rigortype 0.3.8 → 0.3.9

data/lib/rigor/rbs_extended.rb

@@ -92,23 +92,60 @@ module Rigor
       end
     end
 
+    # The shared empty answers of the per-method readers. Dispatch consults the three readers on every RBS
+    # method it resolves (~150k each on the lib self-check) and nearly every method carries no `rigor:v1:`
+    # annotation, so a fresh `[]` / `{}` per decline was pure allocation. Callers never mutate a reader's
+    # result (`read_flow_contribution` selects into fresh arrays; the override map is documented read-only).
+    NO_DIRECTIVES = [].freeze
+    private_constant :NO_DIRECTIVES
+    NO_OVERRIDES = {}.freeze
+    private_constant :NO_OVERRIDES
+
+    # `%a{rigor:v1:inferred-return}` — the declaration states the member's presence and its parameters and
+    # says nothing about what it returns, so the return comes from the body. Normative in
+    # `docs/type-specification/rbs-extended.md`.
+    INFERRED_RETURN_DIRECTIVE = "rigor:v1:inferred-return"
+
     module_function
 
+    # Whether `method_def` declares its return type inferred rather than contracted (issue #823).
+    #
+    # The producer is `rigor-rbs-inline`: inside a file that carries one annotation, upstream rbs-inline
+    # emits a `(untyped, …) -> untyped` skeleton for every unannotated `def` too, and an accepted signature
+    # outranks body inference — so one annotation used to retype every sibling in its file to `untyped`.
+    # The plugin now marks exactly the type slots it DEFAULTED, and {MethodDispatcher::RbsDispatch} declines
+    # a marked member so the call takes the same body-inference tier an undeclared method takes. Nothing
+    # else about the declaration changes: the class keeps its full method surface, `new` keeps its arity,
+    # and cross-file references still resolve.
+    #
+    # Reads `RBS::Definition::Method#annotations`, so it answers for an inherited member too, and a
+    # hand-written `.rbs` may carry the annotation for the same effect.
+    #
+    # @param method_def — an `RBS::Definition::Method`, or anything else answering `#annotations`.
+    def inferred_return?(method_def)
+      return false if method_def.nil?
+
+      annotations = method_def.annotations
+      return false if annotations.nil? || annotations.empty?
+
+      annotations.any? { |annotation| annotation.string.to_s.strip == INFERRED_RETURN_DIRECTIVE }
+    end
+
     # Reads RBS::Extended predicate effects off `RBS::Definition::Method#annotations`. Returns the effects in
     # source order; duplicates and unrecognised `rigor:v1:` directives are dropped. Returns an empty array (NEVER
     # `nil`) for a method with no recognised annotations so callers can iterate unconditionally.
     #
-    # @param environment [Rigor::Environment, nil] ADR-13 slice
+    # @param environment — ADR-13 slice
     #   3b. When provided, threads the plugin-supplied
     #   `name_scope:` and the per-run reporter through the
     #   annotation-parse path. `nil` (default) preserves the
     #   pre-slice-3b behaviour — no plugin resolvers consulted
     #   and no diagnostics accumulated.
     def read_predicate_effects(method_def, environment: nil)
-      return [] if method_def.nil?
+      return NO_DIRECTIVES if method_def.nil?
 
       annotations = method_def.annotations
-      return [] if annotations.nil? || annotations.empty?
+      return NO_DIRECTIVES if annotations.nil? || annotations.empty?
 
       name_scope = environment&.name_scope
       reporter = environment&.rbs_extended_reporter
@@ -127,10 +164,11 @@ module Rigor
     end
 
     # The right-hand side accepts either a Capitalised class name (with optional `~` negation, optional `::`
