ryac 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2bddb3f3efea0d09081975f55f29c156ef437180470e5dc08ef30046dd19b995
-  data.tar.gz: 062e95d78fa295320ef0ea800d01aa3dff509e9f2c20b341781a06e9ed60671e
+  metadata.gz: 0e028fd595a5109347a3c20ddca86a61fa1ade6a043276471e771ab60c4723a9
+  data.tar.gz: aa11c81ee53ce49056f8f7dfd2679549b75855e9b4a912558e461d80348ef79a
 SHA512:
-  metadata.gz: 308731a116d5765d712d85be56b819821345847b21cdb1feb591a34071c865f0073addb6e36de31d21c117138e74b6967068fb1e4e5d897176b4a4edff44d5f6
-  data.tar.gz: bcd1419c8b24b9f718e20a0b529636b265ecf531689d0468920f101d10f82e10e5019da28ac183a31fe5fa8c072cbd2f00ff1e9f78b5525b916009adf971ad42
+  metadata.gz: 980ad6bcee3e5db39ee429715b10555e831401b1fcd18f5f918d7128d4548c33185a441c5bb8b7554f0836f15b677067119e9a1cc26b8b8bd06a4ea488ba6e3e
+  data.tar.gz: b847884f580ed660733e9d23fa71aa706257257771f7a1e1bf3cc2c27801e400e6b38b289adbe7498e574c984c9627a1e91676470f465550322b79c268938dbe

data/README.md