-    # prefix, qualified names) OR a kebab-case refinement payload routed through
-    # `Builtins::ImportedRefinements::Parser` (bare names, `name[T]`, `name<min, max>`). The two arms share the
-    # same overall directive shape; the parser detects which form matched by looking at the `class_name` vs
-    # `refinement` capture groups.
+    # prefix, qualified names) OR a refinement payload routed through
+    # `Builtins::ImportedRefinements::Parser` (bare kebab-case names, `name[T]`, the numeric range form
+    # `Integer[1..10]`, and the deprecated `name<min, max>`). The two arms share the same overall directive
+    # shape; the parser detects which form matched by looking at the `class_name` vs `refinement` capture
+    # groups. A class head followed by a bracketed range literal is a refinement (ADR-109), not a class name.
     PREDICATE_DIRECTIVE_PATTERN = /
       \A
       rigor:v1:(?<directive>predicate-if-(?:true|false))
@@ -141,7 +179,7 @@ module Rigor
       (?:
         (?<class_name>(?:::)?[A-Z][A-Za-z0-9_]*(?:::[A-Z][A-Za-z0-9_]*)*)
         |
-        (?<refinement>[a-z][a-z0-9-]*(?:[\[<][^\]>]*[\]>])?)
+        (?<refinement>[a-z][a-z0-9-]*(?:[\[<][^\]>]*[\]>])?|[A-Z][A-Za-z0-9_]*\[[^\]]*\.\.[^\]]*\])
       )
       \s*
       \z
@@ -183,10 +221,10 @@ module Rigor
     #
     # See {.read_predicate_effects} for the `environment:` keyword contract.
     def read_assert_effects(method_def, environment: nil)
-      return [] if method_def.nil?
+      return NO_DIRECTIVES if method_def.nil?
 
       annotations = method_def.annotations
-      return [] if annotations.nil? || annotations.empty?
+      return NO_DIRECTIVES if annotations.nil? || annotations.empty?
 
       name_scope = environment&.name_scope
       reporter = environment&.rbs_extended_reporter
@@ -214,7 +252,7 @@ module Rigor
       (?:
         (?<class_name>(?:::)?[A-Z][A-Za-z0-9_]*(?:::[A-Z][A-Za-z0-9_]*)*)
         |
-        (?<refinement>[a-z][a-z0-9-]*(?:[\[<][^\]>]*[\]>])?)
+        (?<refinement>[a-z][a-z0-9-]*(?:[\[<][^\]>]*[\]>])?|[A-Z][A-Za-z0-9_]*\[[^\]]*\.\.[^\]]*\])
       )
       \s*
       \z
@@ -352,7 +390,8 @@ module Rigor
 
     # The trailing payload supports the full refinement grammar in `Builtins::ImportedRefinements::Parser` — bare
     # kebab-case names plus parameterised forms like `non-empty-array[Integer]`, `non-empty-hash[Symbol,
-    # Integer]`, and `int<5, 10>`. The directive head is consumed by the regex; the rest is forwarded to the
+    # Integer]`, `Integer[5..10]`, and the deprecated `int<5, 10>`. The directive head is consumed by the regex;
+    # the rest is forwarded to the
     # refinement parser. Anything the parser cannot resolve falls back to nil so the call site keeps the
     # RBS-declared return type.
     RETURN_DIRECTIVE_PATTERN = /
@@ -449,7 +488,7 @@ module Rigor
 
     # Returned for `rigor:v1:param: <name> <refinement>`. The parameter name is a Ruby identifier (Symbol); the
     # type is any `Rigor::Type` the refinement parser resolves (bare kebab-case name, parameterised form, or
-    # `int<...>` range — the same grammar the `return:` directive accepts).
+    # `Integer[a..b]` range, or the deprecated `int<a, b>` — the same grammar the `return:` directive accepts).
     ParamOverride = Data.define(:param_name, :type)
 
     # Reads every `rigor:v1:param: <name> <refinement>` directive off `RBS::Definition::Method#annotations` and
@@ -469,10 +508,10 @@ module Rigor
     # argument-check purposes; passing a too-wide `Nominal[String]` argument is flagged as an argument-type
     # mismatch at the call site.
     def read_param_type_overrides(method_def, environment: nil)
-      return [] if method_def.nil?
+      return NO_DIRECTIVES if method_def.nil?
 
       annotations = method_def.annotations
-      return [] if annotations.nil? || annotations.empty?
+      return NO_DIRECTIVES if annotations.nil? || annotations.empty?
 
       name_scope = environment&.name_scope
       reporter = environment&.rbs_extended_reporter
@@ -491,9 +530,10 @@ module Rigor
     # frozen Hash<Symbol, Rigor::Type>; missing keys mean "use the RBS-declared type". Callers MUST treat the
     # hash as read-only.
     def param_type_override_map(method_def, environment: nil)
-      read_param_type_overrides(method_def, environment: environment)
-        .to_h { |o| [o.param_name, o.type] }
-        .freeze
+      overrides = read_param_type_overrides(method_def, environment: environment)
+      return NO_OVERRIDES if overrides.empty?
+
+      overrides.to_h { |o| [o.param_name, o.type] }.freeze
     end
 
     # The `is` glue word is optional so authors can write either `param: id is non-empty-string` (consistent with
@@ -708,9 +748,9 @@ module Rigor
     # `RBS::Extended` conflict channel) rather than silently resolved. Returns `nil` when the list
     # carries neither spelling.
     #
-    # @param annotations [Array<#string>] the node's annotations, in source order.
-    # @param owner_key [String] the method key (`Class#m` / `Class.m`) or class name the bound binds.
-    # @param source [Symbol] {Effects::Envelope::SOURCES} member to stamp when the labelled spelling
+    # @param annotations — the node's annotations, in source order.
+    # @param owner_key — the method key (`Class#m` / `Class.m`) or class name the bound binds.
+    # @param source — {Effects::Envelope::SOURCES} member to stamp when the labelled spelling
     #   matched; `%a{pure}` always stamps `:pure_annotation`, and a class-level read overrides both.
     def read_effect_envelope(annotations, owner_key:, source: :effect_annotation, registry: nil, reporter: nil)
       return nil if annotations.nil? || annotations.empty?