@@ -4,6 +4,10 @@
 
 A Ruby code minifier that uses [TypeProf](https://github.com/ruby/typeprof) for type-aware analysis and AST-based transformations to achieve high compression rates while preserving functional equivalence.
 
+## Status
+
+ryac is under active development and no interface is settled yet. The architecture — the pipeline stages, the rename policies, the alias and lazy-region mechanisms — and with it the CLI options, the `Ryac::Minifier` API and the shape of the output may all change between releases. Pin an exact version if you depend on any of them.
+
 ## Philosophy
 
 This project takes an **aggressive optimization** approach. In Ruby, even comment removal requires context awareness — for example, `foo\n# comment\n.to_s` works because the comment connects the method chain, but removing it causes a syntax error. Whether a given comment is safe to remove depends entirely on context, making the boundary between safe and unsafe transformations inherently blurry. Since conservative minification is already difficult in Ruby, we choose to optimize as aggressively as possible. TypeProf's type analysis helps make these transformations more informed, but the goal is always maximum compression.
@@ -11,9 +15,10 @@ This project takes an **aggressive optimization** approach. In Ruby, even commen
 ## Features
 
 - **Multi-file support**: Follows `require_relative` and `autoload` to collect and concatenate dependencies into a single output
+- **Dynamic requires**: A `require_relative "driver/#{name}"` inside a method bundles every file under that directory as a lazy region — registered at load, run the moment the require would have run — so a driver's own `require "ffi"` keeps its optional-dependency timing while the whole program shares one rename table (see [Dynamic requires](#dynamic-requires))
 - **Whitespace & comment removal**: Strips all unnecessary whitespace and comments
 - **AST transformations**: Boolean/char shortening, constant folding, control flow simplification, endless methods, parenthesis optimization
-- **Constant aliasing**: Renames user-defined constants and shortens repeated external constant paths
+- **Constant aliasing**: Renames user-defined constants and shortens repeated external constant paths, emitting backward-compat aliases; once a program's dynamically loaded files are bundled, the only reader left outside is a launcher, which spells the class/module skeleton (`Optcarrot::NES.new.run`) and never a value constant — so value-constant aliases are dropped and the skeleton's kept
 - **Variable renaming**: Shortens local variables, keyword arguments, instance/class/global variables
 - **Method renaming**: Shortens method names with `send(:sym)` coordination and attr-backed ivar optimization
 - **Method alias shortening**: Replaces long stdlib method names with shorter aliases (e.g., `collect` → `map`)
@@ -22,6 +27,12 @@ This project takes an **aggressive optimization** approach. In Ruby, even commen
 
 ## Installation
 
+```bash
+gem install ryac
+```
+
+Or in a Gemfile:
+
 ```ruby
 gem 'ryac'
 ```
@@ -32,28 +43,34 @@ gem 'ryac'
 
 ```bash
 # Minify a file (follows require_relative automatically)
-bin/ryac path/to/entry.rb
+ryac path/to/entry.rb
 
 # Specify compression level (stable or unstable)
-bin/ryac path/to/entry.rb -c stable
-bin/ryac path/to/entry.rb -c unstable
+ryac path/to/entry.rb -c stable
+ryac path/to/entry.rb -c unstable
 
 # Write to output file
-bin/ryac path/to/entry.rb -o minified.rb
+ryac path/to/entry.rb -o minified.rb
 
 # Write constant aliases to a separate file
-bin/ryac path/to/entry.rb -o minified.rb -a aliases.rb
+ryac path/to/entry.rb -o minified.rb -a aliases.rb
+
+# Emit a self-extracting packed file (self = zero dependencies, zlib = smaller)
+ryac path/to/entry.rb -o packed.rb --pack self
+
+# Keep the program a pure library and put its lazy regions in a runner
+ryac path/to/entry.rb -o minify.rb --driver driver.rb
 
 # Multiple entry points
-bin/ryac file1.rb file2.rb
+ryac file1.rb file2.rb
 
 # Minify installed gem(s) by name (resolved via Gem::Specification)
-bin/ryac -g rack
-bin/ryac -g rack,rack-session -o bundle.rb
+ryac -g rack
+ryac -g rack,rack-session -o bundle.rb
 
 # Show version / help
-bin/ryac -v
-bin/ryac -h
+ryac -v
+ryac -h
 ```
 
 ### Ruby API
@@ -80,21 +97,58 @@ There are exactly two levels, named for their promise. The default is **`stable`
 
 | Level | Transformations | Promise |
 |-------|----------------|---------|
-| `stable` | AST compaction and folding, constant/class/module renaming with compatibility aliases, external prefix aliasing, local/keyword/instance/class/global variable renaming | Verified frame-for-frame on a real program (Optcarrot). Sound under closed-world analysis; reflection over *names the program renames* is the caveat. |
-| `unstable` | + Method renaming, attr-backed ivar coordination | A program can defeat method renaming by construction (names inside strings, `eval`'d source, `send(computed)`), so this works only when the program plays along. Verified by self-hosting. |
+| `stable` | AST compaction and folding, constant/class/module renaming with compatibility aliases, external prefix aliasing, local/keyword/instance/class/global variable renaming, and method renaming under the `:safe` policy — a name is renamed only when type inference resolved every caller and no dynamic escape hatch (a string mention, a dynamic-ivar class, an uncalled def) touches it; attr declarations, their backing ivars and their call sites move together | Verified frame-for-frame on a real program (Optcarrot). Sound under closed-world analysis; reflection over *names the program renames* is the caveat. |
+| `unstable` | The same stages; method renaming switches to `:aggressive`, which also renames names whose callers type inference could not resolve, betting that a same-named call is the same method | A program can defeat that bet by construction (names inside strings, `eval`'d source, `send(computed)`), so this works only when the program plays along. Verified by self-hosting. |
 
 Finer configurations are not levels: the pipeline is built from steps, and callers can pass an explicit stage list in place of a level name (`Minifier#call(path, level: [...stage defs...])`). The unit tests pin each step's behavior through exactly that mechanism.
 
+### Dynamic requires
+
+A file the program loads by a computed path — optcarrot's `require_relative "driver/#{name}_#{type}"` inside `Driver.load_each` — is outside any static dependency graph, yet it runs against the program: subclassing its classes, reading its instance variables, overriding its methods. Renaming one side and not the other breaks exactly there. When the computed path starts with a static directory, ryac bundles every `.rb` file under it (and whatever those files require that nothing static did) into the same closed world, so the rename table covers both sides, and writes each as a *lazy region*:
+
+```ruby
+RYAC_LAZY["optcarrot/driver/sdl2_video"] = -> { ...the file, minified... }
+```
+
+The region's body runs when the original require would have run — a short loader keeps Ruby's contract (once and `true`, `false` on a repeat, a failed run stays retryable, an unregistered path falls through to a real `require_relative` relative to the bundle), and the require sites are rewritten to call it. So `require "ffi"` and `ffi_lib "SDL2"` at a driver's top level still execute only when that driver is selected, and the auto-selection's `rescue LoadError` still walks on to the next one.
+
+The output is still one file. For optcarrot, it stands in for `lib/optcarrot.rb` under upstream's unmodified `bin/optcarrot`:
+
+```bash
+ryac gem_tests/optcarrot/lib/optcarrot.rb -o /path/to/optcarrot/lib/optcarrot.rb
+cd /path/to/optcarrot && bin/optcarrot examples/Lan_Master.nes
+```
+
+A constant only a region defines (`SDL2Video`, the `SDL2` module) keeps its name — it does not exist until the region runs, so no alias at the end of the file could restore it — and an external constant a region references is never hoisted into the preamble. Neither costs much: a region's own names are few, and its references to the core rename like everything else.
+
+Or keep the program a pure library and put the regions in a runner of their own:
+
+```bash
+ryac gem_tests/optcarrot/lib/optcarrot.rb -o minify.rb --driver driver.rb
+ruby driver.rb minify.rb --exec "Optcarrot::NES.new.run" examples/Lan_Master.nes
+```
+
+`minify.rb` is the loader, the core and its aliases — nothing that runs. `driver.rb` loads it, registers the regions and evals the `--exec` expression at top level, its own two arguments already gone from `ARGV` so the program's option parsing sees only what follows (anything after `--` is never read). The split assumes the program loads its dynamic files after boot, from a method — the shape that made them lazy; a dynamic require the core ran while loading would miss its region. The expression is code outside the bundle, so it can spell only what survives outside: the class/module skeleton, which the aliases restore, and methods the program itself never calls — under `stable`'s safe policy an uncalled def keeps its name, and a launcher's entry point (`NES#run`) is exactly that. `--driver` needs `-o`, and cannot be combined with `-a` or with `--pack` (a packed core cannot be loaded).
+
+### Packed output
+
+`--pack` is an output format, orthogonal to the levels: it wraps the minified program in a self-extracting stub — a short plain-Ruby decoder followed by the compressed bytes after `__END__`. On optcarrot it takes the artifact from 37% of the original source to 19.4% (`self`) or 15.1% (`zlib`).
+
+- `--pack self` inlines a pure-Ruby LZSS decoder (282 bytes) — no `require` at all, runs anywhere Ruby runs
+- `--pack zlib` deflates via the zlib default gem — smaller, but dead on a Ruby built without it
+
+A packed file is a main-program format: the stub reads its own `__END__` data and `eval`s the program with `$0` as the file name, so `ruby packed.rb` runs it and a `$PROGRAM_NAME == __FILE__` launcher still fires. It cannot be `require`d — only the main script has `DATA` — and a program that itself uses `__END__` or reads `DATA` is refused with an error.
+
 See [`tests/ryac/pipeline/`](tests/ryac/pipeline/) for per-stage transformation examples, and [`tests/ryac/levels/`](tests/ryac/levels/) for end-to-end compression examples.
 
 ### What the levels are verified against
 
 The supported boundary is defined by two programs, both verified in CI:
 
-- **[Optcarrot](https://github.com/mame/optcarrot) at `stable`** — the minified emulator matches the original frame-for-frame across the 180-frame demo and three scripted play scenarios (1,820 frames of title menus, piece rotation, pausing and button mashing) ([`tests/test_optcarrot.rb`](tests/test_optcarrot.rb))
+- **[Optcarrot](https://github.com/mame/optcarrot) at `stable`** — the minified emulator matches the original frame-for-frame across the 180-frame demo and three scripted play scenarios (1,820 frames of title menus, piece rotation, pausing and button mashing), and, standing in for `lib/optcarrot.rb` under upstream's own `bin/optcarrot`, its bundled png and wav drivers write the same frame and samples as the original's ([`tests/test_optcarrot.rb`](tests/test_optcarrot.rb))
 - **This minifier itself at `unstable`** — the minified minifier re-minifies the original source to identical output, and minifying its own output is a byte-identical fixed point ([`tests/test_integration.rb`](tests/test_integration.rb))
 
-Whether `unstable` holds for a given program depends on the program. Optcarrot stops at `stable` because it defeats method renaming by construction: it builds its CPU/PPU cores as source strings and `eval`s them, scans that text for `@ivar` names with a regexp, and dispatches through `send(computed_symbol)` — method names survive inside strings, out of reach of static analysis. The sinatra and rubocop suites run in CI as regression canaries on a keyword-only step composition, but they sit outside this boundary and do not define it.
+Whether `unstable` holds for a given program depends on the program. Optcarrot stops at `stable` because it defeats aggressive method renaming by construction: it builds its CPU/PPU cores as source strings and `eval`s them, scans that text for `@ivar` names with a regexp, and dispatches through `send(computed_symbol)` — method names survive inside strings, out of reach of static analysis. The sinatra and rubocop suites run in CI as regression canaries on a keyword-only step composition, but they sit outside this boundary and do not define it.
 
 ## Development
 
@@ -133,7 +187,7 @@ FileCollector → Concatenator → StageRunner (Compactor → stage list) → Ou
 2. **Concatenator** — Topologically sorts files and concatenates them into a single source
 3. **StageRunner** — Compacts the source (AST rebuilt into minimal whitespace form), then walks the level's ordered stage list. Every stage implements one contract — `needs_analysis?` / `fixpoint?` / `collect(ctx, patches)` / `finish(ctx)` — and phase is list position:
    - **Syntactic stages** (no analysis): `ControlFlowSimplify`, `EndlessMethod`, `ConstantFold`, `BooleanShorten`, `CharShorten` before the rename batch; `ParenOptimizer` after it
-   - **Analysis stages**: `ConstantAliaser`, `AttrDeclShorten`, `VariableRenamer` (plus `MethodRenamer` at `unstable`) — consecutive analysis stages form one batch sharing a single TypeProf pass, and the runner rejects a list that would need two
+   - **Analysis stages**: `ConstantAliaser`, `AttrDeclShorten`, `VariableRenamer`, `MethodRenamer` (`:safe` at `stable`, `:aggressive` at `unstable`) — consecutive analysis stages form one batch sharing a single TypeProf pass, and the runner rejects a list that would need two
 
 ## Dependencies
 

data/Steepfile

@@ -5,5 +5,7 @@ target :lib do
 
   check "lib"
 
+  library "zlib"
+
   collection_config "rbs_collection.yaml"
 end

data/bin/ryac

@@ -8,7 +8,9 @@ options = {
   output: nil,
   aliases: nil,
   level: nil,
-  gems: nil
+  gems: nil,
+  pack: nil,
+  driver: nil
 }
 
 parser = OptionParser.new do |opts|
@@ -36,6 +38,20 @@ parser = OptionParser.new do |opts|
     end
   end
 
+  opts.on("-p", "--pack FORMAT", "Emit a self-extracting file (self or zlib)") do |value|
+    begin
+      options[:pack] = Ryac::Packer.resolve_format(value)
+    rescue ArgumentError => e
+      warn "Error: #{e.message}"
+      warn opts
+      exit 1
+    end
+  end
+
+  opts.on("-d", "--driver FILE", "Write the lazy regions to FILE as a runner (ruby FILE CORE --exec EXPR)") do |file|
+    options[:driver] = file
+  end
+
   opts.on("-h", "--help", "Display this help message") do
     puts opts
     exit 0
@@ -55,6 +71,21 @@ rescue OptionParser::InvalidOption => e
   exit 1
 end
 
+if options[:driver]
+  unless options[:output]
+    warn "Error: --driver needs -o for the core file"
+    exit 1
+  end
+  if options[:aliases]
+    warn "Error: --driver cannot be combined with -a (the runner loads the core with its aliases)"
+    exit 1
+  end
+  if options[:pack]
+    warn "Error: --driver cannot be combined with --pack (a packed core cannot be loaded)"
+    exit 1
+  end
+end
+
 if options[:gems]
   unless ARGV.empty?
     warn "Error: Cannot specify both --gem and file arguments"
@@ -108,9 +139,17 @@ begin
     result.full_content
   end
 
+  content = Ryac::Packer.pack(content, options[:pack]) if options[:pack]
+
+  if options[:driver]
+    content, driver = Ryac::DriverFile.split(content)
+    File.write(options[:driver], driver)
+  end
+
   if options[:output]
-    File.write(options[:output], content)
+    File.binwrite(options[:output], content)
   else
+    $stdout.binmode if options[:pack]
     puts content
   end
 

data/lib/ryac/analysis/constant/collection.rb

@@ -101,6 +101,52 @@ module Ryac
         (value.name == :define && receiver.name == :Data)
     end
 
+    # A constant only a lazy region defines does not exist until the region
+    # runs, so no alias for it could execute at the end of the file: it keeps
+    # its name, and `Optcarrot.const_get(:SDL2Video)` finds it as written. A
+    # constant the flat code defines too is merely reopened by the region
+    # and renames as usual.
+    def exclude_lazy_definitions(prism_root)
+      return if @lazy_regions.empty?
+
+      flat = Set.new #: Set[Array[Symbol]]
+      lazy = Set.new #: Set[Array[Symbol]]
+      each_constant_event(prism_root) do |kind, node, cpath, _singleton, _in_def|
+        next unless cpath && (kind == :class_def || kind == :write)
+
+        (LazyRegions.contains?(@lazy_regions, node) ? lazy : flat) << cpath
+      end
+      (lazy - flat).each { |cpath| @constant_mapping.exclude_path(cpath) }
+    end
+
+    # `expr::NAME` reads a constant on a scope only the running program
+    # knows — `self.class::OPTIONS` in an included helper lands on whichever
+    # class included it — so no static path stands in for the reference and
+    # the name in the text is the name looked up. Every user constant called
+    # NAME keeps its name, so any of them can be the one meant.
+    def exclude_dynamic_root_reads(prism_root)
+      names = Set.new #: Set[Symbol]
+      each_constant_event(prism_root) do |kind, node, _cpath, _singleton, _in_def|
+        next unless kind == :read && node.is_a?(Prism::ConstantPathNode) && dynamic_root?(node)
+
+        name = node.name
+        names << name if name
+      end
+      return if names.empty?
+
+      pinned = [] #: Array[Array[Symbol]]
+      @constant_mapping.each_user_defined_path { |cpath| pinned << cpath if names.include?(cpath.last) }
+      pinned.each { |cpath| @constant_mapping.exclude_path(cpath) }
+    end
+
+    # A path whose outermost parent is neither a constant nor absent (`::X`)
+    # — `self::X`, `self.class::X`, `klass::X`.
+    def dynamic_root?(node)
+      current = node.parent
+      current = current.parent while current.is_a?(Prism::ConstantPathNode)
+      !(current.nil? || current.is_a?(Prism::ConstantReadNode))
+    end
+
     def collect_constants(prism_root)
       each_constant_event(prism_root) do |kind, node, cpath, singleton, in_def|
         case kind
@@ -224,6 +270,9 @@ module Ryac
       each_constant_event(prism_root) do |kind, node, _cpath, _singleton, _in_def|
         next unless kind == :read
         next if counted_prefix_ids.include?(node.object_id)
+        # A region's reference resolves when the region runs — after its own
+        # requires. A preamble alias for it would resolve at boot.
+        next if LazyRegions.contains?(@lazy_regions, node)
 
         mark_chain_prefixes(node, counted_prefix_ids)
         prefix = external_prefix_for(node)

data/lib/ryac/analysis/constant/rename_mapping.rb

@@ -58,8 +58,13 @@ module Ryac
     # minifier's own process, which over-approximates: everything the
     # minifier has loaded — including, under self-hosting, the analyzed
     # program itself — then looks like a reopening.
-    def initialize(boot_roots: nil)
+    #
+    # alias_surface: which renames the alias block restores — :full, every
+    # one, or :skeleton, classes and modules only. See
+    # generate_alias_declarations.
+    def initialize(boot_roots: nil, alias_surface: :full)
       @boot_roots = boot_roots
+      @alias_surface = alias_surface
       @mappings = {}           # Hash<Array<Symbol>, ConstantInfo> - key is static_cpath
       # keyed by the last path segment
       @by_name = {}
@@ -205,8 +210,17 @@ module Ryac
     # Generate backward-compatible alias declarations for renamed constants.
     # Returns array of strings like "OriginalName=ShortName" or
     # "ShortParent::OriginalName=ShortParent::ShortName" for nested constants.
+    #
+    # With the :full surface every rename stays restorable: nothing says
+    # which original names code outside the analyzed world spells. A program
+    # that dynamically loads files at runtime had enumerated its external
+    # readers, and bundling them as lazy regions brought every one inside;
+    # what remains outside is a launcher, and a launcher spells the
+    # class/module skeleton (`Optcarrot::NES.new.run`), never a value
+    # constant. That is the :skeleton surface.
     def generate_alias_declarations
       renamed = @mappings.values.select(&:short_name).sort_by { |info| [info.full_path.size, info.full_path] }
+      renamed.reject! { |info| info.definition_type == :value } if @alias_surface == :skeleton
       renamed.filter_map { |info| build_alias_declaration(info) }
     end
 

data/lib/ryac/analysis/ivar/collection.rb

@@ -23,16 +23,42 @@ module Ryac
         case node
         when Prism::InstanceVariableReadNode, *IVAR_WRITE_NODES
           # @type var node: Prism::InstanceVariableReadNode | ivar_write_node
-          next if attr_backed[cpath]&.include?(node.name)
+          next if attr_backed_ivar?(attr_backed, cpath, node.name)
           @ivar_rename_mapping.add_site(cpath, node.name, node)
         end
       end
     end
 
+    # An attr declared anywhere up the chain backs the ivar in every
+    # descendant: a subclass's `@palette = ...` fills the slot the
+    # ancestor's `attr_reader :palette` reads. Those sites belong to the
+    # attr coordination (which follows the declaring ancestor), not to plain
+    # ivar renaming — which would give the subclass its own name for the
+    # slot and leave the reader looking at nothing.
+    def attr_backed_ivar?(attr_backed, cpath, name)
+      backed = false
+      @oracle.each_ancestor_cpath(cpath, false) do |ancestor_cpath|
+        backed ||= attr_backed.fetch(ancestor_cpath, nil)&.include?(name) || false
+      end
+      backed || (attr_backed.fetch(cpath, nil)&.include?(name) || false)
+    end
+
+    # The attr-backed ivar names per class, closed upward through the
+    # program's own classes: an attr declared in D backs the slot in every
+    # ancestor of D the program defines, since a write there (`@label_text =
+    # ...` in a base class) fills what D's reader reads. Object and the rest
+    # of the built-in chain write nothing and are not closed over — they
+    # would make every attr back every class's ivar of that name.
     def collect_attr_backed_ivars(prism_root)
+      defined = Set.new #: Set[Array[Symbol]]
+      each_constant_event(prism_root) { |kind, _node, cpath, _singleton, _in_def| defined << cpath if kind == :class_def && cpath }
+
       result = Hash.new { |h, k| h[k] = Set.new } #: Hash[Array[Symbol], Set[Symbol]]
       each_attr_declaration(prism_root, ATTR_DECLARATION_METHODS, require_class_body: false) do |_node, cpath, _singleton, sym|
         result[cpath] << :"@#{sym}"
+        @oracle.each_ancestor_cpath(cpath, false) do |ancestor_cpath|
+          result[ancestor_cpath] << :"@#{sym}" if defined.include?(ancestor_cpath)
+        end
       end
       result
     end
@@ -151,7 +177,7 @@ module Ryac
       used_ivar_names = @ivar_rename_mapping.node_mapping.values.to_set
       used_ivar_names.merge(path_a_mapping.values)
       used_method_names = rename_map.values.to_set
-      scope_vars = MethodRenameMapping.build_scope_vars(@scope_mappings)
+      scope_vars = @scope_visible_names
       generator = NameGenerator.new(prefix: "@")
 
       path_b_info

data/lib/ryac/analysis/lazy_regions.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Ryac
+  # A file the program loads at runtime through a dynamic require
+  # (optcarrot's `require_relative "driver/#{name}_#{type}"`) is bundled by
+  # the Concatenator as a registration:
+  #
+  #   RYAC_LAZY["optcarrot/driver/sdl2_video"] = -> { <the file> }
+  #
+  # The lambda is the file's schedule and nothing more: its body runs when
+  # the original require would have, so a `require "ffi"` or `ffi_lib
+  # "SDL2"` at the file's top level keeps its optional-dependency timing.
+  # For analysis the body is ordinary code in the closed world — one rename
+  # table across the core and the files that subclass it.
+  #
+  # Two things about a region are special. TypeProf does not register a
+  # class defined inside a block, so it is handed a view of the source with
+  # the wrapper bytes blanked (typeprof_view): every byte of the body keeps
+  # its position, and the body reads as the top-level code it becomes when
+  # it runs. And a region does not exist at boot: a constant it alone
+  # defines cannot be aliased at the end of the file, and an external
+  # constant it references cannot be hoisted into the preamble.
+  #
+  # Regions are recognized by shape — a top-level `Const["key"] = -> { ... }`
+  # statement with a parameterless lambda — not by the registry's name,
+  # which the aliaser renames like any other constant. Reading a program's
+  # own statement of that shape as a region is safe: every consequence keeps
+  # more names, never fewer.
+  module LazyRegions
+    module_function
+
+    # The lambdas of every registration, in source order.
+    def collect(prism_root)
+      lambdas = [] #: Array[Prism::LambdaNode]
+      each_registration(prism_root) { |_statement, lambda_node| lambdas << lambda_node }
+      lambdas
+    end
+
+    def contains?(lambdas, node)
+      offset = node.location.start_offset
+      lambdas.any? { |lam| offset > lam.opening_loc.start_offset && offset < lam.closing_loc.start_offset }
+    end
+
+    # The source as TypeProf must read it: each registration's wrapper —
+    # `["key"] = -> {` after the registry constant, and the closing `}` —
+    # replaced by spaces, newlines kept, so the body sits at top level at
+    # its original byte positions. The registry constant stays, as its own
+    # statement: it is a reference the aliaser renames like any other, and
+    # it has to be renamed at the registration too.
+    def typeprof_view(content, prism_root)
+      bytes = content.b
+      each_registration(prism_root) do |statement, lambda_node|
+        # statement.receiver is the registry constant (registration_lambda)
+        from = statement.receiver.location.end_offset # steep:ignore NoMethod
+        blank(bytes, from, lambda_node.opening_loc.end_offset)
+        bytes.setbyte(from, 0x3b)
+        blank(bytes, lambda_node.closing_loc.start_offset, lambda_node.closing_loc.end_offset)
+      end
+      bytes.force_encoding(content.encoding)
+    end
+
+    def each_registration(prism_root)
+      prism_root.statements.body.each do |statement|
+        lambda_node = registration_lambda(statement)
+        yield statement, lambda_node if lambda_node
+      end
+    end
+
+    def registration_lambda(statement)
+      return nil unless statement.is_a?(Prism::CallNode) && statement.name == :[]=
+      return nil unless statement.receiver.is_a?(Prism::ConstantReadNode)
+
+      args = statement.arguments&.arguments
+      return nil unless args && args.size == 2
+
+      key, value = args
+      return nil unless key.is_a?(Prism::StringNode) && value.is_a?(Prism::LambdaNode)
+      return nil if value.parameters
+
+      value
+    end
+
+    def blank(bytes, from, to)
+      (from...to).each { |i| bytes.setbyte(i, 0x20) unless bytes.getbyte(i) == 0x0a }
+    end
+  end
+end