data/lib/rigor/reflection/constant_path.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Rigor
+  # {Reflection}'s second constant-resolution phase, split out for the reader rather than for the
+  # loader: `reflection.rb` asks what a whole spelling names under a series of prefixes, and this file
+  # asks what a PATH names segment by segment. Reopening the module rather than nesting under it keeps
+  # the walk inside the facade its callers already read, and lets it use the same private candidate
+  # lookups (`constant_type_at`, `enclosing_class_path`, `ancestor_constant_scopes`) the ladder uses.
+  module Reflection
+    module_function
+
+    # Issue #656 — Ruby's lookup for an as-written, unrooted constant PATH (`A::B`, `A::B::C`), which is
+    # a different question from "what does this whole string name under some prefix". Ruby resolves the
+    # FIRST segment through the ladder a bare name gets — `Module.nesting`, then the enclosing class's
+    # ancestors, then the top level — and then resolves each LATER segment inside the constant the
+    # previous segment produced, searching THAT constant's own ancestors in turn. So `A::B` written in
+    # `P::Guard` with `P::A < P::Base` names `P::Base::B`, while every whole-path candidate
+    # (`P::Guard::A::B`, `P::A::B`, `A::B`) either misses or names a real but different class.
+    #
+    # `known` decides the FINAL segment only, so the constant typer (any constant, values included) and
+    # `Inference::Narrowing`'s class-guard resolver (classes only) share one walk without sharing an
+    # acceptance test — the two cannot answer different names for the same spelling. Every earlier
+    # segment must name a namespace, because only a namespace can own the next one.
+    #
+    # Returns nil for a single-segment name — the callers' own ladders already own that case — and the
+    # moment any segment declines. Declining hands the caller back its unchanged fallback instead of a
+    # guess: a walk that finds the WRONG constant is worse than the wrong constant answered today
+    # (AGENTS.md § "Implementation Guidelines").
+    #
+    # Checked against MRI 4.0.5 rather than recollection: a later segment does NOT reach the top level
+    # for either a Class or a Module owner (`P::Mod::B` raises `NameError` where a top-level `B`
+    # exists), which is why {.constant_in_namespace} consults the owner's ancestors and stops. Rigor
+    # still lets its callers fall through to their own top-level rung there — that read raises at
+    # runtime and Rigor reports nothing about it either way, so retracting the resolution would trade a
+    # silent wrong answer for a silent absent one at no gain (the same reasoning as
+    # {.toplevel_first_constant_type}'s caller-derived rungs).
+    def resolve_constant_path_name(name, scope, &known)
+      segments = name.to_s.split("::")
+      return nil unless segments.size > 1
+
+      owner = path_head_owner(segments.first, scope)
+      last = segments.size - 1
+      segments.each_with_index do |segment, index|
+        next if index.zero?
+        return nil if owner.nil?
+
+        owner = constant_in_namespace(owner, segment, scope) do |candidate|
+          index == last ? known.call(candidate) : namespace_known?(candidate, scope)
+        end
+      end
+      owner
+    end
+
+    # Step 2.5's rung as a type: the segment-wise name, then that name looked up like any other
+    # candidate so the answer comes from the same source-precedence order as every other rung.
+    def constant_path_type(name, scope)
+      qualified = resolve_constant_path_name(name, scope) { |candidate| constant_type_at(candidate, scope) }
+      qualified && constant_type_at(qualified, scope)
+    end
+    private_class_method :constant_path_type
+
+    # The namespace a path's FIRST segment names — the bare-name ladder, restricted to answers that can
+    # OWN the segments that follow. A value constant is not one of them, so it declines here rather
+    # than producing a namespace prefix no source knows.
+    def path_head_owner(head, scope)
+      hit = first_namespace_hit(lexical_nesting_chain(scope), head, scope)
+      return hit if hit
+
+      prefix = enclosing_class_path(scope)
+      unless prefix.nil? || prefix.empty?
+        hit = first_namespace_hit(bounded_ancestor_scopes(prefix, scope), head, scope)
+        return hit if hit
+      end
+
+      head if namespace_known?(head, scope)
+    end
+    private_class_method :path_head_owner
+
+    # {.first_constant_hit}'s namespace twin: the first `<entry>::<name>` that can own further segments.
+    def first_namespace_hit(entries, name, scope)
+      entries.each do |entry|
+        candidate = "#{entry}::#{name}"
+        return candidate if namespace_known?(candidate, scope)
+      end
+      nil
+    end
+    private_class_method :first_namespace_hit
+
+    # `segment` looked up inside `owner` and then through `owner`'s own ancestors — Ruby's lookup for
+    # every segment after the first. `Object` is deliberately absent: MRI raises rather than reaching a
+    # top-level constant through an explicit `::` receiver.
+    def constant_in_namespace(owner, segment, scope)
+      candidate = "#{owner}::#{segment}"
+      return candidate if yield(candidate)
+
+      bounded_ancestor_scopes(owner, scope).each do |ancestor|
+        inherited = "#{ancestor}::#{segment}"
+        return inherited if yield(inherited)
+      end
+      nil
+    end
+    private_class_method :constant_in_namespace
+
+    # How many of {.ancestor_constant_scopes}' entries one segment may consult, under
+    # `Scope::ANCESTOR_WALK_LIMIT` — the budget `Scope`'s method lookup already spends on this same
+    # graph, reused rather than re-chosen so one pathological ancestry costs one bound. The list
+    # itself is the memoised one step 2 builds, so this bounds the per-segment consultation the walk
+    # adds and not the graph. Reported through the shared counter, so a truncated walk is visible in a
+    # budget trace instead of looking like a plain miss.
+    def bounded_ancestor_scopes(class_name, scope)
+      scopes = ancestor_constant_scopes(class_name, scope)
+      return scopes if scopes.size <= Scope::ANCESTOR_WALK_LIMIT
+
+      Inference::BudgetTrace.hit(Inference::BudgetTrace::ANCESTOR_WALK_LIMIT)
+      scopes.first(Scope::ANCESTOR_WALK_LIMIT)
+    end
+    private_class_method :bounded_ancestor_scopes
+
+    # Whether `name` can OWN a constant. `class_known?` covers the RBS and registry classes and modules;
+    # the project tables cover a namespace the project declares with no RBS for it.
+    def namespace_known?(name, scope)
+      scope.environment.class_known?(name) || known_project_namespace?(name, scope)
+    end
+    private_class_method :namespace_known?
+  end
+end

data/lib/rigor/reflection.rb

@@ -51,9 +51,6 @@ module Rigor
 
     module_function
 
-    # @param class_name [String, Symbol]
-    # @param scope [Rigor::Scope]
-    # @return [Boolean]
     def class_known?(class_name, scope: Scope.empty)
       return true if scope.discovered_classes.key?(class_name.to_s)
 
@@ -92,7 +89,7 @@ module Rigor
       loader.project_declared_class?(class_name)
     end
 
-    # @return [Symbol] one of `:equal`, `:subclass`, `:superclass`,
+    # @return one of `:equal`, `:subclass`, `:superclass`,
     #   `:disjoint`, `:unknown`.
     def class_ordering(lhs, rhs, scope: Scope.empty)
       scope.environment.class_ordering(lhs, rhs)
@@ -171,9 +168,16 @@ module Rigor
       # § "Implementation Guidelines"). Only project ancestors are walked; an RBS-known superclass
       # contributes no name here (see {.ancestor_constant_scopes}).
       #
+      # Step 2.5 (#656) — the path read SEGMENT BY SEGMENT, which is the only rung that can answer a
+      # path whose head and tail have different owners. See {.resolve_constant_path_name}. It sits
+      # BELOW the whole-path rungs so no read that resolves today moves, and ABOVE step 3 because
+      # beating the top-level whole-string answer is the point: `A::B` inside `P::Guard` with
+      # `P::A < P::Base` is `P::Base::B`, and step 3's `A::B` is a real but different class.
+      #
       # Step 3 — the bare name (top level).
       first_constant_hit(lexical_nesting_chain(scope), name, scope) ||
         ancestor_constant_type(name, scope, enclosing_class_path(scope)) ||
+        constant_path_type(name, scope) ||
         constant_type_at(name, scope)
     end
 
@@ -215,8 +219,12 @@ module Rigor
     # dependabot-core — `docs/notes/20260905-toplevel-def-cref-movable-sites.md`). Rigor reports nothing
     # about them either way, so retracting them would trade a silent wrong answer for a silent absent one at
     # no gain. Making them FIRE is a separate question with its own false-positive budget.
+    #
+    # Issue #656's rung goes LAST here rather than second: for a top-level body Ruby's own first answer
+    # for `A::B` is the top level, and a whole-string hit there already means "`A` owns `B`". The
+    # segment-wise walk only has something to add once that misses.
     def toplevel_first_constant_type(name, scope)
-      constant_type_at(name, scope) || caller_derived_constant_type(name, scope)
+      constant_type_at(name, scope) || caller_derived_constant_type(name, scope) || constant_path_type(name, scope)
     end
     private_class_method :toplevel_first_constant_type
 
@@ -242,11 +250,16 @@ module Rigor
       singleton = env.singleton_for_name(candidate)
       return singleton if singleton
 
+      # Issue #639 — the class-EXISTENCE edge. Without it a reference-only consumer (`Foo` with no call on
+      # it) recorded nothing, so deleting the declaring file left the warm `--incremental` run serving
+      # `singleton(Foo)` where `--no-cache` answers the honest unresolved type. Recorded ahead of the lookup
+      # rather than on the hit: every rung of the ladder spells the same last segment, which is the whole of
+      # the key, so one call covers the candidates instead of a branch around each.
+      scope.record_class_existence(candidate) if Analysis::DependencyRecorder.active?
       in_source_class = scope.discovered_classes[candidate]
       return in_source_class if in_source_class
 
-      in_source_value = scope.in_source_constants[candidate]
-      if in_source_value
+      if (in_source_value = scope.in_source_constants[candidate])
         scope.record_constant_dependency(candidate) if Analysis::DependencyRecorder.active?
         return in_source_value
       end
@@ -465,15 +478,14 @@ module Rigor
     end
     private_class_method :rbs_loader_for
 
-    # @return [Boolean] true when the analyzed source contains a class / module declaration
+    # @return true when the analyzed source contains a class / module declaration
     #   for the given name. Does NOT consult the RBS loader (use {.class_known?} for the
     #   union).
     def discovered_class?(class_name, scope: Scope.empty)
       scope.discovered_classes.key?(class_name.to_s)
     end
 
-    # @param kind [:instance, :singleton]
-    # @return [Boolean] true when the ScopeIndexer recorded a `def` for the given method on
+    # @return true when the ScopeIndexer recorded a `def` for the given method on
     #   the given class with the matching kind.
     #
     # ADR-46 — a MISS records a negative cross-file dependency, so a consumer whose analysis
@@ -497,3 +509,7 @@ module Rigor
     end
   end
 end
+
+# Loaded last: the segment-wise path walk reopens the module above and reads its private candidate
+# lookups, so the facade has to exist first.
+require_relative "reflection/constant_path"

data/lib/rigor/runtime/jit.rb

@@ -70,7 +70,7 @@ module Rigor
       # call is what enabled YJIT (so the `?`-suffix predicate convention does
       # not apply; hence the Naming/PredicateMethod exemption).
       #
-      # @return [Boolean] true if this call enabled YJIT; false if it was a
+      # @return true if this call enabled YJIT; false if it was a
       #   no-op (unavailable / opted out / already enabled).
       def enable_now # rubocop:disable Naming/PredicateMethod
         return false unless available?
@@ -90,8 +90,8 @@ module Rigor
       # up front (unavailable / opted out / already enabled), so callers never
       # pay for a thread that could only no-op.
       #
-      # @param seconds [Numeric] the amortization deadline.
-      # @return [Thread, nil] the deadline thread, or nil when no-op up front.
+      # @param seconds — the amortization deadline.
+      # @return the deadline thread, or nil when no-op up front.
       def enable_after(seconds)
         return nil unless available?
         return nil if disabled?
@@ -143,7 +143,7 @@ module Rigor
       # Re-arming goes through {enable_after}, so the child records the same
       # absolute deadline it inherited and a grandchild fork carries it too.
       #
-      # @return [Thread, nil] the child's deadline thread; nil when YJIT was
+      # @return the child's deadline thread; nil when YJIT was
       #   enabled immediately, and nil when the call is a no-op up front
       #   (unavailable / opted out / already enabled — a child forked after the
       #   parent enabled inherits the enabled state and has nothing to do).
@@ -166,8 +166,6 @@ module Rigor
 
       # The resolved {enable_after} deadline: {DEADLINE_ENV} when it parses to a
       # non-negative float, else {DEFAULT_DEADLINE_SECONDS}.
-      #
-      # @return [Numeric]
       def deadline_seconds
         raw = ENV.fetch(DEADLINE_ENV, nil)
         return DEFAULT_DEADLINE_SECONDS if raw.nil? || raw.empty?
@@ -176,12 +174,12 @@ module Rigor
         value && value >= 0 ? value : DEFAULT_DEADLINE_SECONDS
       end
 
-      # @return [Boolean] whether this Ruby exposes `RubyVM::YJIT.enable`.
+      # @return whether this Ruby exposes `RubyVM::YJIT.enable`.
       def available?
         defined?(RubyVM::YJIT.enable) ? true : false
       end
 
-      # @return [Boolean] whether the opt-out env switch is set.
+      # @return whether the opt-out env switch is set.
       def disabled?
         ENV[DISABLE_ENV] == "1"
       end

data/lib/rigor/scope/discovery_index.rb

@@ -27,10 +27,13 @@ module Rigor
       :discovered_superclasses,
       :discovered_header_nestings,
       :discovered_includes,
+      :discovered_extends,
       :discovered_class_sources,
       :constant_sources,
       :published_constant_names,
       :local_constant_names,
+      :published_constant_alias_names,
+      :published_constant_ivars,
       :data_member_layouts,
       :struct_member_layouts,
       :param_inferred_types,
@@ -52,6 +55,11 @@ module Rigor
       # either kind.
       METHOD_KIND_BOTH = :both
 
+      # Issue #728 — the key a `discovered_header_nestings` bucket stores its class-wide chain under, beside
+      # the per-ancestor-name entries. `nil` is used because every other key in a bucket is an ancestor name
+      # as written, and no ancestor name can be nil.
+      UNKEYED_HEADER_NESTING = nil
+
       # The shared all-empty index `Scope.empty` (and every scope that never sees a seeding pass) points at — one
       # allocation per process.
       EMPTY = new(
@@ -86,8 +94,20 @@ module Rigor
         # name — the peel is the nested spelling's answer, and it searched an `Admin::Base` that a compact
         # `class Admin::Widget < Base` written at the top level never reaches. An absent entry means "not
         # recorded" and keeps the peel, so a scope that never saw a declaration walk is unchanged.
+        #
+        # Issue #728 — the value is keyed by the ancestor NAME the site wrote, because a class's declaration
+        # sites need not share a cref: `class Foo < Base` at the top level and `class ::Foo; include Helper`
+        # inside `module Outer` resolve `Base` and `Helper` in different ones, and a single chain per class
+        # gave `Outer` to both. {UNKEYED_HEADER_NESTING} holds the union over every ancestor-naming site, for
+        # a name no site recorded under its own key.
         discovered_header_nestings: EMPTY_TABLE,
         discovered_includes: EMPTY_TABLE,
+        # Issue #898 — the singleton-side twin of `discovered_includes`: `{qualified class or module name =>
+        # [module names it `extend`s, as written]}`, built by the same `ScopeIndexer` walk that #526 already
+        # ran to fold an extended module's instance defs onto the extending class's singleton. #526 consumed
+        # the table inside the indexer and threw it away; `Narrowing` needs it to survive onto the scope,
+        # because `Singleton[C]`'s ancestry is exactly what `extend` writes and nothing else records it.
+        discovered_extends: EMPTY_TABLE,
         discovered_class_sources: EMPTY_TABLE,
         # Issue #644 — `{qualified constant name => Set[declaring file]}`, the write attribution behind the
         # cross-file value-constant table. Read only by `Scope#record_constant_dependency` during ADR-46
@@ -102,6 +122,16 @@ module Rigor
         # author cannot see. Both empty outside a runner-seeded scope, which makes the guard a no-op there.
         published_constant_names: EMPTY_NAME_SET,
         local_constant_names: EMPTY_NAME_SET,
+        # Issue #667 — the two per-file tables that carry a published constant's provenance across a COPY,
+        # which the name sets above cannot: they answer about a reference's spelling, and a copy has none.
+        # `published_constant_alias_names` is the last segments of the constants THIS FILE assigns straight
+        # from a foreign published one (`MODE2 = AppConfig::MODE`), which the local-declaration exemption
+        # would otherwise release. `published_constant_ivars` is `{class name => Set[ivar name]}` for an ivar
+        # whose class-ivar seed is such a copy (`@mode = AppConfig::MODE` in `initialize`), stamped onto the
+        # flow carrier at method entry. Both are seeded by `ScopeIndexer.index` and only when the project
+        # published something, so a project with no cross-file value constants pays no walk.
+        published_constant_alias_names: EMPTY_NAME_SET,
+        published_constant_ivars: EMPTY_TABLE,
         data_member_layouts: EMPTY_TABLE,
         struct_member_layouts: EMPTY_TABLE,
         # ADR-67 WD3 — the call-site parameter-inference table, keyed by `[class_name, method_name, kind]` (the