diff --git a/.github/scripts/check-tree-sitter-upgrade-readiness.py b/.github/scripts/check-tree-sitter-upgrade-readiness.py
index c4cfa0860..6d26eae4d 100644
--- a/.github/scripts/check-tree-sitter-upgrade-readiness.py
+++ b/.github/scripts/check-tree-sitter-upgrade-readiness.py
@@ -69,6 +69,8 @@ GRAMMARS: dict[str, tuple[str, str, str]] = {
     "tree-sitter-python":     ("tree-sitter/tree-sitter-python",     "master", "src/parser.c"),
     "tree-sitter-ruby":       ("tree-sitter/tree-sitter-ruby",       "master", "src/parser.c"),
     "tree-sitter-rust":       ("tree-sitter/tree-sitter-rust",       "master", "src/parser.c"),
+    # Scoped npm package: the only grammar whose name does not start with "tree-sitter-".
+    "@eagleoutice/tree-sitter-r": ("r-lib/tree-sitter-r",             "main",   "src/parser.c"),
     "tree-sitter-swift":      ("alex-pinkus/tree-sitter-swift",      "main",   "src/parser.c"),
     "tree-sitter-typescript": ("tree-sitter/tree-sitter-typescript", "master",  "typescript/src/parser.c"),
     # Vendored parsers — kept here so the upstream coords for drift
@@ -162,13 +164,15 @@ def read_pinned_grammar_versions() -> dict[str, str]:
 
     Looks at both runtime and optional dependencies. Returns the raw range
     string (e.g. '0.21.4', '^0.23.0', 'file:./vendor/...') so the report can
-    expose how flexible each pin is.
+    expose how flexible each pin is. A grammar is recognised by its package
+    basename, so a scoped package (``@scope/tree-sitter-x``) is included, keyed
+    by its full name.
     """
     pkg = _load_package_json()
     pinned: dict[str, str] = {}
     for section in ("dependencies", "optionalDependencies"):
         for name, spec in (pkg.get(section) or {}).items():
-            if name.startswith("tree-sitter-"):
+            if name.rsplit("/", 1)[-1].startswith("tree-sitter-"):
                 pinned[name] = spec
     return pinned
 
@@ -182,7 +186,7 @@ def read_patched_peers() -> list[tuple[str, str, str]]:
     """
     script = GITNEXUS_DIR / "scripts" / "prepare-tree-sitter-bundle.cjs"
     return re.findall(
-        r"\['(tree-sitter[\w-]*)@([\d.]+)',\s*'([^']+)'\]",
+        r"\['((?:@[\w.-]+/)?tree-sitter[\w-]*)@([\d.]+)',\s*'([^']+)'\]",
         script.read_text(encoding="utf-8"),
     )
 
diff --git a/.github/scripts/test_check_tree_sitter_upgrade_readiness.py b/.github/scripts/test_check_tree_sitter_upgrade_readiness.py
index c75e7caca..b31957c32 100644
--- a/.github/scripts/test_check_tree_sitter_upgrade_readiness.py
+++ b/.github/scripts/test_check_tree_sitter_upgrade_readiness.py
@@ -38,8 +38,10 @@ _spec.loader.exec_module(readiness)  # type: ignore[union-attr]
 # The exact row-diff regex the workflow's change-detection bot uses
 # (.github/workflows/tree-sitter-upgrade-readiness.yml) — byte-identical so a matrix
 # format change that would silently break change-detection fails here. Group 2 is
-# ONLY the Status cell ([^|]+? before the final `|$`).
-_ROW_DIFF_RE = re.compile(r"\| `(tree-sitter-[^`]+)` \|.*\| ([^|]+?) \|$", re.M)
+# ONLY the Status cell ([^|]+? before the final `|$`). Group 1 is the grammar
+# name, optionally scoped (`@eagleoutice/tree-sitter-r`).
+_R_GRAMMAR = "@eagleoutice/tree-sitter-r"
+_ROW_DIFF_RE = re.compile(r"\| `((?:@[^/`]+/)?tree-sitter-[^`]+)` \|.*\| ([^|]+?) \|$", re.M)
 # Mirrors the scheduled issue-update summary extraction in
 # tree-sitter-upgrade-readiness.yml. If the report prose changes again, the issue
 # comment should not silently degrade to "?/? ready. ? blocker(s)".
@@ -216,6 +218,93 @@ class AssertCurrent(TestCase):
         self.assertIn("outside current runtime range", buf.getvalue())
 
 
+class AssertCurrentCoversR(TestCase):
+    """R is an npm grammar under a scoped name; --assert-current must check its
+    installed ABI against the current runtime's range like any other grammar."""
+
+    def test_out_of_range_r_abi_fails_the_gate_and_names_r(self):
+        real = readiness.extract_language_version
+
+        def fake(parser_c):
+            return 99 if "tree-sitter-r" in parser_c.parts else real(parser_c)
+
+        import urllib.request
+        buf = io.StringIO()
+        with mock.patch.object(readiness, "extract_language_version", side_effect=fake), \
+             mock.patch.object(urllib.request, "urlopen", side_effect=AssertionError("network")), \
+             contextlib.redirect_stdout(buf):
+            code = readiness.assert_current()
+        self.assertEqual(code, 1)
+        self.assertIn(f"{_R_GRAMMAR}: installed ABI 99 outside current runtime range", buf.getvalue())
+
+
+class ScopedGrammarName(TestCase):
+    """The R grammar's package name is scoped (`@eagleoutice/tree-sitter-r`); every
+    place that recognises a grammar by a `tree-sitter-` prefix must cope with it."""
+
+    def test_pinned_versions_include_the_scoped_grammar(self):
+        pkg = json.loads((_REPO_ROOT / "gitnexus" / "package.json").read_text())
+        pinned = readiness.read_pinned_grammar_versions()
+        self.assertEqual(pinned.get(_R_GRAMMAR), pkg["dependencies"][_R_GRAMMAR])
+        # Selection is by grammar basename: the runtime and non-grammar scoped
+        # dependencies are still excluded.
+        self.assertNotIn("tree-sitter", pinned)
+        self.assertNotIn("@ladybugdb/core", pinned)
+
+    def test_r_row_shows_its_pin_and_is_a_blocker_not_a_bump_candidate(self):
+        # Production-faithful R metadata: npm latest 1.1.2 (what package.json pins) with peer ^0.21.0 — blocks 0.25 and is NOT behind latest.
+        def fake_npm(pkg: str):
+            if pkg == _R_GRAMMAR:
+                return {"version": "1.1.2", "peerDependencies": {"tree-sitter": "^0.21.0"}}
+            return {"version": "9.9.9", "peerDependencies": {"tree-sitter": "^0.25.0"}}
+
+        def fake_fetch(url: str, timeout: int = 8):
+            if "parser.c" in url and "alex-pinkus" not in url:
+                return "#define LANGUAGE_VERSION 14\n"
+            if "/commits/" in url:
+                return json.dumps({"sha": "0123456789abcdef"})
+            return None
+
+        buf = io.StringIO()
+        with mock.patch.object(readiness, "npm_view_json", side_effect=fake_npm), \
+             mock.patch.object(readiness, "fetch_text", side_effect=fake_fetch), \
+             contextlib.redirect_stdout(buf):
+            code = readiness.main()
+        report = buf.getvalue()
+        row = next(l for l in report.splitlines() if l.startswith(f"| `{_R_GRAMMAR}` |"))
+        cells = [c.strip() for c in row.strip().strip("|").split("|")]
+        self.assertEqual(cells[1], "1.1.2")  # Pinned
+        self.assertEqual(cells[-1], "Peer patch required")
+        self.assertEqual(code, 1)
+        self.assertIn(f"`{_R_GRAMMAR}@1.1.2` — peer `^0.21.0`", report)  # Blocked bucket
+        # On latest already: not a bump candidate (pre-fix the lost pin made it
+        # one). Other grammars are mocked at 9.9.9 and so do appear in that list;
+        # only R's own line is asserted absent.
+        self.assertNotIn(f"- `{_R_GRAMMAR}`: ", report)
+        self.assertNotIn(f"`{_R_GRAMMAR}` — pinned", report)
+
+    def test_row_diff_regex_captures_scoped_and_unscoped_names(self):
+        rows = (
+            "| `@eagleoutice/tree-sitter-r` | ^1.1.2 | 1.1.2 | ^0.21.0 | **No** | 14 | 14 | Peer patch required |\n"
+            "| `tree-sitter-go` | ^0.23.0 | 0.25.0 | ^0.25.0 | Yes | 14 | 14 | Ready |\n"
+        )
+        self.assertEqual(
+            dict(_ROW_DIFF_RE.findall(rows)),
+            {"@eagleoutice/tree-sitter-r": "Peer patch required", "tree-sitter-go": "Ready"},
+        )
+
+    def test_row_diff_regex_mirror_matches_the_workflow(self):
+        # The workflow's change-detection regex is the one that matters; the
+        # mirror above is only worth anything while it is the same expression.
+        workflow = (
+            _REPO_ROOT / ".github" / "workflows" / "tree-sitter-upgrade-readiness.yml"
+        ).read_text(encoding="utf-8")
+        match = re.search(r"md\.matchAll\(/(.+)/gm\)", workflow)
+        self.assertIsNotNone(match, "row-diff regex not found in the workflow")
+        # JS regex literals escape `/`; Python patterns do not.
+        self.assertEqual(match.group(1).replace("\\/", "/"), _ROW_DIFF_RE.pattern)
+
+
 class FetchHelperReadPhaseErrors(TestCase):
     """Read-phase transport failures — raised by resp.read() AFTER urlopen has
     returned (ConnectionResetError, ssl.SSLError, socket.timeout,
@@ -326,6 +415,17 @@ class ReportRendering(TestCase):
         self.assertNotIn("Could not check", self.report)
         self.assertNotIn("fetch failed", self.report)
 
+    def test_r_grammar_is_listed_npm_queried_and_diffable(self):
+        # R is an npm dependency, so it takes the npm path (queried, not vendored)
+        # and its row must be captured by the change-detection regex despite the
+        # scoped package name.
+        self.assertEqual(
+            readiness.GRAMMARS.get(_R_GRAMMAR),
+            ("r-lib/tree-sitter-r", "main", "src/parser.c"),
+        )
+        self.assertIn(_R_GRAMMAR, _render_report.last_npm_calls)
+        self.assertIn(_R_GRAMMAR, self.rows)
+
     def test_held_swift_renders_held_and_keeps_exit_nonzero(self):
         # Status is the last matrix cell (the row-diff regex captures the whole
         # tail, not just status, so read the cell directly).
@@ -361,17 +461,19 @@ class ReportRendering(TestCase):
         self.assertIsNotNone(ready)
         self.assertIsNotNone(blockers)
         # Counts are derived from _render_report()'s mock corpus (all npm peer
-        # deps mocked permissive): of the 10 npm-installed grammars, 9 render
+        # deps mocked permissive): of the 11 npm-installed grammars, 10 render
         # Ready and 1 — tree-sitter-cpp — is the intentional pin (#1242), so it is
         # not counted ready. The remaining workarounds are that intentional pin
         # and Swift's declaration-recovery hold.
-        self.assertEqual(ready.groups(), ("9", "10"))
+        self.assertEqual(ready.groups(), ("10", "11"))
         self.assertEqual(blockers.group(1), "2")
 
     def test_lists_every_pack_time_peer_patch_with_its_drop_condition(self):
         patched = readiness.read_patched_peers()
-        # Guards the AUDITED_PEERS regex: the bundle script patches 8 manifests today.
-        self.assertGreaterEqual(len(patched), 8)
+        # Guards the AUDITED_PEERS regex: the bundle script patches 9 manifests
+        # today, including the scoped R grammar.
+        self.assertGreaterEqual(len(patched), 9)
+        self.assertIn((_R_GRAMMAR, "1.1.2", "^0.21.0"), patched)
         self.assertIn(f"## Pack-time peer patches ({len(patched)})", self.report)
         for name, version, _ in patched:
             self.assertIn(f"- `{name}@{version}`", self.report)
@@ -382,6 +484,8 @@ class ReportRendering(TestCase):
         self.assertIn("required while intentionally pinned", line("tree-sitter-cpp@0.23.4"))
         self.assertIn("transitive", line("tree-sitter-javascript@0.23.1"))
         self.assertIn("transitive", line("tree-sitter-c@0.23.6"))
+        # The scoped R grammar is a direct pin, so its patch is listed like any other.
+        self.assertIn("can drop: bump to `9.9.9`", line(f"{_R_GRAMMAR}@1.1.2"))
 
     def test_target_runtime_is_the_bundled_pin(self):
         pkg = json.loads((_REPO_ROOT / "gitnexus" / "package.json").read_text())
diff --git a/.github/workflows/tree-sitter-upgrade-readiness.yml b/.github/workflows/tree-sitter-upgrade-readiness.yml
index 889e6cd76..afdf69882 100644
--- a/.github/workflows/tree-sitter-upgrade-readiness.yml
+++ b/.github/workflows/tree-sitter-upgrade-readiness.yml
@@ -176,7 +176,8 @@ jobs:
                 // `|$`), so change-detection fires on status transitions, not on
                 // unrelated cell drift (e.g. an upstream-ABI bump). Mirror this in
                 // _ROW_DIFF_RE in test_check_tree_sitter_upgrade_readiness.py.
-                for (const m of md.matchAll(/\| `(tree-sitter-[^`]+)` \|.*\| ([^|]+?) \|$/gm)) {
+                // The grammar name may be scoped (`@eagleoutice/tree-sitter-r`).
+                for (const m of md.matchAll(/\| `((?:@[^\/`]+\/)?tree-sitter-[^`]+)` \|.*\| ([^|]+?) \|$/gm)) {
                   map[m[1]] = m[2].trim();
                 }
                 return map;
diff --git a/AGENTS.md b/AGENTS.md
index 2172825f5..c211bf02e 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -1,7 +1,7 @@
-<!-- version: 1.17.0 -->
-<!-- Last updated: 2026-09-24 -->
+<!-- version: 1.18.0 -->
+<!-- Last updated: 2026-10-07 -->
 
-Last reviewed: 2026-09-24
+Last reviewed: 2026-10-07
 
 **Project:** GitNexus · **Environment:** dev · **Maintainer:** repository maintainers (see GitHub)
 
@@ -40,6 +40,7 @@ Commands and gotchas live under **Repo reference** below and in **[CONTRIBUTING.
 
 - **[ARCHITECTURE.md](ARCHITECTURE.md)**, **[CONTRIBUTING.md](CONTRIBUTING.md)**, **[GUARDRAILS.md](GUARDRAILS.md)**
 - **Objective-C provider work:** read **[docs/languages/objective-c-provider.md](docs/languages/objective-c-provider.md)** before changing Objective-C parsing or resolution.
+- **R provider work:** read **[docs/languages/r-provider.md](docs/languages/r-provider.md)** before changing R parsing or resolution.
 - **Call & inheritance resolution (RFC #909 Ring 3):** See ARCHITECTURE.md § Scope-Resolution Pipeline. All languages resolve calls and inheritance through the scope-resolution pipeline (`Registry.lookup`, `preEmitInheritanceEdges`, `emitHeritageEdges`, `buildMro` → `MethodDispatchIndex`). **Shared code in `gitnexus/src/core/ingestion/` must not name languages** — plug language behavior in via `LanguageProvider` / `ScopeResolver` hooks. A language plugs in by implementing `ScopeResolver` (`scope-resolution/contract/scope-resolver.ts`) and registering it in `SCOPE_RESOLVERS`. (The legacy call-resolution DAG + `@heritage` capture path were removed in RING4-1 #942.)
 - **Cursor:** `.cursor/index.mdc` (always-on); `.cursor/rules/*.mdc` (glob-scoped). Legacy `.cursorrules` deprecated.
 - **GitNexus:** standard skills in `.claude/skills/gitnexus-*/`; MCP rules in `gitnexus:start` block below.
@@ -91,6 +92,7 @@ mirror. `gitnexus/test/unit/shipped-skills-sync.test.ts` guards the copies. Toke
 
 | Date | Version | Change |
 |------|---------|--------|
+| 2026-10-07 | 1.18.0 | Added the R provider guide as the required reference before changing R parsing or resolution. |
 | 2026-09-24 | 1.17.0 | Clones with the same `origin` URL now share a store automatically; `--no-share` records a lasting opt-out (#3352). |
 | 2026-09-24 | 1.16.0 | Documented the shared worktree index store (`<GITNEXUS_HOME>/stores/`, `analyze --share-with`, `GITNEXUS_SHARED_STORE=off`) in the storage notes (#3352). |
 | 2026-09-07 | 1.15.0 | Added the Objective-C provider guide as the required reference before changing Objective-C parsing or resolution. |
diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
index 8a13abd94..62b47a37b 100644
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@@ -377,7 +377,7 @@ CI auto-discovers the set via `tsx`. No workflow edit required.
 
 ## Language-agnostic graph feeding
 
-18 languages → single unified graph. Four abstraction layers:
+19 languages → single unified graph. Four abstraction layers:
 
 ```
  Unified Graph Schema (44 node types, 21 relationship types)
@@ -404,8 +404,10 @@ Each language implements `LanguageProvider` (`language-provider.ts`). Key fields
 | `mroStrategy`          | `first-wins` / `c3` / `none`                                                                                                                                                                                                                                                                                                      |
 | `descriptionExtractor` | Optional hook returning a symbol's doc-comment text as its `description`; feeds the embedding metadata header so doc-only terms are semantically searchable (issue #2270). Most languages register `createLeadingDocDescriptionExtractor` (shared, language-neutral; per-language comment/wrapper config passed at the call site) |
 | `definitionPropertiesExtractor` | Optional language-owned hook for structured, clone-safe definition metadata. Shared ingestion persists these properties opaquely; the owning provider supplies the extraction semantics. |
+| `postParse` | Optional. Whole-graph pass a language runs once after every chunk is merged and before scope resolution (deferred owner resolution, manifest-driven export refinement). Called once per analyze, awaited, only when the language has parsed files; a throw aborts the parse phase. R: deferred `setMethod`/R6 owners + NAMESPACE exports. |
+| `resolveMemberOwnerNode` | Optional. For languages whose members are owned by a call/assignment rather than an enclosing container node (R: R6/RefClass): returns the node the method and field extractors read members from, or null. Consulted by the enclosing-owner slot after the container walk and `resolveFileTypeOwner` (same slot; Zig file-owner is the precedent). Not an S4 mechanism: R's `setMethod(...)` returns null (its owner is a string-literal class name, not a node); S4 ownership arrives only through the `ownerNameHint` → `postParse` path. |
 
-18 providers in `languages/index.ts` via `satisfies Record<SupportedLanguages, LanguageProvider>` — missing a language is a compile error.
+19 providers in `languages/index.ts` via `satisfies Record<SupportedLanguages, LanguageProvider>` — missing a language is a compile error.
 
 ### Unified capture tags
 
diff --git a/README.md b/README.md
index d89a7ef05..e805a18be 100644
--- a/README.md
+++ b/README.md
@@ -722,9 +722,12 @@ GitNexus builds a complete knowledge graph of your codebase through a multi-phas
 | Objective-C | ✓      | —              | ✓       | ✓        | ✓                | —                     | —      | —          | —            |
 | Dart       | ✓       | —              | ✓       | ✓        | ✓                | ✓                     | —      | ✓          | ✓            |
 | Zig        | ✓       | —              | ✓       | —        | ✓                | ✓                     | ✓      | —          | ✓            |
+| R (experimental) | ✓  | ✓              | ✓       | ✓        | —                | ✓                     | ✓      | —          | —            |
 
 **Imports** — cross-file import resolution · **Named Bindings** — `import { X as Y }` / re-export tracking · **Exports** — public/exported symbol detection · **Heritage** — class inheritance, interfaces, mixins · **Type Annotations** — explicit type extraction for receiver resolution · **Constructor Inference** — infer receiver type from constructor calls (`self`/`this` resolution included for all languages) · **Config** — language toolchain config parsing (tsconfig, go.mod, etc.) · **Frameworks** — AST-based framework pattern detection · **Entry Points** — entry point scoring heuristics
 
+**R (experimental)** — `.r` / `.R` files, parsed with `@eagleoutice/tree-sitter-r`. Extracts functions, S4 classes, R6 classes and RefClass (`setRefClass`) classes with their methods and fields, and resolves `library()` / `require()` / `source()` imports to local packages and files, `obj$method()` and `pkg::fn()` calls, R6 `inherit=` / S4 `contains=` heritage and NAMESPACE-driven export status. Calls through function values, `do.call()`, infix operators and S3 dispatch are not linked, and `.Rmd` files, `box::use()` and external (CRAN) packages are not supported. See [docs/languages/r-provider.md](docs/languages/r-provider.md) for the full coverage and limits.
+
 **Control flow (CFG, opt-in `--pdg`)** — per-function control-flow graphs (`BasicBlock` nodes + `CFG` edges) feeding the PDG/taint substrate, currently **TypeScript & JavaScript** (#2081 M1); other languages planned. Off by default.
 
 ### Multi-Repo Architecture
diff --git a/docs/languages/r-provider.md b/docs/languages/r-provider.md
new file mode 100644
index 000000000..35eaac0b1
--- /dev/null
+++ b/docs/languages/r-provider.md
@@ -0,0 +1,121 @@
+# R Language Provider
+
+Status: implemented (experimental)
+
+The provider is covered by unit and integration tests, listed under [Tests](#tests). It is classified as experimental in the language support table. This status describes what is implemented today; it does not promise R's dynamic dispatch.
+
+## Scope
+
+GitNexus indexes `.r` and `.R` files with the `@eagleoutice/tree-sitter-r` grammar and resolves them through the scope-resolution pipeline (see ARCHITECTURE.md, Scope-Resolution Pipeline). R-specific logic lives in `gitnexus/src/core/ingestion/languages/r/`, with the per-language extractor and import-resolver files beside those of the other languages. Shared ingestion code does not name R; the provider plugs in through `LanguageProvider` and `ScopeResolver` hooks.
+
+R has no class syntax: classes are function calls (`R6Class(...)`, `setClass(...)`, `setRefClass(...)`) and package exports live in a NAMESPACE file rather than in the source. That is why the provider uses two optional hooks, `postParse` (attach each member to its owner and refine export status once every file is parsed) and `resolveMemberOwnerNode` (name the owner of a member from a call rather than an enclosing node).
+
+## Supported constructs
+
+Definitions:
+
+- Functions defined by assignment (`<-`, `=`, `<<-`). S3 methods appear as ordinary functions with dotted names such as `print.foo`.
+- S4 classes (`setClass`), generics (`setGeneric`), methods (`setMethod`) and slots (`representation`, `slots`).
+- R6 classes with their methods, fields and active bindings.
+- RefClass (`setRefClass`) classes with their methods and fields.
+- The argument that names an S4 or RefClass class, a generic or a method is the argument spelled with the first formal (`Class=`, `name=`, `f=`) wherever it sits, else the first unnamed argument (so a later `Class=` takes the formal from an earlier unnamed argument, as in R). Other strings (`contains=`, `valueClass=`, a `setMethod` signature) create no node.
+
+Types:
+
+- `x <- Type$new()` (R6, RefClass) and `x <- new("Class")` (S4) type `x`. Resolution of `x$method()` is asserted by tests for R6 only; the S4 `new()` binding is unit-tested only.
+- roxygen2 `@param` types in a restricted form: the description is the type alone (`#' @param name Type`) or starts with it in braces (`#' @param name {Type} prose`), the type is an R6, S4 or RefClass class defined in the same file, and the name is a formal of the function the block documents. The type is bound inside that function only. Prose that begins with a capitalised word binds nothing. Other roxygen2 tags (`@return`, `@field`, `@inheritParams`, `@rdname`, `@noRd`, `@export`) are not read.
+
+Imports:
+
+- `library()` and `require()` resolve to local packages, and `source()` to local files. The argument is `package=` / `file=` wherever it sits, else the first unnamed argument after any named one; named-first arguments such as `lib.loc=` and `local=` are not imports.
+- NAMESPACE `importFrom()` names bind to definitions in local packages. A name that can never bind (not exported, not defined at top level, or dotted) creates no import, so its calls keep the `global-name-fallback` guess.
+
+Calls:
+
+- Free calls, `obj$method()` calls (receiver typed as above), R6 `self$method()` calls, and calls inside native pipe (`|>`) chains.
+- Named nested functions (closures) are indexed, and calls inside attribute to the nested function, which can shadow a top-level name. Top-level script calls outside any function are attributed to the File node.
+- `pkg::fn()` and `pkg:::fn()`, decided by the qualifier (see [Resolution model](#resolution-model)).
+
+Heritage:
+
+- R6 `inherit=` and S4 `contains=` (a single class or `c(...)`). `contains = "VIRTUAL"` links to one placeholder class named `VIRTUAL`.
+
+Exports:
+
+- Read from each local package's NAMESPACE: `export()`, `exportClasses()`, `exportMethods()`, `S3method()` and `exportPattern()`. `S3method(generic, class, method)` exports `method`, the function R registers, else `generic.class`. A `DESCRIPTION` file with a `Package:` line marks a package root.
+
+## Resolution model
+
+The scope query (`languages/r/query.ts`) captures three call shapes only: `f(x)`, `pkg::f(x)` and `obj$f(x)`.
+
+- A bare call binds lexically first. `library()` and `require()` of a local package make every top-level name of that package visible, unfiltered by NAMESPACE. `source()` binds no name; a call into a sourced file, or into another file of the same package, binds through a workspace-wide unique-name fallback at confidence 0.5 (`global-name-fallback`). An ambiguous name yields no edge.
+- A bare call never binds to a dotted definition, so `foo(x)` cannot reach `print.foo`. Dotted (S3-style) names are never import-resolved; a call that spells the full dotted name binds by qualified-name lookup. Dotted names are not bound through `importFrom()`.
+- `pkg::name()` is decided by its qualifier:
+  - `pkg` is a package of the repository and defines `name` exactly once: the call binds to that definition at confidence 0.85 (`import-resolved`).
+  - `pkg` is certainly not a repository package (discovery completed and found no such package, including a repository with no `DESCRIPTION`): no edge.
+  - `pkg` defines `name` more than once: no edge.
+  - Discovery may have missed a package (its limits were reached): the call keeps the name-based behaviour.
+- `::` and `:::` are not distinguished, so `pkg::name` binds to a definition whether or not the package exports it.
+- Package discovery is bounded to depth 3 and 200 directories (when the bound may have hidden a package this is flagged internally and nothing is logged), reads directories in code-unit order, ranks duplicate package names by shallowest then by whole path, and never searches directories named exactly `renv`, `packrat`, `revdep` or `<name>.Rcheck`. The shared file scanner has no such ignore entries, so `.R` files inside those trees are still parsed even though discovery skips them.
+- Export status: the language-level export check treats every symbol as public. The NAMESPACE pass then marks the remaining `R/` symbols of a NAMESPACE-bearing package non-exported. Symbols outside `R/` (`tests/`, `vignettes/`, `inst/`) are not package members and stay public; files in `R/` subdirectories are treated as `R/` files although R itself does not load them. A package without a NAMESPACE stays fully public, and a nested package without one does not inherit its enclosing package's. roxygen2 `@export` tags are not consulted.
+- `exportPattern()` text comes from the analysed repository, so patterns are compiled to a linear-time automaton (`linear-regex.ts`) with a work budget. Constructs with no linear-time algorithm (back-references, look-around) and oversized patterns are dropped with one logged warning per pattern per package. Character classes use ASCII semantics.
+
+## Limits and known gaps
+
+Not edges or nodes:
+
+- A function passed as a value (`lapply(x, f)`, `Map`, `lapply(x, pkg::f)`), dynamic calls (`do.call("f", ...)`, `match.fun()`, `get()`) and dispatch through a registry (`handlers[["a"]]()`) create no CALLS edge, because only the three call shapes above are captured; the cross-language callable-value analysis classifies R as not applicable.
+- R6 `super$method()` and `private$method()` calls, S4 slot access (`obj@slot`), and `UseMethod()` / `NextMethod()` create no edge.
+- Anonymous functions (`function(x)`, `\(x)`) passed as arguments are not indexed as definitions; calls inside are attributed to the enclosing function, or to the File at top level.
+- Infix operators (`a %op% b`) are not linked to their definitions.
+- Constants and other top-level non-function assignments, and environments (`new.env()`, `local()`, `assign()` / `get()`), are not nodes; the only value-like nodes are R6, RefClass and S4 fields and slots. `setValidity()`, `setClassUnion()`, `setReplaceMethod()` and `Class$methods(...)` create no definition or edge.
+- No framework or entry-point detection (Shiny, plumber, targets, testthat). Plumber `#*` annotations are not read and no route nodes are created, and no route or fetch edges link R to other languages.
+
+Not supported:
+
+- The magrittr pipe `%>%` has no specific support and none is claimed; the native pipe `|>` is supported. tidyverse non-standard evaluation (bare column names, `.data$x`) is not modelled.
+- `.Rmd` and `.qmd` files are not indexed (the provider handles `.r` and `.R` only; `.Rprofile` and `.Renviron` are not indexed either), and `box::use()`, `import::from()`, `loadNamespace()`, `attachNamespace()` and `sys.source()` imports are not read.
+- S3 dispatch is not resolved: S3 methods are indexed as functions only. S4 and RefClass dispatch is not resolved either; there are definitions and heritage, not dispatch edges.
+- NAMESPACE `import()`, `importClassesFrom()` and `importMethodsFrom()` are not read. Imports of external (CRAN) packages produce no edges.
+- S4 `contains=` links only to classes defined in the repository or the `VIRTUAL` marker; basic-type bases such as `"numeric"` add no edge.
+- Package discovery is bounded (depth 3, 200 directories), so a package beyond the bound is treated like an unknown one. A package found only under `renv`, `packrat`, `revdep` or `<name>.Rcheck` is not a repository package.
+- A `pkg::name` whose package does not itself define `name` (for example a re-export) can still bind to a same-file or `importFrom` candidate, a `::` to a name the package does not export still binds to its definition, and `pkg::name` used as a value is not qualifier-resolved. Call sites dropped for certainly-external packages or duplicate definitions leave no recorded outcome.
+- When discovery may have missed a package, a `pkg::name` call keeps the name-based behaviour even if the candidate sits in a different package.
+- Files in `R/` subdirectories are treated as package-owned, although R itself does not load them.
+- NAMESPACE is read from disk during analysis, but neither it nor `DESCRIPTION` is a parsed source file. After an edit to either alone, an incremental analyse (no `--force`) keeps stale manifest-derived data: the persisted `isExported` of symbols in unchanged `R/` files, a `CALLS` edge bound through an `importFrom()` whose target changed, and a `pkg::fn` edge after a `Package:` rename. A full analyse is correct and `analyze --force` recomputes it. This is a limitation of the shared incremental write path (only changed files are re-processed), not of R resolution; other language manifests that feed resolution can be affected in the same way. It is to be addressed in a follow-up.
+- Roxygen `@param` types live in the per-file type environment; no graph edge consumes them.
+- Argument matching follows R for named and reordered arguments but does not model partial argument names: `setClass(Cla = "D")`, `new(Cla = "E")`, `setRefClass(Cla = "A")` and `setMethod("show", sig = "Foo")` are not recognised, so no definition or owner is attached.
+- Members are read only from the named forms. The positional second argument of `setClass("A", representation(x = "numeric"))`, `R6Class("X", list(...))` and `setRefClass("A", list(...))` creates no field or slot nodes; use `slots=` / `representation=`, `public =` / `private =` / `active =` and `fields =`.
+- For `S3method(generic, class, method)` the positional third argument names the exported method. A named third argument such as `S3method(print, foo, method = impl)` is not read: R registers `impl`, but the export is recorded for `print.foo`.
+- A leading `]` in a bracket expression of a NAMESPACE `exportPattern()` (for example `[]a]` or `[^]a]`) is read with JavaScript RegExp semantics, not POSIX/TRE, unless the pattern also contains a POSIX class such as `[:digit:]`; R would treat that `]` as a literal member.
+
+### Bounds on NAMESPACE exportPattern matching
+
+- Matching work and NFA states are counted in deterministic work units, never wall-clock time, so the outcome is the same on every machine. A NAMESPACE file is still read in full.
+- Caps, in `linear-regex.ts`: `MAX_TOTAL_WORK` (40,000,000 state visits per matcher), `MAX_SHARED_WORK` (100,000,000 matching visits per load), `MAX_PACKAGE_WORK` (30,000,000 per package), `MAX_SHARED_STATES` (500,000 NFA states per load) and `MAX_PACKAGE_STATES` (100,000 per package); a single pattern is also capped by `MAX_PATTERN_LENGTH` (16,384 characters) and `MAX_STATES` (16,384).
+- A pattern that does not fit is dropped, exports nothing and is warned about: at most 50 patterns are named per package (`MAX_LISTED_DROPPED_PATTERNS`), followed by a summary line counting the rest.
+- The first pattern refused for lack of states closes that package's allowance, so later patterns in the package are refused without being parsed.
+- One hostile package cannot exhaust the load budget alone (it is limited to its own share), but several can (three, for matching work); packages processed after that degrade, with warnings. Which package degrades follows graph node order.
+- Explicit `export()` names are unaffected by these bounds.
+
+## Type annotations
+
+R has no inline type annotations, so the "Type Annotations" column of the language support table is not ticked for R. The roxygen2 `@param` extraction above is a comment-based fallback, in the same class as the JSDoc, PHPDoc and YARD fallbacks listed in type-resolution-system.md (Ruby's YARD support is likewise not ticked).
+
+## Extending the provider
+
+- Definition captures are in `R_QUERIES` (`tree-sitter-queries.ts`); scope, import, type-binding, heritage and reference captures are in `languages/r/query.ts`. Keep each declaration pattern and its matching `@scope.function` pattern in lockstep, as the comments in `query.ts` explain.
+- The captures for `setClass`, `setRefClass`, `setGeneric`, `setMethod` and for `library` / `require` / `source` are deliberately loose. The argument that names the definition or the import is chosen afterwards in `languages/r/naming-argument.ts`, because a query-level prefix that skips leading comments and named arguments is quadratic in the argument count.
+- Resolution wiring is in `languages/r/scope-resolver.ts`, registered in `SCOPE_RESOLVERS`. Package discovery and NAMESPACE parsing are in `package-config.ts` and `namespace-imports.ts`; qualified calls in `qualified-call.ts`; owner and export post-processing in `post-parse.ts` and `owner-hooks.ts`.
+- Changing what the scope query captures changes what cached parsed files contain, so raise `SCHEMA_BUMP`.
+- Shared code under `gitnexus/src/core/ingestion/` must not name languages; add behaviour through the provider hooks.
+
+## Tests
+
+Unit tests are under `gitnexus/test/unit/` (`r-*.test.ts`, `type-env-r.test.ts` and `scope-resolution/r/`) and integration tests under `gitnexus/test/integration/resolvers/` (`r*.test.ts`), with `r-*` fixture projects in `gitnexus/test/fixtures/lang-resolution/`. They cover:
+
+- definitions, owners and the naming-argument rules (`r-definition-anchors`, `r-owner-hooks`, `r-post-parse-owners`, `r-scope-naming-argument`, `r-s4-anchors`, `r-s4-formals`, `r-scope-args`);
+- NAMESPACE parsing, exports and `exportPattern()` safety and scale (`r-namespace-parser`, `r-namespace-exports`, `r-export-pattern*`, `r-export-status-*`);
+- package discovery and root-package imports (`r-package-discovery-*`, `r-import-root-package`, `r-namespace-imports`);
+- qualified calls, dotted S3 names and native pipes (`r-qualified-*`, `r-dotted-s3-collision`, `r-native-pipes` fixture in `r.test.ts`);
+- roxygen2 `@param` types (`type-env-r`, `r-roxygen-param`).
diff --git a/gitnexus-shared/src/language-detection.ts b/gitnexus-shared/src/language-detection.ts
index 583a0fd5f..eb465959d 100644
--- a/gitnexus-shared/src/language-detection.ts
+++ b/gitnexus-shared/src/language-detection.ts
@@ -53,6 +53,7 @@ const EXTENSION_MAP: Record<SupportedLanguages, readonly string[]> = {
   [SupportedLanguages.Swift]: ['.swift'],
   [SupportedLanguages.Dart]: ['.dart'],
   [SupportedLanguages.Vue]: ['.vue'],
+  [SupportedLanguages.R]: ['.r'],
   [SupportedLanguages.Cobol]: ['.cbl', '.cob', '.cpy', '.cobol'],
   [SupportedLanguages.Zig]: ['.zig'],
 } satisfies Record<SupportedLanguages, readonly string[]>; // Ensure exhaustiveness
@@ -127,6 +128,7 @@ const SYNTAX_MAP: Record<SupportedLanguages, string> = {
   [SupportedLanguages.Swift]: 'swift',
   [SupportedLanguages.Dart]: 'dart',
   [SupportedLanguages.Vue]: 'typescript',
+  [SupportedLanguages.R]: 'r',
   [SupportedLanguages.Cobol]: 'cobol',
   [SupportedLanguages.Zig]: 'zig',
 } satisfies Record<SupportedLanguages, string>; // Ensure exhaustiveness
diff --git a/gitnexus-shared/src/languages.ts b/gitnexus-shared/src/languages.ts
index eec45e612..85a67e9ad 100644
--- a/gitnexus-shared/src/languages.ts
+++ b/gitnexus-shared/src/languages.ts
@@ -21,6 +21,7 @@ export enum SupportedLanguages {
   Swift = 'swift',
   Dart = 'dart',
   Vue = 'vue',
+  R = 'r',
   /** Standalone regex processor — no tree-sitter, no LanguageProvider. */
   Cobol = 'cobol',
   Zig = 'zig',
diff --git a/gitnexus-shared/src/scope-resolution/language-classification.ts b/gitnexus-shared/src/scope-resolution/language-classification.ts
index 2e635c8e2..1d9a1fff0 100644
--- a/gitnexus-shared/src/scope-resolution/language-classification.ts
+++ b/gitnexus-shared/src/scope-resolution/language-classification.ts
@@ -16,6 +16,7 @@
  *
  * Added after Ring 1: zig enters as `experimental` (new language
  * integration; promotion to `production` is a separate governance PR).
+ * Same for r, added later.
  */
 
 import { SupportedLanguages } from '../languages.js';
@@ -47,6 +48,7 @@ export const LanguageClassifications: Readonly<Record<SupportedLanguages, Langua
     [SupportedLanguages.Vue]: 'experimental',
     [SupportedLanguages.Cobol]: 'experimental',
     [SupportedLanguages.Zig]: 'experimental',
+    [SupportedLanguages.R]: 'experimental',
   };
 
 /** Convenience predicate: is this language gating Ring 4 retirement? */
diff --git a/gitnexus/README.md b/gitnexus/README.md
index 82ad8cb04..658dac1e8 100644
--- a/gitnexus/README.md
+++ b/gitnexus/README.md
@@ -461,7 +461,7 @@ GitNexus supports indexing multiple repositories. Each `gitnexus analyze` regist
 
 ## Supported Languages
 
-TypeScript, JavaScript, Python, Java, C, C++, C#, Go, Rust, PHP, Kotlin, Swift, Ruby, Dart, Zig
+TypeScript, JavaScript, Python, Java, C, C++, C#, Go, Rust, PHP, Kotlin, Swift, Ruby, Dart, Zig, R
 
 ### Language Feature Matrix
 
@@ -482,9 +482,12 @@ TypeScript, JavaScript, Python, Java, C, C++, C#, Go, Rust, PHP, Kotlin, Swift,
 | C++        | —       | —              | ✓       | ✓        | ✓                | ✓                     | —      | ✓          | ✓            |
 | Dart       | ✓       | —              | ✓       | ✓        | ✓                | ✓                     | —      | ✓          | ✓            |
 | Zig        | ✓       | —              | ✓       | —        | ✓                | ✓                     | ✓      | —          | ✓            |
+| R (experimental) | ✓  | ✓              | ✓       | ✓        | —                | ✓                     | ✓      | —          | —            |
 
 **Imports** — cross-file import resolution · **Named Bindings** — `import { X as Y }` / re-export tracking · **Exports** — public/exported symbol detection · **Heritage** — class inheritance, interfaces, mixins · **Type Annotations** — explicit type extraction for receiver resolution · **Constructor Inference** — infer receiver type from constructor calls (`self`/`this` resolution included for all languages) · **Config** — language toolchain config parsing (tsconfig, go.mod, etc.) · **Frameworks** — AST-based framework pattern detection · **Entry Points** — entry point scoring heuristics
 
+**R (experimental)** — `.r` / `.R` files, parsed with `@eagleoutice/tree-sitter-r`. Extracts functions, S4 classes, R6 classes and RefClass (`setRefClass`) classes with their methods and fields, and resolves `library()` / `require()` / `source()` imports to local packages and files, `obj$method()` and `pkg::fn()` calls, R6 `inherit=` / S4 `contains=` heritage and NAMESPACE-driven export status. Calls through function values, `do.call()`, infix operators and S3 dispatch are not linked, and `.Rmd` files, `box::use()` and external (CRAN) packages are not supported. See [docs/languages/r-provider.md](../docs/languages/r-provider.md) for the full coverage and limits.
+
 ## Agent Skills
 
 GitNexus ships with skill files that teach AI agents how to use the tools effectively:
diff --git a/gitnexus/bench/import-target/baselines.json b/gitnexus/bench/import-target/baselines.json
index 85f84fa21..939a2241c 100644
--- a/gitnexus/bench/import-target/baselines.json
+++ b/gitnexus/bench/import-target/baselines.json
@@ -2,6 +2,7 @@
   "_what": "Baselines for bench/import-target/measure.mjs cover every import-target resolver registered in SCOPE_RESOLVERS on a shared corpus, plus a configured C# arm for the branch the default call cannot reach. measure.mjs derives its arm inventory from LANG_REGISTRY and --check reconciles the registered languages in both directions. The single PHP arm supplies its production PSR-4 Composer mapping; csharp_csproj supplies csproj configuration. C and C++ also receive their production resolutionConfig header corpus. The timing, shape, fingerprint, context, and retained-heap gates therefore cover each production resolver path without splitting PHP into configured and unconfigured identities.",
   "_rebaselined_2960_kotlin_declared_packages": "Kotlin now resolves only from parsed package facts and local module bindings. This deliberately changes its five fingerprints, removes path-depth sensitivity, adds the context probe, and reduces the 32000-file retained index from 40.82 MiB to 4.31 MiB. External same-name path decoys now remain unresolved.",
   "_zig_arm_1432": "zig was registered in SCOPE_RESOLVERS by PR #1432 with no arm here, which is the exact hole the inventory arm exists for, and it reported it. The arm passes NO build config: resolveZigImportInternal walks an importer-relative @import path component by component and probes allFiles.has() twice (as spelled, then + '.zig'), so its fingerprints pin that walk alone and do not move when build.zig / build.zig.zon parsing (the bare-name legs, gated by test/unit/zig-import-resolver.test.ts) changes. Same corpus proportions as rust — 979 of 3200 resolve at 400 files — and rust's collide design, a deep tree whose spellings carry thirteen components against the unique arm's three, because component count is the only axis the cost has. Measured on one box: small 1.036 ms, collide 1.700 ms, scaling 1.050, collide scaling 1.011, depth 1.573; budgets take the file's usual ~1.5x on ratios (2.4 depth) and ~4x on absolute ms (4 / 7). Heap reads 16 B at both 8000 and 32000 files — it builds nothing, exactly rust's reading — so it sits in heap_bound_bytes at rust's absolute 1048576 B.",
+  "_r_arm": "R was registered in SCOPE_RESOLVERS without an arm here, which is the hole the inventory arm exists for, and it reported it twice: no LANG_REGISTRY row, and a five-parameter resolveImportTarget with no context arm. The arm drives the registered hook with the three import forms R code has, at the shared corpus proportions (1153 of 3200 resolve at 400 files, as for go, java and objc): library(pkg) as a wildcard, which resolves to every file of the package's R/ directory; source(\"R/file.R\") as a side-effect import, which misses the exact join and is answered by the suffix index; and a NAMESPACE importFrom(pkg, name) as a named import, spelled pkg::name in the corpus and split back in resolveOne, which reads the parsed workspace. The config is the DESCRIPTION-derived package map rebuilt from the corpus paths, with no NAMESPACE, so exports are not filtered. The collide arm repeats mod{k}.R in every package and spells source() at the project root (R/mod{k}.R), which is ambiguous across every package. The context probe is importFrom(pkgA, f): the parsed workspace answers the one file defining f, the context-free call answers every file of pkgA/R. Heap reads 57.26 MiB at 32000 files through the shared workspace file index, ratio 0.970, so R is budgeted. Measured over three runs: small 11.9-12.1 ms, collide 10.8-11.2 ms, scaling 1.38-1.43, collide scaling 1.39-1.45, depth 2.77-2.89. Budgets take the file's usual ~1.5x on ratios and ~4x on absolute ms. R sits above every other linear-budget language on scaling and collide scaling because two of its legs are genuinely O(files) per import rather than keyed: library() of a local package scans the whole file list for the R/ prefix, and every source() path calls normalizedFileList.indexOf before it reaches the index. Measured per leg at 400/1600/6400 files: library of a local package 2.5/8.9/32.4 us, source hit 1.2/6.3/35.9 us, against a flat 0.04 us for an external library() and about 13 us for a source miss. The mixed corpus is dominated by the flat legs, which is why the aggregate stays under the shared 1.8 scaling budget; the collide and depth budgets are set with that in mind rather than hiding it. Fixing the two scans is a resolver change, outside this arm's scope.",
   "_objc_arm_3179": "Objective-C resolves local header and source imports through a cached suffix map. The map preserves the previous first-path tie-break, which is covered directly in objective-c-provider.test.ts. This arm covers the registered resolver's five dispatch paths, including the depth-sensitive index construction and a collision layout. Measured on this branch: small 1.844 ms, collide 1.861 ms, scaling 1.111, collide scaling 1.067, depth 2.779, and 44101944 retained bytes. The 3.6 depth budget allows normal timing variation while remaining below a full per-import file scan; collision scaling stays at the shared linear 1.8 budget because suffix lookup is keyed.",
   "_cobol_copybook_dir_preference_2967": "COBOL now prefers well-known copybook directories (copybooks/, cpy/, copy/, plus importer dir) over vendor paths when resolving COPY statements, so COPY EXTERNAL no longer hits same-named decoys outside the project structure. This intentional behavior change moves the resolver from depth-free (prior measured ~0.885) to depth-sensitive (measured 1.751 on CI), because the new preferredCopybookDirs check walks path components. The 2.4 depth budget is ~1.37x the measured ratio, consistent with the ~1.5x convention for depth arms. The unique-arm fingerprints and resolved counts change to reflect the new target set: small/deep drop from 1153 to 442 resolved because files outside preferred directories are now correctly filtered. The collide arm (svc${d}/copybooks layout) keeps 1153 resolved because ALL its files are in preferred copybook directories, so the filter does not change its resolution outcomes — the collide arm now measures collision behavior within the preferred class rather than across mixed layouts. Fixes #2967.",
   "_php_composer_gate_2962": "The canonical PHP arm supplies an authoritative App PSR-4 mapping. A deterministic Vendor0 suffix decoy makes deletion of the external gate change every timing fingerprint, while the heap arm separately pins a mapped miss, the rendered mapping, and the external null result. Three serial samples measured depth ratios 1.058, 1.114, and 1.158; the 1.8 budget is 1.55x the observed maximum. The mapped-miss heap reading peaked at 39607216 retained bytes at 32000 files.",
@@ -31,7 +32,8 @@
     "c": 3.8,
     "cpp": 4,
     "objc": 1.8,
-    "zig": 1.8
+    "zig": 1.8,
+    "r": 2.2
   },
   "depth_budget": {
     "go": 1.4,
@@ -52,7 +54,8 @@
     "c": 3,
     "cpp": 3,
     "objc": 3.6,
-    "zig": 2.4
+    "zig": 2.4,
+    "r": 4.2
   },
   "small_ms_ceiling": {
     "go": 7,
@@ -73,7 +76,8 @@
     "c": 7,
     "cpp": 7,
     "objc": 8,
-    "zig": 4
+    "zig": 4,
+    "r": 50
   },
   "collide_ms_ceiling": {
     "go": 28,
@@ -94,7 +98,8 @@
     "c": 11,
     "cpp": 12,
     "objc": 8,
-    "zig": 7
+    "zig": 7,
+    "r": 45
   },
   "heap_ceiling_bytes": {
     "rust": 31300000,
@@ -109,7 +114,8 @@
     "php": 59410824,
     "java": 5600000,
     "python": 9541404,
-    "c": 15000000
+    "c": 15000000,
+    "r": 90100000
   },
   "_heap_reading_note": "heap_reading_bytes records each measured large-corpus reading so the 0.5x floor is independent of its ceiling. Ceilings use the standard 1.5x allowance for cross-platform and Node heap-accounting differences; re-baseline the reading and ceiling together.",
   "_kotlin_declared_package_gate": "#2960 replaces Kotlin\u0027s path-suffix cascade with one declared-package/module-binding index. The 32000-file arm measured 4516944 retained bytes (4.31 MiB), with a 6800000-byte ceiling. Correctness and reuse are pinned separately by kotlin-module-resolution.test.ts, external-import-conformance.test.ts, the shared index-reuse contract, and bench/kotlin-import-target.",
@@ -126,7 +132,8 @@
     "php": 39607216,
     "java": 3676984,
     "python": 6360936,
-    "c": 10018816
+    "c": 10018816,
+    "r": 60040752
   },
   "_heap_bound_note": "THE SECOND HEAP TIER. Every registered language is measured now; heap_bound_bytes gates the nine that are not BUDGETED above, and it gates them with one comparison and no floor. A ceiling says 'this index is not too big'. A bound says something narrower and it is the thing that was missing: 'the exclusion still holds' \u2014 this language has not grown an index since it was left out. measure.mjs's MEMORY section states the re-entry condition (if a language ever diverges in what it ASKS its index, it earns a budgeted arm) and until now nothing watched for the divergence; HEAP_LANGS was a hand-maintained list of eight whose two neighbours, LANG_REGISTRY and CONTEXT_LANGS, are both reconciled against a derived predicate in both directions. HEAP_BOUNDED is derived too \u2014 it is LANGS minus HEAP_BUDGETED \u2014 so the two tiers partition the languages and a new one cannot land outside both. WHAT RE-MEASURING FOUND, five runs each, maximum quoted, peak-to-peak in brackets. go 2998464 B [1.0021], dart 7834200 B [1.0006] and kotlin 42802456 B [1.0004] HAD NO STATED REASON AT ALL: the old prose opened 'SIX of the seventeen are deliberately NOT in HEAP_LANGS' against a list of eight of seventeen, and these three were the three nobody counted. All three retain a real per-pass structure (go's PackageDirIndex, dart's basename buckets, kotlin's suffixByStem cascade) and kotlin's 40.82 MiB is above ruby's 39.12 and java's 33.34, both of which carry a full budget. (It read 45.85 MiB when this was written, described here as 'the second-largest reading in this file' \u2014 it was third even then, behind csharp_csproj and php; #2881 later compacted its dirChildren buckets and took 11% off it. Same staleness this paragraph exists to document.) swift 3449216 B [1.0024] and cobol 2320456 B [1.0000] were excluded as 'below the measurement's own noise floor' on readings of 0.29 MB and 0 B at 32000 files; they now read 3.29 MB and 2.21 MB, growing with the corpus (969120 B and 536264 B at 8000). Those old numbers were not wrong when taken \u2014 the ARM changed under them, when #2903's follow-up made every probe resolve a real import and when measureHeap began flattening its corpus \u2014 which is the whole finding: a measurement written into prose is not re-taken, and this file had already gone stale against itself, quoting javascript at 46208832 B four paragraphs after quoting it at 25.51 MiB. rust is the one exclusion that survived unchanged: 16 B at 8000 files and 16 B at 32000, identical in all five runs. typescript 26745296 B, vue 28884016 B and cpp 10023344 B are duplicates of a builder AND of a read pattern: typescript is byte-identical to javascript's 26745296 in four runs of five, cpp is +0.05% of c's 10018816, vue is +8.0% of javascript. HOW THE BOUNDS WERE CHOSEN. Each takes 1.5x its measured maximum, rounded up to the next 100000 B: cobol 6200000 (1.508x of 4112464 B measured after copybook-dir preference; previously 3500000 based on 2320456 B before the behavior change), swift 5200000 (1.508x). (This sentence used to list eight, including go, dart, kotlin, typescript, vue and cpp. Those six were promoted to the budgeted tier and their bounds deleted; the numbers stayed here, unread by any gate, and #2881 dutifully updated kotlin's to 64300000 before anyone noticed heap_bound_bytes holds only cobol, swift and rust. A number nothing asserts is a number that rots \u2014 the finding this paragraph is otherwise about.) 1.5x is NOT copied from the ceilings out of habit \u2014 it is the same number for a stated reason, and the reason is not noise: measured peak-to-peak on this box is at most 1.0024, so noise alone would justify 1.05x. What a bound has to survive is a RUNNER change, since heapUsed accounting moves across platforms and Node majors, and this file already fixes that allowance at 50% for exactly this measurement on exactly this arm. Using a second allowance for the same uncertainty on the same number would be two conventions, not more rigour. At 1.5x the bound catches what the re-entry condition is about \u2014 a language growing an index, which costs +85% for one more suffix map and +100% for a duplicate \u2014 and it does NOT catch a duplicate diverging by 8%. That limit is real and is stated rather than hidden: the tight form is a same-process ratio against the arm each duplicate is a duplicate OF, which is the only form immune to the drift the absolute bound has to tolerate. RUST TAKES AN ABSOLUTE BOUND INSTEAD, 1048576 B (1 MiB), because 1.5 x 16 B is 24 B and would fail on the first byte of anything \u2014 a multiplier on a reading that is already nothing is a gate that flakes rather than a gate that bites. 1 MiB is ~65000x the reading and still 3.9x below the smallest real index measured here (cobol's 3.92 MB at the same file count after copybook-dir preference), so it separates 'builds nothing' from 'builds something' with room on both sides. NO FLOOR ON ANY OF THE NINE, and the reason differs by language rather than being uniform. For rust a floor would be a floor on noise. For the other eight the readings are stable enough to floor today, and for kotlin and dart \u2014 larger than budgeted arms \u2014 a floor would be worth having, since a lazily-built map going quiet is exactly how the four budgeted arms once read 0 B. Adding one is a PROMOTION to the budgeted tier, with a ceiling and a recorded reading beside it, not a line here: a floor whose companion ceiling does not exist asserts 'still measuring' against a number nothing else bounds. Recommended next, in order: kotlin, then dart, then go.",
   "heap_bound_bytes": {
@@ -1152,6 +1159,62 @@
         "scaling_ratio": 1.05,
         "small_ms": 1.036
       }
+    },
+    "r": {
+      "small": {
+        "files": 400,
+        "imports": 3200,
+        "resolved": 1153,
+        "distinct_outcomes": 3080,
+        "fingerprint": "b77a56af9b59034404801d79b3ed7760bbc63069b50caab996123051e97bf755"
+      },
+      "large": {
+        "files": 1600,
+        "imports": 12800,
+        "resolved": 4681,
+        "distinct_outcomes": 12297,
+        "fingerprint": "159bb6eacfff674cc2c7fec1ffe3b814104fb500d6cb8416a38942ec11ec97fd"
+      },
+      "deep": {
+        "files": 400,
+        "imports": 3200,
+        "resolved": 1153,
+        "distinct_outcomes": 3080,
+        "fingerprint": "5ea8bb989760f40b4e47986efeb8b6e67d8363f38caac1c341d24c000af25a05"
+      },
+      "collide": {
+        "files": 400,
+        "imports": 3200,
+        "resolved": 1153,
+        "distinct_outcomes": 3057,
+        "fingerprint": "b53fe6dce1eaa9bd6c1c5083aa36bec45ea5afe485cc9ec28db97b78cc41fce5"
+      },
+      "collide_large": {
+        "files": 1600,
+        "imports": 12800,
+        "resolved": 4681,
+        "distinct_outcomes": 12212,
+        "fingerprint": "225bda6d01439bc48eda483a76e7b4c1c3f8328ab243d52adcf2d4c018b0cf0b"
+      },
+      "fingerprint": "159bb6eacfff674cc2c7fec1ffe3b814104fb500d6cb8416a38942ec11ec97fd",
+      "heap": {
+        "files_small": 8000,
+        "files_large": 32000,
+        "path_segments": 11,
+        "probe": "vendor0/R/missing.R"
+      },
+      "context": {
+        "target": "pkgA::f",
+        "with_context": "pkgA/R/a.R",
+        "without_context": "pkgA/R/a.R,pkgA/R/b.R"
+      },
+      "_measured": {
+        "collide_ms": 11.022,
+        "collide_scaling_ratio": 1.434,
+        "depth_ratio": 2.82,
+        "scaling_ratio": 1.39,
+        "small_ms": 12.145
+      }
     }
   },
   "_blind_spot": "MEASURED, so nobody has to rediscover it: a full workspace scan reintroduced on 1-in-32 imports passes EVERY arm here \u2014 dart scored 1.458 scaling and 1.736 ms against the 1.8 budget and 4 ms ceiling of an earlier revision. At 1-in-8 the scaling arm catches it (2.414). The gate that NARROWS this is not a timing gate at all: test/unit/scope-resolution/import-target-index-parity.test.ts counts iterations of the file-set Set and reads 14 instead of 1 for that same 1-in-32 mutation, deterministically and for all five languages. It does NOT close it. The counter watches the Set, and the resolvers no longer read the Set \u2014 they read materialized copies of the same file list: WorkspaceFileIndex.normalized and .all (C#, Ruby), Dart's byBasename buckets, and PackageDirIndex.filesByDir (Go, C#). A 1-in-32 scan over any of those three touches the Set zero extra times, so it passes the parity test AND passes --check. Closing it would take an iteration counter on the materialized arrays themselves. Read the two gates together; tightening these ceilings toward the noise floor to chase that case would only buy flaky CI. CONFIRMED THE HARD WAY by PR #2911: JavaScript resolution was scanning ImportPassCache.normalizedFileList on every import \u2014 a materialized array, not the Set \u2014 at 25972 us per import at 8000 files, and no instrument on the #2901-#2909 branch could see it. It took a differential parity test over 211200 old-vs-new pairs to find. The arms added here would have caught THAT one on absolute ms (85 ms budget against a 20 ms arm; the unindexed resolver costs ~83000 ms on the same corpus), which is the argument for gating every registered language rather than only the ones a PR happens to touch. THE SECOND BLIND SPOT IS CLOSED, and this records what closing it changed. This harness used to call the inner resolvers with the NO-CONTEXT shape: run.ts calls provider.resolveImportTarget with five arguments, the fifth being { parsedFiles, parsedImport }, and resolveOne supplied three. resolveOne now makes the production call, newPass mints the ParsedFile[] FIRST and derives the path set from it exactly as run.ts does, and both legs behind the argument run on every import of their arms \u2014 PHP's named/alias function-or-const leg over filesByDirectory(context.parsedFiles), whose memo defeated measures 197.0 us -> 9976.2 us per import (50.6x), and Python's from-import submodule-precedence branch, the only spelling that reads context.parsedFiles at all. Fifteen of the seventeen arms cannot observe a context (their hooks declare three or four parameters) and are handed none, so their numbers did not move; which two CAN is now reconciled against SCOPE_RESOLVERS' hook arity rather than asserted in prose. NOTHING ELSE IN THIS FILE COULD HAVE GATED IT, which is why the context arm exists: fingerprints and shape can remain unchanged while dropping context only makes timing faster. The deterministic context arm is therefore the guard for this wiring. The arm is one import per language resolved through resolveOne twice, with and without the pass's parsedFiles, whose two answers must DIFFER and must both match what is recorded. WHAT REMAINS UNMEASURED, narrowed rather than deleted: Python's parsedFileByPath memo is exercised by the five timing arms and cannot be reached by the heap arm at all, because retainedPassBytes requires a probe that MISSES while every path that builds that memo returns a non-null packageTarget \u2014 so no ceiling bounds that Map (one pointer per parsed file, O(files), no depth term) and the contract test's count gate is what holds it to one build per pass. PHP's sole arm carries a representative Composer PSR-4 map, so mapped hits and authoritative misses exercise that production branch directly. And the const tail of PHP's leg is a different ANSWER at the same cost \u2014 it runs the identical candidate gather and localDefs filter and diverges in the last two lines \u2014 so it is gated by count in test/unit/scope-resolution/import-target-index-reuse.contract.test.ts, which stays the gate to read alongside this file.",
diff --git a/gitnexus/bench/import-target/measure.mjs b/gitnexus/bench/import-target/measure.mjs
index 60a73ffee..e07e39e27 100644
--- a/gitnexus/bench/import-target/measure.mjs
+++ b/gitnexus/bench/import-target/measure.mjs
@@ -5,8 +5,8 @@
  * — over ONE shared corpus so the arms are directly comparable. One arm per
  * registered language, plus a second `csharp` arm carrying csproj configs
  * (#2902), so there is one more arm than there are languages. The newest row
- * is `zig` (PR #1432), added the day its resolver registered — the inventory
- * arm below is what noticed it missing, which is the arm doing its job.
+ * is `r`, which registered without a row and was reported by the inventory arm
+ * below — the arm doing its job — after `zig` (PR #1432), which did the same.
  *
  * NO LANGUAGE IS OMITTED, and that is the point of the list rather than an
  * accident of it. Nine of these arms (go, csharp, csharp_csproj, dart, ruby,
@@ -127,6 +127,19 @@
  *     path-walking resolver alone and does not move when that config parsing
  *     changes.
  *
+ *   - r: one resolver behind three import forms, and the arm builds all three
+ *     (see `uniqueTarget`): `library(pkg)` (a wildcard that resolves to every
+ *     file of the package's `R/`), `source("R/file.R")` (a side-effect import
+ *     answered by the suffix index after an exact-join miss) and a NAMESPACE
+ *     `importFrom(pkg, name)` (a named import that reads the parsed workspace,
+ *     spelled `pkg::name` in the corpus). It passes the package map a
+ *     `DESCRIPTION` scan yields and is a `CONTEXT_LANGS` member. Two of its
+ *     legs are O(files) per import rather than keyed (a local `library()` scans
+ *     the file list for the `R/` prefix; every `source()` path runs
+ *     `normalizedFileList.indexOf` before the index), which is why R reads the
+ *     highest scaling of the linear-budget languages; `_r_arm` in
+ *     baselines.json has the per-leg numbers.
+ *
  * Two properties of the corpus are load-bearing and must not be "simplified":
  *
  *  1. **Most imports are unresolvable.** In real source the majority of imports
@@ -495,6 +508,7 @@ import { typescriptScopeResolver } from '../../src/core/ingestion/languages/type
 import { cScopeResolver } from '../../src/core/ingestion/languages/c/scope-resolver.ts';
 import { cppScopeResolver } from '../../src/core/ingestion/languages/cpp/scope-resolver.ts';
 import { objectiveCScopeResolver } from '../../src/core/ingestion/languages/objective-c/scope-resolver.ts';
+import { rScopeResolver } from '../../src/core/ingestion/languages/r/scope-resolver.ts';
 // `SCOPE_RESOLVERS` is NOT imported here — see the inventory arm at the bottom,
 // which loads it dynamically. Statically it costs 6-10 s of module load
 // depending on the box (measured both ways there), because reaching the
@@ -606,6 +620,9 @@ const HEAP_BUDGETED = [
   'objc',
   // Lexical module lookup retains a workspace index over parsed Rust files.
   'rust',
+  // R retains the shared workspace file index (57.26 MiB at 32000 files, ratio
+  // 0.970 against the 1.25 budget), so it takes the full ceiling + floor + ratio.
+  'r',
 ];
 // javascript, typescript and vue were budgeted here until #2953 and are now
 // BOUNDED, which is a demotion in gate strength and a promotion in what the
@@ -634,7 +651,7 @@ const HEAP_BUDGETED = [
  * parameters cannot observe a context and are not listed, so their timed
  * numbers stay on the three-argument shape.
  */
-const CONTEXT_LANGS = ['php', 'java', 'kotlin', 'python', 'swift', 'rust', 'c', 'cpp'];
+const CONTEXT_LANGS = ['php', 'java', 'kotlin', 'python', 'swift', 'rust', 'c', 'cpp', 'r'];
 
 /**
  * Needs `node --expose-gc` to force collection for a clean delta; without it
@@ -767,6 +784,7 @@ const EXTENSION = {
   cpp: '.cpp',
   objc: '.m',
   zig: '.zig',
+  r: '.R',
 };
 /** C and C++ resolve `#include` against HEADERS, which reach the resolver
  *  through `resolutionConfig` rather than through `allFilePaths` — see
@@ -899,6 +917,12 @@ function uniqueDir(lang, d, i) {
   // share the other unique arms take from a nested directory comes from the
   // target instead (see `uniqueTarget`).
   if (lang === 'zig') return `src/mod${d}`;
+  // An R package keeps its sources in `<pkg>/R/` and nothing else in the
+  // namespace, so one package per index with its files flat under `R/` is the
+  // layout `library()` (every file of `<pkg>/R/`) and `importFrom()` (the file
+  // defining one name) both address. Flat on purpose: R has no nested source
+  // directories inside `R/`, so there is no `d % 7` nested slice to mint.
+  if (lang === 'r') return `pkg${d}/R`;
   throw unwiredLanguage('uniqueDir', lang);
 }
 
@@ -994,6 +1018,11 @@ function collideDir(lang, d, i) {
   // axis that CAN grow — `collideTarget` spells its imports up through the
   // tree and back down, ~4x the components of the unique arm.
   if (lang === 'zig') return `src/l0/l1/l2/l3/l4/mod${d}`;
+  // `svc{d}/R/mod{k}.R` in every package: the conventional flat `R/` directory
+  // with a repeated basename per package, so the `source("R/mod{k}.R")` spelling
+  // below is ambiguous across every package and its suffix lookup answers from
+  // a bucket that grows with the corpus.
+  if (lang === 'r') return `svc${d}/R`;
   throw unwiredLanguage('collideDir', lang);
 }
 
@@ -1048,7 +1077,8 @@ function buildFiles(lang, fileCount, pad, shape) {
       layout === 'vue' ||
       layout === 'python' ||
       layout === 'c' ||
-      layout === 'cpp';
+      layout === 'cpp' ||
+      layout === 'r';
     const [fileStem, modStem] = PASCAL_CASE_FILES.has(layout) ? ['File', 'Mod'] : ['file', 'mod'];
     let stem =
       shape === 'collide' && collideStem ? `${modStem}${Math.floor(i / dirs)}` : `${fileStem}${i}`;
@@ -1169,6 +1199,58 @@ const kotlinProbeFile = (filePath, packageName, exportName) => {
   };
 };
 
+/**
+ * An R file whose Module scope binds each of `names` to a top-level function,
+ * which is exactly what `rFileTopLevel` reads — and ONLY that, because
+ * `localDefs` also lists nested functions and R6 members and cannot answer "is
+ * this defined at top level". The resolver reads the bindings, never the def's
+ * other fields, so the rest of the shape is the inert `probeFile` one.
+ */
+const rProbeFile = (filePath, names) => {
+  const base = probeFile(
+    filePath,
+    names.map((name) => ['Function', name]),
+  );
+  const moduleScope = `module:${filePath}`;
+  return {
+    ...base,
+    moduleScope,
+    scopes: [
+      {
+        id: moduleScope,
+        parent: null,
+        kind: 'Module',
+        range: { startLine: 1, startCol: 0, endLine: 1, endCol: 1 },
+        filePath,
+        bindings: new Map(
+          base.localDefs.map((def) => [def.qualifiedName, [{ def, origin: 'local' }]]),
+        ),
+        ownedDefs: base.localDefs,
+        imports: [],
+        typeBindings: new Map(),
+      },
+    ],
+  };
+};
+
+/**
+ * What `loadRPackageConfig` reads from disk (one `DESCRIPTION` per package),
+ * rebuilt from the corpus paths: every `<dir>/R/` is the `R/` directory of the
+ * package named after its last component. `namespaceInfoByPackageDir` is empty
+ * — no NAMESPACE file — so `importFrom()` exports are not filtered, which is
+ * the leg that reads `parsedFiles` and is the one this arm exists to measure.
+ */
+const rPackageConfigFor = (files) => {
+  const packages = new Map();
+  for (const file of files) {
+    const at = file.indexOf('/R/');
+    if (at < 0) continue;
+    const dir = file.slice(0, at);
+    packages.set(dir.slice(dir.lastIndexOf('/') + 1), dir);
+  }
+  return { packages, namespaceInfoByPackageDir: new Map() };
+};
+
 function javaBenchmarkPackage(filePath) {
   const uniquePackage = /\/com\/example\/(pkg\d+)(?:\/|$)/.exec(`/${filePath}`)?.[1];
   if (uniquePackage !== undefined) return `com.example.${uniquePackage}`;
@@ -1217,6 +1299,17 @@ function buildParsedFiles(lang, files) {
       parsedFiles.push(kotlinProbeFile(filePath, kotlinBenchmarkPackage(filePath), stem));
       continue;
     }
+    if (lang === 'r') {
+      // One top-level function named for the file, plus an S3 method on it
+      // (`file7.print`), which is a dotted top-level name: the resolver's
+      // `dottedTails` guard reads it, and its tail (`print`) never equals a
+      // name an import asks for, so the guard runs on every lookup and refuses
+      // none.
+      const slash = filePath.lastIndexOf('/');
+      const stem = filePath.slice(slash + 1, filePath.lastIndexOf('.'));
+      parsedFiles.push(rProbeFile(filePath, [stem, `${stem}.print`]));
+      continue;
+    }
     const slash = filePath.lastIndexOf('/');
     const stem = filePath.slice(slash + 1, filePath.lastIndexOf('.'));
     const parent = slash < 0 ? '' : filePath.slice(0, slash);
@@ -1446,6 +1539,32 @@ function uniqueTarget(lang, { local, r, d, j, dirs }) {
     if (miss === 1) return `ghost${(r >>> 4) % 97}`;
     return `../vendor${(r >>> 4) % 97}/missing.zig`;
   }
+  if (lang === 'r') {
+    // Three import forms, one per leg of the resolver, in the shares R code
+    // actually has them:
+    //   - `library(pkg)` — `pkg{d}` is a LOCAL package and resolves to every
+    //     file of its `R/` directory (a list); an external one (`dplyr`) is
+    //     refused by the wildcard guard before any lookup;
+    //   - `source("R/file{j}.R")` — the project-root spelling. The importer's
+    //     own directory does not hold `R/R/…`, so the exact-join probe misses
+    //     and the suffix index answers; an external one is a vendored path in
+    //     no package, which runs the whole cascade to null;
+    //   - `importFrom(pkg, name)` — spelled `pkg::name` in this corpus because
+    //     the import list is `[from, target]` pairs and `resolveOne` splits it
+    //     back (`::` is not legal in a package name, so the split is exact).
+    //     Resolves through the parsed workspace's top-level definitions; an
+    //     external package is not in the config and answers null.
+    if (local) {
+      const leg = (r >>> 3) % 3;
+      if (leg === 0) return `pkg${d}`;
+      if (leg === 1) return `R/file${j}.R`;
+      return `pkg${j % dirs}::file${j}`;
+    }
+    const miss = (r >>> 3) % 3;
+    if (miss === 0) return ['dplyr', 'ggplot2', 'data.table', 'stringr'][(r >>> 4) % 4];
+    if (miss === 1) return `vendor${(r >>> 4) % 97}/R/missing.R`;
+    return `ext${(r >>> 4) % 97}::tidy`;
+  }
   throw unwiredLanguage('uniqueTarget', lang);
 }
 
@@ -1679,6 +1798,27 @@ function collideTarget(lang, { local, r, d, j, dirs }) {
     if (miss === 1) return `ghost${(r >>> 4) % 97}`;
     return `${up}/vendor${(r >>> 4) % 97}/missing.zig`;
   }
+  if (lang === 'r') {
+    // The same three forms in the same proportions as the unique arm, so the
+    // resolved count is identical by construction (asserted). The source
+    // spelling is the one that collides: `R/mod{k}.R` matches the file of that
+    // name in EVERY package, so the suffix lookup is ambiguous across `dirs`
+    // packages — the project-root `source("R/utils.R")` shape a multi-package
+    // repo really has. The external spellings are unchanged and deliberately
+    // share no stem with a real file, or they would suffix-match and stop
+    // being misses.
+    const k = Math.floor(j / dirs);
+    if (local) {
+      const leg = (r >>> 3) % 3;
+      if (leg === 0) return `svc${d}`;
+      if (leg === 1) return `R/mod${k}.R`;
+      return `svc${j % dirs}::mod${k}`;
+    }
+    const miss = (r >>> 3) % 3;
+    if (miss === 0) return ['dplyr', 'ggplot2', 'data.table', 'stringr'][(r >>> 4) % 4];
+    if (miss === 1) return `vendor${(r >>> 4) % 97}/R/missing.R`;
+    return `ext${(r >>> 4) % 97}::tidy`;
+  }
   throw unwiredLanguage('collideTarget', lang);
 }
 
@@ -1780,7 +1920,12 @@ function newPass(lang, files, pad = 0) {
     restoreBenchmarkSideChannels(lang, parsedFiles);
     return {
       allFilePaths: new Set(parsedFiles.map((f) => f.filePath)),
-      config: lang === 'php' ? phpComposerConfigFor(pad) : undefined,
+      config:
+        lang === 'php'
+          ? phpComposerConfigFor(pad)
+          : lang === 'r'
+            ? rPackageConfigFor(files)
+            : undefined,
       parsedFiles,
     };
   }
@@ -1966,6 +2111,33 @@ function resolveOne(lang, from, target, pass) {
   if (lang === 'objc') {
     return objectiveCScopeResolver.resolveImportTarget(target, from, allFilePaths, pass.config);
   }
+  // The registered hook, because R's adapter is where its per-pass file index,
+  // the wildcard guard and the `importFrom` branch all live. `parsedImport` is
+  // rebuilt from the target's spelling exactly the way `interpretRImport` and
+  // `populateRNamespaceImports` mint it: `library()` is a `wildcard`, `source()`
+  // a `side-effect`, and a NAMESPACE `importFrom()` a `named` import whose
+  // `targetRaw` is the package. Only the named form reads `parsedFiles`.
+  if (lang === 'r') {
+    const sep = target.indexOf('::');
+    const parsedImport =
+      sep >= 0
+        ? {
+            kind: 'named',
+            localName: target.slice(sep + 2),
+            importedName: target.slice(sep + 2),
+            targetRaw: target.slice(0, sep),
+          }
+        : target.endsWith('.R')
+          ? { kind: 'side-effect', targetRaw: target }
+          : { kind: 'wildcard', targetRaw: target };
+    return rScopeResolver.resolveImportTarget(
+      parsedImport.targetRaw,
+      from,
+      allFilePaths,
+      pass.config,
+      contextFor(pass, parsedImport),
+    );
+  }
   if (lang === 'csharp' || lang === 'csharp_csproj') {
     return resolveCsharpImportTarget(
       { kind: 'namespace', localName: '_', importedName: '_', targetRaw: target },
@@ -2223,6 +2395,9 @@ const HEAP_PROBE_TARGET = {
   typescript: 'vendor0/lib/missing',
   vue: 'vendor0/lib/Missing.vue',
   cpp: 'vendor0/missing.hpp',
+  // A vendored `source()` path in no package: the exact-join probe misses and
+  // the suffix cascade runs to the end, forcing the workspace file index.
+  r: 'vendor0/R/missing.R',
 };
 
 /**
@@ -2447,6 +2622,24 @@ const CONTEXT_PROBE = {
       probeFile('include/util.hpp', []),
     ],
   },
+  /**
+   * `importFrom(pkgA, f)` where `pkgA` holds `a.R` (defining `f`) and `b.R`
+   * (defining `g`). With the parsed workspace the named import resolves to the
+   * one file that defines `f`; without it the call is the context-free one,
+   * which cannot tell a named import from `library(pkgA)` and answers every
+   * file of the package's `R/`. Two distinct non-null answers, so a dropped
+   * `parsedFiles` cannot look like a miss. `f` is spelled with the `pkg::name`
+   * convention `resolveOne` splits.
+   */
+  r: {
+    from: 'app/R/main.R',
+    target: 'pkgA::f',
+    parsedFiles: [
+      rProbeFile('app/R/main.R', ['main']),
+      rProbeFile('pkgA/R/a.R', ['f']),
+      rProbeFile('pkgA/R/b.R', ['g']),
+    ],
+  },
 };
 
 /** Resolve the probe twice through `resolveOne` — once with the pass's parsed
@@ -2455,7 +2648,12 @@ const CONTEXT_PROBE = {
 function measureContext(lang) {
   const { from, target, parsedFiles } = CONTEXT_PROBE[lang];
   const allFilePaths = new Set(parsedFiles.map((f) => f.filePath));
-  const config = lang === 'php' ? phpComposerConfigFor(0) : undefined;
+  const config =
+    lang === 'php'
+      ? phpComposerConfigFor(0)
+      : lang === 'r'
+        ? rPackageConfigFor(parsedFiles.map((f) => f.filePath))
+        : undefined;
   const answer = (files) => {
     restoreBenchmarkSideChannels(lang, files ?? []);
     const pass = { allFilePaths, config, parsedFiles: files };
@@ -2616,6 +2814,7 @@ const LANG_REGISTRY = {
   cpp: SupportedLanguages.CPlusPlus,
   objc: SupportedLanguages.ObjectiveC,
   zig: SupportedLanguages.Zig,
+  r: SupportedLanguages.R,
 };
 const LANGS = Object.keys(LANG_REGISTRY);
 /**
diff --git a/gitnexus/package-lock.json b/gitnexus/package-lock.json
index b9a2b9dd6..52b1735f0 100644
--- a/gitnexus/package-lock.json
+++ b/gitnexus/package-lock.json
@@ -8,6 +8,7 @@
       "name": "gitnexus",
       "version": "1.6.12",
       "bundleDependencies": [
+        "@eagleoutice/tree-sitter-r",
         "tree-sitter",
         "tree-sitter-c-sharp",
         "tree-sitter-cpp",
@@ -23,6 +24,7 @@
       "hasInstallScript": true,
       "license": "PolyForm-Noncommercial-1.0.0",
       "dependencies": {
+        "@eagleoutice/tree-sitter-r": "1.1.2",
         "@ladybugdb/core": "0.21.1",
         "@modelcontextprotocol/sdk": "^1.0.0",
         "@scarf/scarf": "^1.4.0",
@@ -231,6 +233,26 @@
         "node": ">=18"
       }
     },
+    "node_modules/@eagleoutice/tree-sitter-r": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@eagleoutice/tree-sitter-r/-/tree-sitter-r-1.1.2.tgz",
+      "integrity": "sha512-HR0RyoI5uxcfsdZvTMqSM8GJyGo6DQTkfdgqygQ6N+D0KQObRH4RxYgBZ6ePsGq/36RBAqv8y0NeQvAFL2N4dQ==",
+      "hasInstallScript": true,
+      "inBundle": true,
+      "license": "MIT",
+      "dependencies": {
+        "node-addon-api": "^8.0.0",
+        "node-gyp-build": "^4.8.0"
+      },
+      "peerDependencies": {
+        "tree-sitter": "^0.21.0"
+      },
+      "peerDependenciesMeta": {
+        "tree_sitter": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/@esbuild/aix-ppc64": {
       "version": "0.28.1",
       "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.28.1.tgz",
diff --git a/gitnexus/package.json b/gitnexus/package.json
index 8b9ccc5bc..2d68ed0ae 100644
--- a/gitnexus/package.json
+++ b/gitnexus/package.json
@@ -67,6 +67,7 @@
     "version": "node scripts/sync-plugin-manifests.mjs"
   },
   "dependencies": {
+    "@eagleoutice/tree-sitter-r": "1.1.2",
     "@ladybugdb/core": "0.21.1",
     "@modelcontextprotocol/sdk": "^1.0.0",
     "@scarf/scarf": "^1.4.0",
@@ -143,6 +144,7 @@
     "node": "^22.18.0 || >=24.11.0"
   },
   "bundleDependencies": [
+    "@eagleoutice/tree-sitter-r",
     "tree-sitter",
     "tree-sitter-c-sharp",
     "tree-sitter-cpp",
diff --git a/gitnexus/scripts/assert-native-parsers.mjs b/gitnexus/scripts/assert-native-parsers.mjs
index 84ef1bc97..af3d68081 100644
--- a/gitnexus/scripts/assert-native-parsers.mjs
+++ b/gitnexus/scripts/assert-native-parsers.mjs
@@ -31,6 +31,7 @@ const SAMPLES = {
   dart: 'void main() { print(1); }\n',
   kotlin: 'class A {\n  fun m() {}\n}\n',
   zig: 'pub fn main() void {}\n',
+  r: 'f <- function(x) x\n',
 };
 
 async function check(installedDir) {
diff --git a/gitnexus/scripts/prepare-tree-sitter-bundle.cjs b/gitnexus/scripts/prepare-tree-sitter-bundle.cjs
index 648cb895a..e5ba9354c 100644
--- a/gitnexus/scripts/prepare-tree-sitter-bundle.cjs
+++ b/gitnexus/scripts/prepare-tree-sitter-bundle.cjs
@@ -13,6 +13,7 @@ const path = require('node:path');
 const RUNTIME = '0.25.1';
 // Upstream metadata is an input to validate, never the peer range we ship.
 const AUDITED_PEERS = new Map([
+  ['@eagleoutice/tree-sitter-r@1.1.2', '^0.21.0'],
   ['tree-sitter-c@0.23.6', '^0.22.1'],
   ['tree-sitter-cpp@0.23.4', '^0.21.1'],
   ['tree-sitter-java@0.23.5', '^0.21.1'],
@@ -30,8 +31,10 @@ function prepareTreeSitterBundle(packageRoot = path.resolve(__dirname, '..')) {
   if (manifest.dependencies['tree-sitter'] !== RUNTIME) {
     throw new Error(`Tree-sitter bundle is only validated for runtime ${RUNTIME}`);
   }
+  // A grammar is recognised by its package basename, so a scoped package such as
+  // @eagleoutice/tree-sitter-r is held to the same bundling and pinning rules.
   const grammars = Object.keys(manifest.dependencies).filter(
-    (name) => name === 'tree-sitter' || name.startsWith('tree-sitter-'),
+    (name) => name === 'tree-sitter' || name.split('/').pop().startsWith('tree-sitter-'),
   );
   for (const name of grammars) {
     if (
diff --git a/gitnexus/src/core/ingestion/export-detection.ts b/gitnexus/src/core/ingestion/export-detection.ts
index 143358c6f..56a9f5f01 100644
--- a/gitnexus/src/core/ingestion/export-detection.ts
+++ b/gitnexus/src/core/ingestion/export-detection.ts
@@ -303,3 +303,10 @@ export function hasZigPubKeyword(declNode: SyntaxNode): boolean {
   }
   return false;
 }
+
+/**
+ * R: every definition is exported by default. NAMESPACE-driven export
+ * refinement lives in R's `postParse` hook (ExportChecker has no file-path
+ * context; NAMESPACE detection needs it).
+ */
+export const rExportChecker: ExportChecker = (_node, _name) => true;
diff --git a/gitnexus/src/core/ingestion/field-extractors/r.ts b/gitnexus/src/core/ingestion/field-extractors/r.ts
new file mode 100644
index 000000000..3e6c38964
--- /dev/null
+++ b/gitnexus/src/core/ingestion/field-extractors/r.ts
@@ -0,0 +1,259 @@
+// gitnexus/src/core/ingestion/field-extractors/r.ts
+
+/**
+ * R field extractor — hand-written because R expresses classes as function
+ * calls (R6Class(), setClass(), setRefClass()) rather than dedicated class syntax, so the
+ * generic config-driven factory cannot navigate the AST.
+ *
+ * Handles:
+ * - R6 fields: non-function entries in public/private list()
+ * - R5 fields: setRefClass("Foo", fields = list(name = "character"))
+ * - S4 representation/slots: setClass("Foo", representation(name = "character"))
+ */
+
+import type { SyntaxNode } from '../utils/ast-helpers.js';
+import { SupportedLanguages } from 'gitnexus-shared';
+import { BaseFieldExtractor } from '../field-extractor.js';
+import { isRNamingArgument } from '../languages/r/naming-argument.js';
+import type {
+  FieldExtractorContext,
+  ExtractedFields,
+  FieldInfo,
+  FieldVisibility,
+} from '../field-types.js';
+
+export class RFieldExtractor extends BaseFieldExtractor {
+  language = SupportedLanguages.R;
+
+  isTypeDeclaration(node: SyntaxNode): boolean {
+    return isR6Class(node) || isS4Class(node);
+  }
+
+  protected extractVisibility(_node: SyntaxNode): FieldVisibility {
+    return 'public';
+  }
+
+  extract(node: SyntaxNode, context: FieldExtractorContext): ExtractedFields | null {
+    if (isR6Class(node)) return this.extractR6Fields(node, context);
+    if (isS4Class(node)) return this.extractS4Fields(node, context);
+    return null;
+  }
+
+  // --------------------------------------------------------------------------
+  // R6 field extraction
+  // --------------------------------------------------------------------------
+
+  private extractR6Fields(
+    node: SyntaxNode,
+    context: FieldExtractorContext,
+  ): ExtractedFields | null {
+    const ownerFqn = node.childForFieldName('lhs')?.text;
+    if (!ownerFqn) return null;
+
+    const call = node.childForFieldName('rhs');
+    if (!call) return null;
+
+    const args = call.childForFieldName('arguments');
+    if (!args) return null;
+
+    const fields: FieldInfo[] = [];
+
+    for (let i = 0; i < args.namedChildCount; i++) {
+      const arg = args.namedChild(i);
+      if (!arg || arg.type !== 'argument') continue;
+
+      const section = arg.childForFieldName('name')?.text;
+      if (section !== 'public' && section !== 'private') continue;
+
+      const visibility: FieldVisibility = section === 'private' ? 'private' : 'public';
+      const listCall = arg.childForFieldName('value');
+      if (!listCall || listCall.type !== 'call') continue;
+
+      const listArgs = listCall.childForFieldName('arguments');
+      if (!listArgs) continue;
+
+      for (let j = 0; j < listArgs.namedChildCount; j++) {
+        const entry = listArgs.namedChild(j);
+        if (!entry || entry.type !== 'argument') continue;
+
+        const nameNode = entry.childForFieldName('name');
+        const valueNode = entry.childForFieldName('value');
+        if (!nameNode) continue;
+
+        // Skip function entries (those are methods, not fields)
+        if (valueNode?.type === 'function_definition') continue;
+
+        fields.push({
+          name: nameNode.text,
+          type: inferR6FieldType(valueNode),
+          visibility,
+          isStatic: false,
+          isReadonly: false,
+          sourceFile: context.filePath,
+          line: entry.startPosition.row + 1,
+        });
+      }
+    }
+
+    return fields.length > 0 ? { ownerFqn, fields, nestedTypes: [] } : null;
+  }
+
+  // --------------------------------------------------------------------------
+  // S4 field extraction (representation / slots / fields)
+  // --------------------------------------------------------------------------
+
+  private extractS4Fields(
+    node: SyntaxNode,
+    context: FieldExtractorContext,
+  ): ExtractedFields | null {
+    const args = node.childForFieldName('arguments');
+    if (!args) return null;
+
+    // The class name is the `Class` argument (by name, else the first unnamed one).
+    const ownerFqn = getRClassNameArgument(args);
+    if (!ownerFqn) return null;
+
+    const fields: FieldInfo[] = [];
+
+    for (let i = 0; i < args.namedChildCount; i++) {
+      const arg = args.namedChild(i);
+      if (!arg || arg.type !== 'argument') continue;
+
+      const paramName = arg.childForFieldName('name')?.text;
+      if (paramName !== 'representation' && paramName !== 'slots' && paramName !== 'fields')
+        continue;
+
+      const slotCall = arg.childForFieldName('value');
+      if (!slotCall || slotCall.type !== 'call') continue;
+
+      const slotArgs = slotCall.childForFieldName('arguments');
+      if (!slotArgs) continue;
+
+      for (let j = 0; j < slotArgs.namedChildCount; j++) {
+        const slot = slotArgs.namedChild(j);
+        if (!slot || slot.type !== 'argument') continue;
+
+        const slotName = slot.childForFieldName('name');
+        const slotType = slot.childForFieldName('value');
+        if (!slotName) continue;
+
+        const typeName = extractQuotedTypeName(slotType);
+
+        fields.push({
+          name: slotName.text,
+          type: typeName,
+          visibility: 'public',
+          isStatic: false,
+          isReadonly: false,
+          sourceFile: context.filePath,
+          line: slot.startPosition.row + 1,
+        });
+      }
+    }
+
+    return fields.length > 0 ? { ownerFqn, fields, nestedTypes: [] } : null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// AST helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * The class name of a `setClass` / `setRefClass` argument list: the string value of
+ * the argument that takes the `Class` formal. Uses the same selection as the scope
+ * query and definition hook (`isRNamingArgument`), so `contains = "Base"` or
+ * `representation(...)` ahead of `Class = "A"` never names the owner.
+ */
+export function getRClassNameArgument(args: SyntaxNode): string | null {
+  for (let i = 0; i < args.namedChildCount; i++) {
+    const arg = args.namedChild(i);
+    if (!arg || arg.type !== 'argument') continue;
+    if (!isRNamingArgument(arg, 'Class')) continue;
+    const value = arg.childForFieldName('value');
+    if (value?.type !== 'string') continue;
+    const name = extractQuotedTypeName(value);
+    if (name) return name;
+  }
+  return null;
+}
+
+export function findRFieldOwnerNode(node: SyntaxNode): SyntaxNode | null {
+  let current: SyntaxNode | null = node;
+  while (current) {
+    if (isR6Class(current) || isS4Class(current)) return current;
+    current = current.parent;
+  }
+  return null;
+}
+
+export function getRTopLevelPropertyOwnerName(node: SyntaxNode): string | null {
+  const ownerNode = findRFieldOwnerNode(node);
+  if (!ownerNode) return null;
+
+  if (ownerNode.type === 'binary_operator') {
+    return ownerNode.childForFieldName('lhs')?.text ?? null;
+  }
+
+  const args = ownerNode.childForFieldName('arguments');
+  if (!args) return null;
+  return getRClassNameArgument(args);
+}
+
+/** Check if a binary_operator node is an R6 class assignment. */
+function isR6Class(node: SyntaxNode): boolean {
+  if (node.type !== 'binary_operator') return false;
+  const rhs = node.childForFieldName('rhs');
+  if (!rhs || rhs.type !== 'call') return false;
+  const fn = rhs.childForFieldName('function');
+  if (!fn) return false;
+  // R6Class(...)
+  if (fn.type === 'identifier' && fn.text === 'R6Class') return true;
+  // R6::R6Class(...)
+  if (fn.type === 'namespace_operator') {
+    const rhsFn = fn.childForFieldName('rhs');
+    return rhsFn?.text === 'R6Class';
+  }
+  return false;
+}
+
+/** Check if a call node is setClass() or setRefClass(). */
+function isS4Class(node: SyntaxNode): boolean {
+  if (node.type !== 'call') return false;
+  const fn = node.childForFieldName('function');
+  return fn?.type === 'identifier' && (fn.text === 'setClass' || fn.text === 'setRefClass');
+}
+
+/** Infer a basic type from an R6 field default value. */
+function inferR6FieldType(valueNode: SyntaxNode | null): string | null {
+  if (!valueNode) return null;
+  switch (valueNode.type) {
+    case 'null':
+      return null;
+    case 'true':
+    case 'false':
+      return 'logical';
+    case 'float':
+      return 'numeric';
+    case 'integer':
+      return 'integer';
+    case 'string':
+      return 'character';
+    default:
+      // NA variants
+      if (valueNode.type === 'identifier') {
+        const text = valueNode.text;
+        if (text === 'NA_character_') return 'character';
+        if (text === 'NA_integer_') return 'integer';
+        if (text === 'NA_real_') return 'numeric';
+        if (text === 'NA_complex_') return 'complex';
+      }
+      return null;
+  }
+}
+
+function extractQuotedTypeName(node: SyntaxNode | null): string | null {
+  if (!node || node.type !== 'string') return null;
+  const content = node.namedChildren.find((c) => c.type === 'string_content');
+  return content?.text ?? node.text.replace(/^["']|["']$/g, '');
+}
diff --git a/gitnexus/src/core/ingestion/import-resolvers/r.ts b/gitnexus/src/core/ingestion/import-resolvers/r.ts
new file mode 100644
index 000000000..15a06a5bc
--- /dev/null
+++ b/gitnexus/src/core/ingestion/import-resolvers/r.ts
@@ -0,0 +1,249 @@
+/**
+ * R import resolution.
+ * Handles library(), require(), source(), and pkg::func() resolution.
+ */
+
+import path from 'path';
+import type { SuffixIndex } from './utils.js';
+import { suffixResolve } from './utils.js';
+import type { ParsedFile } from 'gitnexus-shared';
+import { rExportPatternMatches, type RPackageConfig } from '../languages/r/package-config.js';
+import {
+  rFileTopLevel,
+  rPackageDirForFile,
+  type RFileTopLevel,
+} from '../languages/r/namespace-imports.js';
+import type { ImportResult, ResolveCtx } from './types.js';
+import type { ImportResolutionContext } from '../scope-resolution/contract/scope-resolver.js';
+import { getWorkspaceFileIndex } from './workspace-file-index.js';
+
+/**
+ * Low-level R import resolver (internal helper).
+ * Resolves library/require/source paths to matching .R files.
+ *
+ * `normToRaw` (normalized path → first raw path with that spelling, built once per pass by
+ * `getWorkspaceFileIndex`) answers the exact-path lookups of `source()` in O(1). Without it
+ * they fall back to `indexOf` over `normalizedFileList`, which picks the same file (the first
+ * in list order) but costs O(files) per `source()` import.
+ */
+export function resolveRImportInternal(
+  filePath: string,
+  rawImportPath: string,
+  normalizedFileList: readonly string[],
+  allFileList: readonly string[],
+  rConfig: RPackageConfig | null,
+  index?: SuffixIndex,
+  normToRaw?: ReadonlyMap<string, string>,
+): string | string[] | null {
+  const exactFile = (normalizedPath: string): string | undefined => {
+    if (normToRaw !== undefined) return normToRaw.get(normalizedPath);
+    const idx = normalizedFileList.indexOf(normalizedPath);
+    return idx >= 0 ? allFileList[idx] : undefined;
+  };
+  const cleaned = rawImportPath.replace(/^["']|["']$/g, '');
+
+  // source() with file path
+  if (cleaned.endsWith('.R') || cleaned.endsWith('.r')) {
+    if (path.isAbsolute(cleaned)) {
+      const normalized = cleaned.replace(/\\/g, '/');
+      return exactFile(normalized) ?? null;
+    }
+    const dir = path.dirname(filePath);
+    const resolved = path.join(dir, cleaned).replace(/\\/g, '/');
+    const direct = exactFile(resolved);
+    if (direct !== undefined) return direct;
+
+    const pathParts = cleaned.split('/').filter(Boolean);
+    return suffixResolve(pathParts, normalizedFileList, allFileList, index);
+  }
+
+  // library("pkg") / require("pkg") — resolve to ALL files in the local package
+  if (rConfig) {
+    const pkgDir = rConfig.packages.get(cleaned);
+    // A root-level package has the directory '' (falsy), so test for absence, not truthiness.
+    if (pkgDir !== undefined) {
+      const rDirPrefix = (pkgDir ? pkgDir + '/' : '') + 'R/';
+      const files: string[] = [];
+      for (let i = 0; i < normalizedFileList.length; i++) {
+        if (
+          normalizedFileList[i].startsWith(rDirPrefix) &&
+          (normalizedFileList[i].endsWith('.R') || normalizedFileList[i].endsWith('.r'))
+        ) {
+          files.push(allFileList[i]);
+        }
+      }
+      if (files.length > 0) return files;
+    }
+  }
+
+  // Fallback: suffix-based resolution
+  const pathParts = cleaned.split('/').filter(Boolean);
+  return suffixResolve(pathParts, normalizedFileList, allFileList, index);
+}
+
+/** R: library/require/source resolution via R package config. */
+export function resolveRImport(
+  rawImportPath: string,
+  filePath: string,
+  ctx: ResolveCtx,
+): ImportResult {
+  const resolved = resolveRImportInternal(
+    filePath,
+    rawImportPath,
+    ctx.normalizedFileList,
+    ctx.allFileList,
+    // The legacy `ResolveCtx` bundle never carried R's config; the live path is
+    // `resolveRImportTarget` + `loadResolutionConfig`.
+    null,
+    ctx.index,
+  );
+  if (!resolved) return null;
+  const files = Array.isArray(resolved) ? resolved : [resolved];
+  return { kind: 'files', files };
+}
+
+/** Per-package index of top-level definitions, built once per `parsedFiles` array. */
+interface RPackageDefIndex {
+  /** Files of the package's `R/` directory, with what each defines at top level. */
+  readonly files: ReadonlyMap<string, RFileTopLevel>;
+  /** Top-level name → files (in `parsedFiles` order) that define it. */
+  readonly definingFiles: ReadonlyMap<string, readonly string[]>;
+}
+
+const packageDefIndexes = new WeakMap<
+  readonly ParsedFile[],
+  WeakMap<RPackageConfig, ReadonlyMap<string, RPackageDefIndex>>
+>();
+
+function packageDefIndex(
+  parsedFiles: readonly ParsedFile[],
+  rConfig: RPackageConfig,
+  pkg: string,
+): RPackageDefIndex | undefined {
+  let byConfig = packageDefIndexes.get(parsedFiles);
+  if (byConfig === undefined) packageDefIndexes.set(parsedFiles, (byConfig = new WeakMap()));
+  let byPackage = byConfig.get(rConfig);
+  if (byPackage === undefined) {
+    const files = new Map<string, Map<string, RFileTopLevel>>();
+    const defining = new Map<string, Map<string, string[]>>();
+    for (const parsed of parsedFiles) {
+      const location = rPackageDirForFile(parsed.filePath, rConfig);
+      if (location === undefined) continue;
+      const topLevel = rFileTopLevel(parsed);
+      let pkgFiles = files.get(location.name);
+      let pkgDefining = defining.get(location.name);
+      if (pkgFiles === undefined || pkgDefining === undefined) {
+        files.set(location.name, (pkgFiles = new Map()));
+        defining.set(location.name, (pkgDefining = new Map()));
+      }
+      pkgFiles.set(parsed.filePath, topLevel);
+      for (const name of topLevel.names) {
+        const list = pkgDefining.get(name);
+        if (list === undefined) pkgDefining.set(name, [parsed.filePath]);
+        else list.push(parsed.filePath);
+      }
+    }
+    const built = new Map<string, RPackageDefIndex>();
+    for (const [name, pkgFiles] of files) {
+      built.set(name, { files: pkgFiles, definingFiles: defining.get(name) ?? new Map() });
+    }
+    byConfig.set(rConfig, (byPackage = built));
+  }
+  return byPackage.get(pkg);
+}
+
+const stripBackticks = (s: string): string => s.replace(/^`+|`+$/g, '');
+
+/**
+ * Resolve a NAMESPACE `importFrom(pkg, importedName)` to the `R/` file(s) of the
+ * local package `pkg` that define `importedName` at top level, or `null`.
+ *
+ * `null` (no binding, no IMPORTS edge) when: `pkg` is not a local package
+ * (external packages never suffix-match anything); `importedName` is dotted
+ * (finalize keys defs by the text after the last `.`, so it can never bind);
+ * the provider has a NAMESPACE that does not export the name; no file defines
+ * it at top level; or a defining file also holds a dotted top-level def whose
+ * tail equals `importedName` (finalize would index `print.tidy` under `tidy`
+ * and bind the WRONG def — the guard is order-blind, so it also refuses the
+ * layout where the bare def comes first). `null` degrades the call site to the
+ * baseline `global-name-fallback` guess. Never builds a workspace file index.
+ */
+export function resolveRNamedImport(
+  rConfig: RPackageConfig | null,
+  targetRaw: string,
+  importedName: string,
+  parsedFiles: readonly ParsedFile[],
+): readonly string[] | null {
+  const pkg = targetRaw.replace(/^["']|["']$/g, '');
+  const pkgDir = rConfig?.packages.get(pkg);
+  if (rConfig === null || pkgDir === undefined) return null;
+
+  if (importedName.includes('.')) return null;
+
+  const info = rConfig.namespaceInfoByPackageDir.get(pkgDir);
+  if (info !== undefined && info.hasNamespaceFile) {
+    const exported =
+      info.namedExports.has(importedName) ||
+      [...info.namedExports].some((entry) => stripBackticks(entry) === importedName) ||
+      rExportPatternMatches(info, importedName);
+    if (!exported) return null;
+  }
+
+  const index = packageDefIndex(parsedFiles, rConfig, pkg);
+  const defining = index?.definingFiles.get(importedName);
+  if (index === undefined || defining === undefined || defining.length === 0) return null;
+  if (defining.some((file) => index.files.get(file)?.dottedTails.has(importedName) === true)) {
+    return null;
+  }
+  return defining;
+}
+
+/**
+ * `ScopeResolver.resolveImportTarget`-shaped adapter over
+ * `resolveRImportInternal`. Two responsibilities live only here, not in the
+ * internal resolver:
+ *
+ *  - Memoization: `getWorkspaceFileIndex` derives `{ normalized, all, index }`
+ *    once per `allFilePaths` Set identity (see its own doc comment) and this
+ *    adapter calls it on every invocation instead of materializing fresh
+ *    arrays per import — the O(imports × files) regression PR #1918/#2911
+ *    exist to catch (`import-target-index-reuse.contract.test.ts`).
+ *  - Cross-language false-positive guard: a `library()`/`require()` package
+ *    name not found in `rConfig.packages` would otherwise fall through to
+ *    `resolveRImportInternal`'s generic suffix fallback — and `EXTENSIONS`
+ *    (`./utils.js`) has no `.R`/`.r` entry, so a bare R package reference can
+ *    suffix-match an unrelated same-named file in another language.
+ *    `context.parsedImport.kind === 'wildcard'` is exactly the
+ *    `library()`/`require()` shape (see `interpretRImport`), so the guard is
+ *    scoped to that kind only — `source()`'s own suffix-based file-path
+ *    fallback is unaffected.
+ *  - NAMESPACE `importFrom()` names (`kind: 'named'`, synthesised by
+ *    `populateRNamespaceImports`): resolved by {@link resolveRNamedImport}
+ *    before `getWorkspaceFileIndex`, so they build no file index.
+ */
+export function resolveRImportTarget(
+  targetRaw: string,
+  fromFile: string,
+  allFilePaths: ReadonlySet<string>,
+  resolutionConfig?: unknown,
+  context?: ImportResolutionContext,
+): string | readonly string[] | null {
+  const rConfig = (resolutionConfig as RPackageConfig | null | undefined) ?? null;
+
+  if (context?.parsedImport?.kind === 'wildcard') {
+    const cleaned = targetRaw.replace(/^["']|["']$/g, '');
+    if (rConfig === null || !rConfig.packages.has(cleaned)) return null;
+  }
+
+  if (context?.parsedImport?.kind === 'named') {
+    return resolveRNamedImport(
+      rConfig,
+      targetRaw,
+      context.parsedImport.importedName,
+      context.parsedFiles,
+    );
+  }
+
+  const { normalized, all, index, normToRaw } = getWorkspaceFileIndex(allFilePaths);
+  return resolveRImportInternal(fromFile, targetRaw, normalized, all, rConfig, index, normToRaw);
+}
diff --git a/gitnexus/src/core/ingestion/language-provider.ts b/gitnexus/src/core/ingestion/language-provider.ts
index 6dd8ddca1..500593e96 100644
--- a/gitnexus/src/core/ingestion/language-provider.ts
+++ b/gitnexus/src/core/ingestion/language-provider.ts
@@ -38,6 +38,8 @@ import type { ImportResolverFn } from './import-resolvers/types.js';
 import type { SyntaxNode } from './utils/ast-helpers.js';
 import type { CfgVisitor } from './cfg/types.js';
 import type { GraphNode, NodeLabel, ParameterTypeClass, RelationshipType } from 'gitnexus-shared';
+import type { KnowledgeGraph } from '../graph/types.js';
+import type { MutableSemanticModel } from './model/semantic-model.js';
 import type { ExtractedRoute } from './route-extractors/laravel.js';
 import type { SharedSpringType } from './route-extractors/spring-shared.js';
 import type {
@@ -233,6 +235,16 @@ export function shouldHarvestModuleConstants(
   return !provider.moduleConstantHeuristic || provider.moduleConstantHeuristic(content);
 }
 
+/**
+ * Everything a {@link LanguageProviderConfig.postParse} hook may read or mutate: the merged graph, the
+ * populated semantic model, and the repository root. Hooks mutate `graph`/`model` in place.
+ */
+export interface PostParseContext {
+  readonly graph: KnowledgeGraph;
+  readonly model: MutableSemanticModel;
+  readonly repoPath: string;
+}
+
 interface LanguageProviderConfig {
   // ── Identity ──────────────────────────────────────────────────────
   readonly id: SupportedLanguages;
@@ -376,6 +388,16 @@ interface LanguageProviderConfig {
     filePath: string,
   ) => { readonly name: string; readonly label: NodeLabel } | null;
 
+  /**
+   * For languages whose member owner is not a syntactic ancestor container
+   * (R: `R6Class(...)` / `setRefClass(...)` calls): return the node the
+   * method/field extractors read members from, or `null`.
+   *
+   * Consulted by the enclosing-owner slot after the container walk and
+   * `resolveFileTypeOwner` (same slot as the Zig file-owner).
+   * Default: undefined. */
+  readonly resolveMemberOwnerNode?: (definitionNode: SyntaxNode) => SyntaxNode | null;
+
   /**
    * The type a CONTAINER node declares, when the language names it from its
    * context rather than from a name child of the node — a binding wrapper,
@@ -732,6 +754,20 @@ interface LanguageProviderConfig {
    */
   readonly prepareRouteConstants?: (repo: RepoConstants) => void;
 
+  /**
+   * Whole-graph work that can only run once every chunk is merged and before scope resolution
+   * (deferred owner resolution, package-manifest-driven export refinement). "Post-parse" means after
+   * all chunks are merged but still inside the parse phase — not the later `crossFile` phase.
+   *
+   * Called once per analyze, only if this language has parsed files, awaited, on the main thread.
+   * Mutates `ctx.graph` / `ctx.model` in place. A throw aborts the parse phase (it is not isolated,
+   * because the hook mutates shared state and a swallowed mid-mutation throw could leave the graph
+   * half-updated).
+   *
+   * Default: undefined (nothing to do after the merge).
+   */
+  readonly postParse?: (ctx: PostParseContext) => void | Promise<void>;
+
   /**
    * Spring async messaging facts captured for one file — the listener
    * annotations that subscribe to a broker destination and the template calls
@@ -1237,6 +1273,22 @@ export function prepareRouteConstantsByProvider(
   }
 }
 
+/**
+ * Run each present language's {@link LanguageProviderConfig.postParse} hook, sequentially and in
+ * language-id order (independent of scan order), awaiting each before the next: the hooks share one
+ * mutable graph/model. The provider lookup is a callback so this file needs no registry import.
+ * A rejection propagates and later hooks do not run.
+ */
+export async function runPostParseHooks(
+  presentLanguages: ReadonlySet<SupportedLanguages>,
+  providerFor: (language: SupportedLanguages) => Pick<LanguageProvider, 'postParse'> | undefined,
+  ctx: PostParseContext,
+): Promise<void> {
+  for (const language of [...presentLanguages].sort()) {
+    await providerFor(language)?.postParse?.(ctx);
+  }
+}
+
 const DEFAULTS: Pick<LanguageProvider, 'mroStrategy'> = {
   mroStrategy: 'first-wins',
 };
diff --git a/gitnexus/src/core/ingestion/languages/index.ts b/gitnexus/src/core/ingestion/languages/index.ts
index b10822a6f..0ade266c9 100644
--- a/gitnexus/src/core/ingestion/languages/index.ts
+++ b/gitnexus/src/core/ingestion/languages/index.ts
@@ -29,6 +29,7 @@ import { rubyProvider } from './ruby.js';
 import { swiftProvider } from './swift.js';
 import { dartProvider } from './dart.js';
 import { vueProvider } from './vue.js';
+import { rProvider } from './r.js';
 import { cobolProvider } from './cobol.js';
 import { zigProvider } from './zig.js';
 
@@ -49,6 +50,7 @@ export const providers = {
   [SupportedLanguages.Swift]: swiftProvider,
   [SupportedLanguages.Dart]: dartProvider,
   [SupportedLanguages.Vue]: vueProvider,
+  [SupportedLanguages.R]: rProvider,
   [SupportedLanguages.Cobol]: cobolProvider,
   [SupportedLanguages.Zig]: zigProvider,
 } satisfies Record<SupportedLanguages, LanguageProvider>;
diff --git a/gitnexus/src/core/ingestion/languages/r.ts b/gitnexus/src/core/ingestion/languages/r.ts
new file mode 100644
index 000000000..e143dea1d
--- /dev/null
+++ b/gitnexus/src/core/ingestion/languages/r.ts
@@ -0,0 +1,195 @@
+/**
+ * R language provider.
+ *
+ * R uses wildcard import semantics — library() and source() bring
+ * everything into scope (no named imports). No special call routing
+ * is needed (unlike Ruby); R imports are parsed as standard import nodes.
+ */
+
+import { SupportedLanguages } from 'gitnexus-shared';
+import { defineLanguage } from '../language-provider.js';
+import { typeConfig as rTypeConfig } from '../type-extractors/r.js';
+import { rExportChecker } from '../export-detection.js';
+import { resolveRImport } from '../import-resolvers/r.js';
+import { R_QUERIES } from '../tree-sitter-queries.js';
+import { RFieldExtractor } from '../field-extractors/r.js';
+import { rMethodExtractor } from '../method-extractors/r.js';
+import { emitRScopeCaptures } from './r/captures.js';
+import { interpretRImport, interpretRTypeBinding } from './r/interpret.js';
+import { rPostParse } from './r/post-parse.js';
+import { rDefinitionProperties, rResolveMemberOwnerNode } from './r/owner-hooks.js';
+import { isRNonNamingArgumentCapture } from './r/naming-argument.js';
+
+const R_BUILT_INS: ReadonlySet<string> = new Set([
+  // Base R
+  'c',
+  'list',
+  'vector',
+  'matrix',
+  'array',
+  'data.frame',
+  'length',
+  'nrow',
+  'ncol',
+  'dim',
+  'names',
+  'colnames',
+  'rownames',
+  'print',
+  'cat',
+  'paste',
+  'paste0',
+  'sprintf',
+  'message',
+  'warning',
+  'stop',
+  'tryCatch',
+  'withCallingHandlers',
+  'try',
+  'on.exit',
+  'sys.call',
+  'match.arg',
+  // Type checks / coercion
+  'is.null',
+  'is.na',
+  'is.numeric',
+  'is.character',
+  'is.logical',
+  'is.list',
+  'as.character',
+  'as.numeric',
+  'as.integer',
+  'as.logical',
+  'as.data.frame',
+  // Apply family
+  'lapply',
+  'sapply',
+  'vapply',
+  'mapply',
+  'tapply',
+  'apply',
+  'Map',
+  'Reduce',
+  'Filter',
+  // Functional
+  'do.call',
+  'Recall',
+  'match.fun',
+  // I/O
+  'readRDS',
+  'saveRDS',
+  'readLines',
+  'writeLines',
+  'read.csv',
+  'write.csv',
+  // Environment
+  'new.env',
+  'environment',
+  'parent.env',
+  'globalenv',
+  'baseenv',
+  'exists',
+  'get',
+  'assign',
+  'rm',
+  'ls',
+  // String
+  'nchar',
+  'substr',
+  'substring',
+  'gsub',
+  'sub',
+  'grep',
+  'grepl',
+  'regmatches',
+  'trimws',
+  'toupper',
+  'tolower',
+  'startsWith',
+  'endsWith',
+  'strsplit',
+  // Math
+  'sum',
+  'mean',
+  'median',
+  'min',
+  'max',
+  'abs',
+  'sqrt',
+  'log',
+  'exp',
+  'round',
+  'ceiling',
+  'floor',
+  'seq',
+  'seq_len',
+  'seq_along',
+  'rep',
+  'which',
+  'range',
+  'cumsum',
+  'diff',
+  // Logical
+  'any',
+  'all',
+  'xor',
+  'identical',
+  // Sort / order
+  'sort',
+  'order',
+  'rev',
+  'unique',
+  'duplicated',
+  'table',
+  // S4 / R6 internals
+  'setClass',
+  'setGeneric',
+  'setMethod',
+  'setRefClass',
+  'new',
+  'validObject',
+  'is',
+  'extends',
+  'isVirtualClass',
+  'R6Class',
+  // Package / namespace
+  'library',
+  'require',
+  'requireNamespace',
+  'loadNamespace',
+  'getNamespace',
+  'source',
+  'sys.source',
+  'attachNamespace',
+  // Control flow (builtins that appear as calls)
+  'return',
+  'invisible',
+  'missing',
+  'nargs',
+  'Sys.time',
+  'Sys.sleep',
+  'proc.time',
+]);
+
+export const rProvider = defineLanguage({
+  id: SupportedLanguages.R,
+  extensions: ['.R', '.r'],
+  entryPointPatterns: [],
+  astFrameworkPatterns: [],
+  treeSitterQueries: R_QUERIES,
+  typeConfig: rTypeConfig,
+  exportChecker: rExportChecker,
+  importResolver: resolveRImport,
+  fieldExtractor: new RFieldExtractor(),
+  methodExtractor: rMethodExtractor,
+  builtInNames: R_BUILT_INS,
+  emitScopeCaptures: emitRScopeCaptures,
+  interpretImport: interpretRImport,
+  interpretTypeBinding: interpretRTypeBinding,
+  postParse: rPostParse,
+  resolveMemberOwnerNode: rResolveMemberOwnerNode,
+  definitionPropertiesExtractor: rDefinitionProperties,
+  // R_QUERIES captures every string argument of setClass/setGeneric/setMethod;
+  // only the one that names the definition is kept.
+  shouldSkipDefinitionCapture: isRNonNamingArgumentCapture,
+});
diff --git a/gitnexus/src/core/ingestion/languages/r/captures.ts b/gitnexus/src/core/ingestion/languages/r/captures.ts
new file mode 100644
index 000000000..edfe74c27
--- /dev/null
+++ b/gitnexus/src/core/ingestion/languages/r/captures.ts
@@ -0,0 +1,48 @@
+import type { Capture, CaptureMatch } from 'gitnexus-shared';
+import { nodeToCapture } from '../../utils/ast-helpers.js';
+import { getRParser, getRScopeQuery } from './query.js';
+import { isRNonNamingScopeMatch } from './naming-argument.js';
+import { getTreeSitterBufferSize } from '../../constants.js';
+import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
+
+/**
+ * Emit R scope captures — a single tree-sitter query run against the R
+ * grammar (see `query.ts` for the capture shapes and the rationale for each
+ * one). No programmatic enrichment is needed: unlike C/Zig/Rust, R's
+ * declarations carry no synthesized arity/parameter metadata, and heritage
+ * sites resolve directly by name (no marker encoding, unlike Ruby's
+ * `include`/`extend`/`prepend`).
+ */
+export function emitRScopeCaptures(
+  sourceText: string,
+  filePath: string,
+  cachedTree?: unknown,
+): readonly CaptureMatch[] {
+  let tree = cachedTree as ReturnType<ReturnType<typeof getRParser>['parse']> | undefined;
+  if (tree === undefined) {
+    tree = parseSourceSafe(getRParser(), sourceText, undefined, {
+      bufferSize: getTreeSitterBufferSize(sourceText),
+    });
+  }
+
+  const rawMatches = getRScopeQuery().matches(tree.rootNode);
+  const out: CaptureMatch[] = [];
+
+  for (const m of rawMatches) {
+    // The scope query captures every candidate argument of setClass/library/require/
+    // source; keep only the one that names the class or import.
+    if (isRNonNamingScopeMatch(m.captures)) continue;
+    const grouped: Record<string, Capture> = {};
+    let hasRealCapture = false;
+    for (const c of m.captures) {
+      const tag = '@' + c.name;
+      if (tag.startsWith('@_')) continue;
+      grouped[tag] = nodeToCapture(tag, c.node);
+      hasRealCapture = true;
+    }
+    if (!hasRealCapture) continue;
+    out.push(grouped);
+  }
+
+  return out;
+}
diff --git a/gitnexus/src/core/ingestion/languages/r/export-pattern.ts b/gitnexus/src/core/ingestion/languages/r/export-pattern.ts
new file mode 100644
index 000000000..f60920ce4
--- /dev/null
+++ b/gitnexus/src/core/ingestion/languages/r/export-pattern.ts
@@ -0,0 +1,234 @@
+import { compileLinearRegexDetailed, type SharedWorkBudget } from './linear-regex.js';
+
+/**
+ * `exportPattern("...")` compilation for R NAMESPACE files.
+ *
+ * R evaluates `exportPattern()` arguments as POSIX (TRE) extended regular
+ * expressions, whose bracket expressions support named classes such as
+ * `[[:alpha:]]`. JavaScript's `RegExp` has no such classes: it reads
+ * `[[:alpha:]]` as the set `[:alph` followed by a literal `]`. The RStudio
+ * new-package template writes `exportPattern("^[[:alpha:]]+")`, so without a
+ * translation step that pattern never matches anything.
+ *
+ * {@link compileRExportPattern} rewrites POSIX classes inside bracket
+ * expressions to ASCII JS equivalents (the C-locale meaning of each class) and
+ * compiles the result once. Patterns without `[:` are compiled verbatim, so
+ * their behaviour is unchanged. It never throws.
+ *
+ * The compiled form is a linear-time matcher, not a `RegExp`: the pattern text comes
+ * from the repository being analysed, and a backtracking engine lets a hostile
+ * pattern such as `^(a+)+$` hang the analyzer (R itself uses the non-backtracking
+ * TRE). See `linear-regex.ts` for the supported subset; a pattern outside it
+ * compiles to null and therefore matches nothing. Callers that care why use
+ * {@link compileRExportPatternDetailed}, so that a dropped pattern is reported
+ * rather than silently treated as an empty export list.
+ *
+ * The argument reaches {@link compileRExportPattern} as an R string *value*:
+ * {@link unescapeRString} first turns the NAMESPACE source text `"\\."` (the
+ * R string value `\.`) into the regex `\.`. Callers that read a pattern out
+ * of NAMESPACE text must unescape before compiling.
+ */
+
+const POSIX_CLASSES: Readonly<Record<string, string>> = {
+  alpha: 'A-Za-z',
+  alnum: 'A-Za-z0-9',
+  digit: '0-9',
+  upper: 'A-Z',
+  lower: 'a-z',
+  punct: '!-\\/:-@\\[-`{-~',
+  space: ' \\t\\n\\r\\f\\v',
+  blank: ' \\t',
+  cntrl: '\\x00-\\x1f\\x7f',
+  print: '\\x20-\\x7e',
+  graph: '\\x21-\\x7e',
+  xdigit: '0-9A-Fa-f',
+};
+
+/**
+ * Translate one bracket expression starting at `src[start] === '['`.
+ * Returns the JS equivalent and the index just past its closing `]`, or null
+ * when the expression is unterminated or names an unknown class.
+ */
+function translateBracket(src: string, start: number): { text: string; end: number } | null {
+  let i = start + 1;
+  let out = '[';
+  if (src[i] === '^') {
+    out += '^';
+    i++;
+  }
+  // A `]` in first position is a literal member, not the terminator.
+  if (src[i] === ']') {
+    out += '\\]';
+    i++;
+  }
+  while (i < src.length) {
+    const ch = src[i];
+    if (ch === ']') return { text: out + ']', end: i + 1 };
+    if (ch === '[' && src[i + 1] === ':') {
+      const close = src.indexOf(':]', i + 2);
+      if (close === -1) return null;
+      const expansion = POSIX_CLASSES[src.slice(i + 2, close)];
+      if (expansion === undefined) return null;
+      out += expansion;
+      i = close + 2;
+    } else if (ch === '\\' && i + 1 < src.length) {
+      out += ch + src[i + 1];
+      i += 2;
+    } else if (ch === '[' || ch === '^') {
+      out += '\\' + ch;
+      i++;
+    } else {
+      out += ch;
+      i++;
+    }
+  }
+  return null;
+}
+
+function translatePosixClasses(src: string): string | null {
+  let out = '';
+  let i = 0;
+  while (i < src.length) {
+    const ch = src[i];
+    if (ch === '\\' && i + 1 < src.length) {
+      out += ch + src[i + 1];
+      i += 2;
+    } else if (ch === '[') {
+      const bracket = translateBracket(src, i);
+      if (bracket === null) return null;
+      out += bracket.text;
+      i = bracket.end;
+    } else {
+      out += ch;
+      i++;
+    }
+  }
+  return out;
+}
+
+/** A compiled `exportPattern()`; `test` answers whether the pattern matches anywhere in `name`. */
+export interface RExportMatcher {
+  /** The pattern text that was compiled (after POSIX-class translation). */
+  readonly source: string;
+  test(name: string): boolean;
+  /**
+   * True once the matcher stopped answering because it spent its work budget (its own, or
+   * the one shared by a package-config load); names it had not yet decided were then
+   * treated as not matching. Absent on matchers that
+   * cannot run out (a plain `RegExp`).
+   */
+  readonly exhausted?: boolean;
+}
+
+/** The outcome of {@link compileRExportPatternDetailed}: a matcher, or why there is none. */
+export type RExportPatternResult =
+  | { readonly matcher: RExportMatcher }
+  | { readonly matcher: null; readonly reason: string };
+
+/**
+ * Compile an `exportPattern()` argument, saying why when it cannot be compiled safely.
+ * Matchers compiled with the same `shared` budget stop together once it is spent (see
+ * `linear-regex.ts`); a package-config load passes one so that the number of patterns a
+ * repository carries cannot multiply the per-matcher cost.
+ */
+export function compileRExportPatternDetailed(
+  source: string,
+  shared?: SharedWorkBudget,
+): RExportPatternResult {
+  try {
+    let translated = source;
+    if (source.includes('[:')) {
+      const posix = translatePosixClasses(source);
+      if (posix === null) {
+        return {
+          matcher: null,
+          reason: 'unterminated bracket expression or unknown POSIX class',
+        };
+      }
+      translated = posix;
+    }
+    const result = compileLinearRegexDetailed(translated, shared);
+    return 'reason' in result
+      ? { matcher: null, reason: result.reason }
+      : { matcher: result.regex };
+  } catch {
+    return { matcher: null, reason: 'pattern could not be compiled' };
+  }
+}
+
+/** Compile an `exportPattern()` argument; null when it cannot be compiled safely. */
+export function compileRExportPattern(
+  source: string,
+  shared?: SharedWorkBudget,
+): RExportMatcher | null {
+  return compileRExportPatternDetailed(source, shared).matcher;
+}
+
+const SIMPLE_R_ESCAPES: Readonly<Record<string, string>> = {
+  n: '\n',
+  t: '\t',
+  r: '\r',
+  a: '\x07',
+  b: '\b',
+  f: '\f',
+  v: '\v',
+  '\\': '\\',
+  '"': '"',
+  "'": "'",
+  '`': '`',
+  ' ': ' ',
+};
+
+/**
+ * Turn the body of an R string literal (the text between the quotes) into the
+ * string value R would hold: `\\` -> `\`, `\"` -> `"`, `\n` -> newline, and
+ * likewise `\t \r \a \b \f \v \' \``, backslash-space, `\xHH`,
+ * `\uXXXX` / `\u{X..}` and `\UXXXXXXXX` / `\U{X..}` (code points). R
+ * rejects any other backslash sequence; this leniently keeps it verbatim, so a
+ * mistaken `"\."` still reaches the regex compiler as `\.`. Never throws.
+ */
+export function unescapeRString(body: string): string {
+  if (!body.includes('\\')) return body;
+  let out = '';
+  for (let i = 0; i < body.length; i++) {
+    const ch = body[i];
+    if (ch !== '\\' || i + 1 >= body.length) {
+      out += ch;
+      continue;
+    }
+    const next = body[i + 1];
+    const simple = SIMPLE_R_ESCAPES[next];
+    if (simple !== undefined) {
+      out += simple;
+      i++;
+      continue;
+    }
+    const hex = readHexEscape(body, i + 1);
+    if (hex !== null) {
+      out += hex.text;
+      i = hex.end - 1;
+      continue;
+    }
+    out += ch; // Unknown escape: keep the backslash; the next char is emitted normally.
+  }
+  return out;
+}
+
+/** `x`/`u`/`U` escape whose introducer is at `body[at]`; null when malformed. */
+function readHexEscape(body: string, at: number): { text: string; end: number } | null {
+  const kind = body[at];
+  const maxDigits = kind === 'x' ? 2 : kind === 'u' ? 4 : kind === 'U' ? 8 : 0;
+  if (maxDigits === 0) return null;
+  let i = at + 1;
+  const braced = kind !== 'x' && body[i] === '{';
+  if (braced) i++;
+  const start = i;
+  while (i < body.length && i - start < maxDigits && /[0-9A-Fa-f]/.test(body[i])) i++;
+  if (i === start) return null;
+  if (braced) {
+    if (body[i] !== '}') return null;
+  }
+  const code = parseInt(body.slice(start, i), 16);
+  if (code > 0x10ffff) return null;
+  return { text: String.fromCodePoint(code), end: braced ? i + 1 : i };
+}
diff --git a/gitnexus/src/core/ingestion/languages/r/interpret.ts b/gitnexus/src/core/ingestion/languages/r/interpret.ts
new file mode 100644
index 000000000..7632a08aa
--- /dev/null
+++ b/gitnexus/src/core/ingestion/languages/r/interpret.ts
@@ -0,0 +1,40 @@
+import type { CaptureMatch, ParsedImport, ParsedTypeBinding } from 'gitnexus-shared';
+
+/**
+ * `source()` is a side-effect import — it establishes a file dependency but
+ * binds no name (cross-file free calls into a `source()`d file resolve via
+ * `rScopeResolver.allowGlobalFreeCallFallback` instead).
+ *
+ * `library()`/`require()` are wildcard imports — every top-level name of the
+ * named local package becomes visible (`rProvider.expandsWildcardTo`).
+ *
+ * `resolveRImportTarget` (`import-resolvers/r.ts`) guards on
+ * `context.parsedImport.kind === 'wildcard'` specifically to refuse a
+ * `library()`/`require()` package name that isn't a known local package
+ * (rather than falling through to a cross-language suffix-match false
+ * positive) — the two kinds set here are what that guard keys on.
+ */
+export function interpretRImport(captures: CaptureMatch): ParsedImport | null {
+  const source = captures['@import.source']?.text;
+  if (source === undefined || source.length === 0) return null;
+
+  if (captures['@import.wildcard'] !== undefined) {
+    return { kind: 'wildcard', targetRaw: source };
+  }
+  return { kind: 'side-effect', targetRaw: source };
+}
+
+/**
+ * `x <- Type$new(...)` — R6's constructor spelling. `@type-binding.type` is
+ * the `$` receiver (the class name), captured only when the extract
+ * operator's rhs is literally `new` (see `query.ts`), so this always
+ * resolves via the shared `constructor-inferred` sub-kind — the same one
+ * Zig's `interpretZigTypeBinding` uses for `Counter.init()`.
+ */
+export function interpretRTypeBinding(captures: CaptureMatch): ParsedTypeBinding | null {
+  const name = captures['@type-binding.name']?.text;
+  const type = captures['@type-binding.type']?.text;
+  if (name === undefined || type === undefined) return null;
+
+  return { boundName: name, rawTypeName: type, source: 'constructor-inferred' };
+}
diff --git a/gitnexus/src/core/ingestion/languages/r/linear-regex.ts b/gitnexus/src/core/ingestion/languages/r/linear-regex.ts
new file mode 100644
index 000000000..2a068a87e
--- /dev/null
+++ b/gitnexus/src/core/ingestion/languages/r/linear-regex.ts
@@ -0,0 +1,1041 @@
+/**
+ * A linear-time matcher for the regular-expression subset that `exportPattern()`
+ * arguments use.
+ *
+ * `exportPattern()` text comes from the repository being analysed and is run against
+ * every node name. Compiling it to a JavaScript `RegExp` lets a pattern such as
+ * `^(a+)+$` take exponential time on a short name and hang the analyzer, whereas R
+ * evaluates the same text with TRE, which does not backtrack. {@link compileLinearRegex}
+ * parses the pattern (JavaScript syntax, non-Unicode mode, the dialect `RegExp`
+ * accepted before) into a Thompson NFA and simulates it with a set of active states.
+ * A match attempt costs O(name length x NFA size) whatever the pattern says, and the
+ * total work one matcher may do is capped (see the cost model below).
+ *
+ * Supported: literals, `.`, bracket expressions, `\d \D \w \W \s \S \b \B`, the
+ * single-character escapes, `^ $`, groups (capturing and `(?:)`), alternation and the
+ * quantifiers `* + ? {n} {n,} {n,m}` (lazy forms behave identically for a yes/no
+ * test). Not supported, and compiled to `null`: back-references and look-around (no
+ * linear-time algorithm), named groups, legacy octal escapes, patterns longer than
+ * {@link MAX_PATTERN_LENGTH} and patterns whose expansion exceeds {@link MAX_STATES}.
+ * A syntax error also yields `null`. Matching is over UTF-16 code units, as
+ * `RegExp` without the `u` flag does. {@link compileLinearRegexDetailed} reports why a
+ * pattern was refused.
+ *
+ * Cost model. Compiling is O(pattern length + states). Matching one name is
+ * O(name length x active states), and a state count alone does not make a pattern
+ * slow: `[[:alpha:]]{1,2000}` has 4,000 states but one of them is active at a time,
+ * and an alternation of literals keeps only the ones whose next character matches.
+ * What is slow is many active states on a long name, and a repository controls both.
+ * So the caps are sized for legitimate patterns and the hostile case is bounded
+ * separately, by {@link MAX_TOTAL_WORK}: each matcher counts every state it visits
+ * and, once the budget is spent, answers false for names it has not already decided
+ * and reports `exhausted`. A visit costs 10-20 ns, so the budget is 0.4-0.8 s per
+ * package however many names are tested: measured on the development machine, `a?`
+ * repeated 500 or 8,000 times then `c`, `[A-Za-z]{1,2000}c`, and a 120-way alternation
+ * of `a...ab` each exhaust it in ~0.4 s against 50,000 distinct 100-character names.
+ * Realistic patterns stay far below it: 500 alternated identifiers, anchored or not,
+ * cost about 20 visits per name, because alternatives that share a prefix share
+ * states. Verdicts are memoised per distinct name, so a repeated name costs one lookup.
+ *
+ * The per-matcher cap does not bound how many matchers there are, and a NAMESPACE can
+ * carry as many `exportPattern()` lines as it likes (200 hostile ones cost ~77 s). So
+ * matchers may also draw on a {@link SharedWorkBudget}, which the caller creates once
+ * for a whole package-config load and hands to every matcher it compiles, across all
+ * the packages it discovers; a matcher stops when its own cap or the shared budget is
+ * spent, whichever comes first. A count cap would not do: a per-package cap still
+ * allows many packages, and a per-run cap would penalise a monorepo whose packages
+ * each carry a few benign patterns, which use next to no work.
+ *
+ * Matching is not the only cost that grows with the number of patterns. Every compiled
+ * pattern keeps an NFA (about 100 bytes a state), and a NAMESPACE can carry hundreds of
+ * thousands of them, so the budget also holds an allowance of NFA states: a pattern that
+ * does not fit in what is left is refused (the build stops at the allowance, so its NFA is
+ * never allocated in full) and, once nothing is left, later patterns are refused without
+ * being parsed (the first pattern that does not fit ends the allowance; a pattern is at most
+ * {@link MAX_STATES} states, so that only happens after the allowance is nearly used up).
+ * Budgets nest: a package's budget is a {@link SharedWorkBudget.child} of the
+ * load's, so one package cannot take the whole load's allowance and leave every other
+ * package's patterns unable to run.
+ */
+
+/** Longest pattern accepted: room for an alternation of ~1,000 identifiers. */
+export const MAX_PATTERN_LENGTH = 16384;
+
+/**
+ * Most NFA states a pattern may expand to. Bounded repetition such as `a{1000}` is
+ * expanded copy by copy, so this caps memory and compile time; the matching cost is
+ * bounded by {@link MAX_TOTAL_WORK}. Room for ~1,000 alternated identifiers of 15
+ * characters, or `[[:alpha:]]{1,2000}`.
+ */
+export const MAX_STATES = 16384;
+
+/** Deepest group nesting accepted; bounds the parser's and the builder's recursion. */
+const MAX_NESTING = 2048;
+
+/**
+ * Most `build` calls for one pattern. States are capped separately, but a body that
+ * creates no states (`(){1000}`) can still be repeated exponentially when nested.
+ */
+const MAX_BUILD_STEPS = 4 * MAX_STATES;
+
+/**
+ * State visits one matcher may spend across all the names it is asked about (see the
+ * cost model above).
+ */
+export const MAX_TOTAL_WORK = 40_000_000;
+
+/**
+ * State visits all the matchers of one package-config load may spend together (the
+ * default limit of a {@link SharedWorkBudget}), in addition to the per-matcher
+ * {@link MAX_TOTAL_WORK}. At 9-10 ns a visit it is about one second: enough for two
+ * and a half pathological patterns to run to their own cap, after which the rest of
+ * the load's patterns stop and are reported, so a hostile NAMESPACE cannot cost more
+ * than that however many patterns it carries. Benign work is a tiny fraction of it: a
+ * 50-package monorepo with three realistic patterns per package and 2,500 functions
+ * spends about 15,000 visits, and one realistic pattern run against 50,000 names
+ * spends 0.2-7 million. Counted in visits, not wall-clock time, so the outcome is the
+ * same on every machine.
+ */
+export const MAX_SHARED_WORK = 100_000_000;
+
+/**
+ * NFA states all the patterns of one load may keep together. A state costs about 700
+ * bytes once compiled (parallel arrays plus a character set per character state;
+ * measured: 2,000,000 states held 1.4 GB), so this bounds what a NAMESPACE can make the
+ * analyzer hold at about 350 MB. A realistic pattern is tens to a few thousand states
+ * (an alternation of 500 identifiers is about 7,500; `[[:alpha:]]{1,2000}` is 4,000), so
+ * the 150 benign patterns of the 50-package monorepo above use under 5,000 states in
+ * total, 1 % of this, and the allowance holds some 65 such alternations.
+ */
+export const MAX_SHARED_STATES = 500_000;
+
+/**
+ * State visits one package may spend on matching, out of {@link MAX_SHARED_WORK} (30 %,
+ * about 0.3 s): one hostile package then cannot take the load's whole budget, so the
+ * packages after it keep their patterns. Three hostile packages spend the load's
+ * budget; the packages after those degrade, with a warning per pattern.
+ */
+export const MAX_PACKAGE_WORK = 30_000_000;
+
+/**
+ * NFA states one package may keep, out of {@link MAX_SHARED_STATES} (20 %, about 70 MB):
+ * six patterns at the {@link MAX_STATES} cap, or some 13 alternations of 500 identifiers,
+ * far beyond what a NAMESPACE writes by hand, while five such packages still cannot
+ * exceed the load's allowance on their own.
+ */
+export const MAX_PACKAGE_STATES = 100_000;
+
+/** Why a pattern was refused because the allowance of states was spent. */
+const STATE_ALLOWANCE_REASON =
+  'the NFA state allowance for this package or repository is spent (too many or too large patterns)';
+
+/**
+ * A work allowance shared by several matchers: state visits spent matching, and NFA
+ * states kept by compiled patterns. Create one per package-config load and give each
+ * package a {@link child}; every matcher compiled with a budget adds the state visits
+ * it spends to {@link spent} (and to every ancestor's), and all of them stop once any
+ * budget up the chain is spent. Counted in work units, never time.
+ */
+export class SharedWorkBudget {
+  /** State visits spent so far by every matcher drawing on this budget. */
+  spent = 0;
+  /** NFA states kept so far by every pattern compiled against this budget. */
+  states = 0;
+  /**
+   * Set by the caller that skipped matching because the budget was spent, so that the
+   * patterns it did not get to run can be reported.
+   */
+  cutShort = false;
+
+  constructor(
+    /** State visits the matchers may spend together. */
+    readonly limit: number = MAX_SHARED_WORK,
+    /** NFA states the compiled patterns may keep together. */
+    readonly stateLimit: number = MAX_SHARED_STATES,
+    private readonly parent?: SharedWorkBudget,
+  ) {}
+
+  /** A sub-budget for one package: it draws on this budget too, and cannot exceed it. */
+  child(
+    limit: number = MAX_PACKAGE_WORK,
+    stateLimit: number = MAX_PACKAGE_STATES,
+  ): SharedWorkBudget {
+    return new SharedWorkBudget(limit, stateLimit, this);
+  }
+
+  /** True once this budget or any ancestor is spent; a matcher then answers false for undecided names. */
+  get isSpent(): boolean {
+    return this.spent >= this.limit || this.parent?.isSpent === true;
+  }
+
+  /**
+   * NFA states that may still be kept, here and in every ancestor (never negative). Zero
+   * once a pattern was refused for not fitting (see {@link closeStates}).
+   */
+  get statesLeft(): number {
+    const own = this.statesClosed ? 0 : Math.max(0, this.stateLimit - this.states);
+    return this.parent === undefined ? own : Math.min(own, this.parent.statesLeft);
+  }
+
+  /**
+   * A pattern was refused because it did not fit in `room` states: close every budget up
+   * the chain whose own allowance is that tight, so later patterns are refused at once,
+   * without being parsed. Otherwise a small remainder that no pattern fits would make
+   * every one of hundreds of thousands of later patterns cost a parse and a partial build.
+   */
+  closeStates(room: number): void {
+    if (Math.max(0, this.stateLimit - this.states) <= room) this.statesClosed = true;
+    this.parent?.closeStates(room);
+  }
+
+  private statesClosed = false;
+
+  /** Add `visits` state visits to this budget and every ancestor. */
+  charge(visits: number): void {
+    this.spent += visits;
+    this.parent?.charge(visits);
+  }
+
+  /** Record `count` NFA states kept by a compiled pattern, here and in every ancestor. */
+  reserveStates(count: number): void {
+    this.states += count;
+    this.parent?.reserveStates(count);
+  }
+}
+
+/** Most distinct names whose verdict a matcher remembers. */
+const MAX_MEMO_ENTRIES = 100_000;
+
+/** Thrown internally for unsupported or invalid input; never escapes this module. */
+class Reject extends Error {}
+
+const reject = (why: string): never => {
+  throw new Reject(why);
+};
+
+type Range = readonly [number, number];
+
+interface CharSet {
+  readonly ranges: readonly Range[];
+  readonly negated: boolean;
+}
+
+type Node =
+  | { readonly kind: 'empty' }
+  | { readonly kind: 'set'; readonly set: CharSet }
+  | { readonly kind: 'assert'; readonly which: 'bol' | 'eol' | 'wordb' | 'nwordb' }
+  | { readonly kind: 'seq'; readonly items: readonly Node[] }
+  | { readonly kind: 'alt'; readonly items: readonly Node[] }
+  | { readonly kind: 'repeat'; readonly min: number; readonly max: number; readonly node: Node };
+
+/**
+ * The code units of `node` when it matches exactly one fixed string (a literal, or a
+ * sequence of literals), else null.
+ */
+function literalWord(node: Node): number[] | null {
+  switch (node.kind) {
+    case 'empty':
+      return [];
+    case 'set': {
+      const { ranges, negated } = node.set;
+      return !negated && ranges.length === 1 && ranges[0][0] === ranges[0][1]
+        ? [ranges[0][0]]
+        : null;
+    }
+    case 'seq': {
+      const word: number[] = [];
+      for (const item of node.items) {
+        const part = literalWord(item);
+        if (part === null) return null;
+        for (const code of part) word.push(code);
+      }
+      return word;
+    }
+    default:
+      return null;
+  }
+}
+
+/** The strings of an alternation whose every alternative is a fixed string, else null. */
+function literalWords(items: readonly Node[]): number[][] | null {
+  const words: number[][] = [];
+  for (const item of items) {
+    const word = literalWord(item);
+    if (word === null) return null;
+    words.push(word);
+  }
+  return words;
+}
+
+const MAX_CODE_UNIT = 0xffff;
+
+const DIGIT: readonly Range[] = [[0x30, 0x39]];
+const WORD: readonly Range[] = [
+  [0x30, 0x39],
+  [0x41, 0x5a],
+  [0x5f, 0x5f],
+  [0x61, 0x7a],
+];
+const SPACE: readonly Range[] = [
+  [0x09, 0x0d],
+  [0x20, 0x20],
+  [0xa0, 0xa0],
+  [0x1680, 0x1680],
+  [0x2000, 0x200a],
+  [0x2028, 0x2029],
+  [0x202f, 0x202f],
+  [0x205f, 0x205f],
+  [0x3000, 0x3000],
+  [0xfeff, 0xfeff],
+];
+const LINE_TERMINATORS: readonly Range[] = [
+  [0x0a, 0x0a],
+  [0x0d, 0x0d],
+  [0x2028, 0x2029],
+];
+
+/** Complement of a sorted, non-overlapping range list over the UTF-16 code units. */
+function complement(ranges: readonly Range[]): Range[] {
+  const out: Range[] = [];
+  let next = 0;
+  for (const [lo, hi] of ranges) {
+    if (lo > next) out.push([next, lo - 1]);
+    next = hi + 1;
+  }
+  if (next <= MAX_CODE_UNIT) out.push([next, MAX_CODE_UNIT]);
+  return out;
+}
+
+const isWordUnit = (c: number): boolean =>
+  (c >= 0x30 && c <= 0x39) || (c >= 0x41 && c <= 0x5a) || c === 0x5f || (c >= 0x61 && c <= 0x7a);
+
+const isDecimal = (c: string | undefined): boolean => c !== undefined && c >= '0' && c <= '9';
+const isHexDigit = (c: string | undefined): boolean => c !== undefined && /^[0-9A-Fa-f]$/.test(c);
+const isAsciiLetter = (c: string | undefined): boolean => c !== undefined && /^[A-Za-z]$/.test(c);
+
+/** What `\x`, `\u` and friends resolve to: a single code unit, or a class. */
+type EscapeResult =
+  | { readonly code: number }
+  | { readonly ranges: readonly Range[]; readonly classEscape: true }
+  | { readonly assertion: 'wordb' | 'nwordb' };
+
+/** `{n}`, `{n,}`, `{n,m}` at the sticky cursor. */
+const BRACES = /\{(\d+)(?:(,)(\d*))?\}/y;
+
+class Parser {
+  private pos = 0;
+  private depth = 0;
+
+  constructor(private readonly src: string) {}
+
+  parse(): Node {
+    const node = this.parseDisjunction();
+    if (this.pos < this.src.length) reject('unmatched )');
+    return node;
+  }
+
+  private peek(offset = 0): string | undefined {
+    return this.src[this.pos + offset];
+  }
+
+  private parseDisjunction(): Node {
+    const alternatives: Node[] = [this.parseAlternative()];
+    while (this.peek() === '|') {
+      this.pos++;
+      alternatives.push(this.parseAlternative());
+    }
+    return alternatives.length === 1 ? alternatives[0] : { kind: 'alt', items: alternatives };
+  }
+
+  private parseAlternative(): Node {
+    const items: Node[] = [];
+    while (this.pos < this.src.length) {
+      const ch = this.peek();
+      if (ch === '|' || ch === ')') break;
+      items.push(this.parseTerm());
+    }
+    if (items.length === 0) return { kind: 'empty' };
+    return items.length === 1 ? items[0] : { kind: 'seq', items };
+  }
+
+  private parseTerm(): Node {
+    const ch = this.peek() as string;
+    if (ch === '^' || ch === '$') {
+      this.pos++;
+      this.rejectQuantifierAfterAssertion();
+      return { kind: 'assert', which: ch === '^' ? 'bol' : 'eol' };
+    }
+    const atom = this.parseAtom();
+    if (atom.kind === 'assert') {
+      this.rejectQuantifierAfterAssertion();
+      return atom;
+    }
+    return this.parseQuantifier(atom);
+  }
+
+  private rejectQuantifierAfterAssertion(): void {
+    const ch = this.peek();
+    if (ch === '*' || ch === '+' || ch === '?') reject('nothing to repeat');
+    if (ch === '{' && this.tryReadBraces() !== null) reject('nothing to repeat');
+  }
+
+  private parseAtom(): Node {
+    const ch = this.peek() as string;
+    switch (ch) {
+      case '.':
+        this.pos++;
+        return { kind: 'set', set: { ranges: LINE_TERMINATORS, negated: true } };
+      case '(':
+        return this.parseGroup();
+      case '[':
+        return this.parseClass();
+      case '\\':
+        return this.parseAtomEscape();
+      case '*':
+      case '+':
+      case '?':
+        return reject('nothing to repeat');
+      case '{':
+        if (this.tryReadBraces() !== null) reject('nothing to repeat');
+        this.pos++;
+        return literal(ch.charCodeAt(0));
+      default:
+        this.pos++;
+        return literal(ch.charCodeAt(0));
+    }
+  }
+
+  private parseGroup(): Node {
+    this.pos++; // (
+    if (this.peek() === '?') {
+      // `(?:` is a plain group; `(?=`, `(?!`, `(?<` and everything else is unsupported or invalid.
+      // Only a `(` the parser reaches here opens a group: one inside a character class
+      // (`[(?<]`) or after a backslash (`\(?<`) is a literal and never gets this far.
+      if (this.peek(1) === '<') reject('named groups and look-behind are unsupported');
+      if (this.peek(1) !== ':') reject('look-around and group modifiers are unsupported');
+      this.pos += 2;
+    }
+    if (++this.depth > MAX_NESTING) reject('groups are nested too deeply');
+    const inner = this.parseDisjunction();
+    this.depth--;
+    if (this.peek() !== ')') reject('unterminated group');
+    this.pos++;
+    // Wrapped so that `(?:$)*` and `(\b)+` stay quantifiable, unlike a bare assertion.
+    return { kind: 'seq', items: [inner] };
+  }
+
+  /** Read `{n}`, `{n,}` or `{n,m}` at the cursor without consuming; null when not a quantifier. */
+  private tryReadBraces(): { min: number; max: number; length: number } | null {
+    BRACES.lastIndex = this.pos;
+    const m = BRACES.exec(this.src);
+    if (m === null) return null;
+    const min = Number(m[1]);
+    const max = m[2] === undefined ? min : m[3] === '' ? Infinity : Number(m[3]);
+    return { min, max, length: m[0].length };
+  }
+
+  private parseQuantifier(atom: Node): Node {
+    const ch = this.peek();
+    let min: number;
+    let max: number;
+    if (ch === '*') {
+      min = 0;
+      max = Infinity;
+      this.pos++;
+    } else if (ch === '+') {
+      min = 1;
+      max = Infinity;
+      this.pos++;
+    } else if (ch === '?') {
+      min = 0;
+      max = 1;
+      this.pos++;
+    } else if (ch === '{') {
+      const braces = this.tryReadBraces();
+      if (braces === null) return atom; // a literal `{`, parsed as the next atom
+      if (braces.max < braces.min) reject('numbers out of order in quantifier');
+      min = braces.min;
+      max = braces.max;
+      this.pos += braces.length;
+    } else {
+      return atom;
+    }
+    if (this.peek() === '?') this.pos++; // lazy: irrelevant for a yes/no match
+    return { kind: 'repeat', min, max, node: atom };
+  }
+
+  /** `\` outside a bracket expression. */
+  private parseAtomEscape(): Node {
+    const result = this.readEscape(false);
+    if ('assertion' in result) return { kind: 'assert', which: result.assertion };
+    if ('classEscape' in result) {
+      return { kind: 'set', set: { ranges: result.ranges, negated: false } };
+    }
+    return literal(result.code);
+  }
+
+  /**
+   * Decode the escape at the cursor (`src[pos] === '\\'`) and advance past it.
+   * `inClass` selects the bracket-expression meanings (`\b` is backspace there).
+   */
+  private readEscape(inClass: boolean): EscapeResult {
+    this.pos++; // backslash
+    const c = this.peek();
+    if (c === undefined) return reject('\\ at end of pattern');
+    this.pos++;
+    switch (c) {
+      case 'd':
+        return { ranges: DIGIT, classEscape: true };
+      case 'D':
+        return { ranges: complement(DIGIT), classEscape: true };
+      case 'w':
+        return { ranges: WORD, classEscape: true };
+      case 'W':
+        return { ranges: complement(WORD), classEscape: true };
+      case 's':
+        return { ranges: SPACE, classEscape: true };
+      case 'S':
+        return { ranges: complement(SPACE), classEscape: true };
+      case 'b':
+        return inClass ? { code: 0x08 } : { assertion: 'wordb' };
+      case 'B':
+        return inClass ? { code: 0x42 } : { assertion: 'nwordb' };
+      case 't':
+        return { code: 0x09 };
+      case 'n':
+        return { code: 0x0a };
+      case 'v':
+        return { code: 0x0b };
+      case 'f':
+        return { code: 0x0c };
+      case 'r':
+        return { code: 0x0d };
+      case '0':
+        if (isDecimal(this.peek())) reject('legacy octal escape');
+        return { code: 0 };
+      case 'c': {
+        const letter = this.peek();
+        // Inside a bracket expression Annex B also accepts a digit or `_` after `\c`.
+        if (isAsciiLetter(letter) || (inClass && (isDecimal(letter) || letter === '_'))) {
+          this.pos++;
+          return { code: (letter as string).charCodeAt(0) % 32 };
+        }
+        // `\c` without a letter is a literal backslash; the `c` is read next.
+        this.pos--;
+        return { code: 0x5c };
+      }
+      case 'x': {
+        if (isHexDigit(this.peek()) && isHexDigit(this.peek(1))) {
+          const code = parseInt(this.src.slice(this.pos, this.pos + 2), 16);
+          this.pos += 2;
+          return { code };
+        }
+        return { code: 0x78 };
+      }
+      case 'u': {
+        const digits = this.src.slice(this.pos, this.pos + 4);
+        if (/^[0-9A-Fa-f]{4}$/.test(digits)) {
+          this.pos += 4;
+          return { code: parseInt(digits, 16) };
+        }
+        return { code: 0x75 };
+      }
+      case 'k':
+        // Identity escape (no named groups exist; `parseGroup` rejects those).
+        return { code: 0x6b };
+      default:
+        if (c >= '1' && c <= '9') reject('back-reference or legacy octal escape');
+        return { code: c.charCodeAt(0) };
+    }
+  }
+
+  private parseClass(): Node {
+    this.pos++; // [
+    let negated = false;
+    if (this.peek() === '^') {
+      negated = true;
+      this.pos++;
+    }
+    const ranges: Range[] = [];
+    for (;;) {
+      const ch = this.peek();
+      if (ch === undefined) reject('unterminated character class');
+      if (ch === ']') {
+        this.pos++;
+        break;
+      }
+      const lo = this.readClassAtom();
+      if (this.peek() === '-' && this.peek(1) !== ']' && this.peek(1) !== undefined) {
+        // Possible range: a class escape on either side makes the `-` a literal (Annex B).
+        this.pos++; // -
+        const hi = this.readClassAtom();
+        if ('code' in lo && 'code' in hi) {
+          if (lo.code > hi.code) reject('range out of order in character class');
+          ranges.push([lo.code, hi.code]);
+        } else {
+          this.addClassAtom(ranges, lo);
+          ranges.push([0x2d, 0x2d]);
+          this.addClassAtom(ranges, hi);
+        }
+      } else {
+        this.addClassAtom(ranges, lo);
+      }
+    }
+    return { kind: 'set', set: { ranges: normalise(ranges), negated } };
+  }
+
+  private addClassAtom(
+    ranges: Range[],
+    atom: { readonly code: number } | { readonly ranges: readonly Range[] },
+  ): void {
+    if ('code' in atom) ranges.push([atom.code, atom.code]);
+    else ranges.push(...atom.ranges);
+  }
+
+  private readClassAtom(): { readonly code: number } | { readonly ranges: readonly Range[] } {
+    const ch = this.peek() as string;
+    if (ch !== '\\') {
+      this.pos++;
+      return { code: ch.charCodeAt(0) };
+    }
+    const result = this.readEscape(true);
+    if ('assertion' in result) return reject('unreachable: no assertions inside a class');
+    if ('classEscape' in result) return { ranges: result.ranges };
+    return { code: result.code };
+  }
+}
+
+const literal = (code: number): Node => ({
+  kind: 'set',
+  set: { ranges: [[code, code]], negated: false },
+});
+
+/** Sort and merge overlapping or adjacent ranges. */
+function normalise(ranges: readonly Range[]): Range[] {
+  const sorted = [...ranges].sort((a, b) => a[0] - b[0]);
+  const out: Array<[number, number]> = [];
+  for (const [lo, hi] of sorted) {
+    const last = out[out.length - 1];
+    if (last !== undefined && lo <= last[1] + 1) last[1] = Math.max(last[1], hi);
+    else out.push([lo, hi]);
+  }
+  return out;
+}
+
+// --- NFA ---------------------------------------------------------------------------
+
+const K_CHAR = 0;
+const K_SPLIT = 1;
+const K_ASSERT = 2;
+const K_MATCH = 3;
+
+const A_BOL = 0;
+const A_EOL = 1;
+const A_WORDB = 2;
+const A_NWORDB = 3;
+
+const ASSERT_CODES = { bol: A_BOL, eol: A_EOL, wordb: A_WORDB, nwordb: A_NWORDB } as const;
+
+/** Thompson NFA over parallel arrays; state `i` is described by index `i` of each. */
+class Nfa {
+  constructor(
+    /** Most states this NFA may have: {@link MAX_STATES}, or less when an allowance is low. */
+    private readonly limit: number = MAX_STATES,
+    private readonly limitReason: string = 'pattern expands beyond the state cap',
+  ) {}
+
+  readonly kind: number[] = [];
+  readonly out: number[] = [];
+  /** Second branch of a split; unused otherwise. */
+  readonly out1: number[] = [];
+  /** Character set (K_CHAR) or assertion code (K_ASSERT). */
+  readonly arg: Array<CharSet | number | null> = [];
+  private steps = 0;
+
+  add(kind: number, out: number, out1: number, arg: CharSet | number | null): number {
+    if (this.kind.length >= this.limit) reject(this.limitReason);
+    this.kind.push(kind);
+    this.out.push(out);
+    this.out1.push(out1);
+    this.arg.push(arg);
+    return this.kind.length - 1;
+  }
+
+  /** Build `node` so that it continues into `next`; returns its entry state. */
+  build(node: Node, next: number): number {
+    if (++this.steps > MAX_BUILD_STEPS) reject('pattern expands beyond the work cap');
+    switch (node.kind) {
+      case 'empty':
+        return next;
+      case 'set':
+        return this.add(K_CHAR, next, -1, node.set);
+      case 'assert':
+        return this.add(K_ASSERT, next, -1, ASSERT_CODES[node.which]);
+      case 'seq': {
+        let cont = next;
+        for (let i = node.items.length - 1; i >= 0; i--) cont = this.build(node.items[i], cont);
+        return cont;
+      }
+      case 'alt': {
+        const words = literalWords(node.items);
+        if (words !== null) return this.buildWords(words, next);
+        let entry = this.build(node.items[node.items.length - 1], next);
+        for (let i = node.items.length - 2; i >= 0; i--) {
+          entry = this.add(K_SPLIT, this.build(node.items[i], next), entry, null);
+        }
+        return entry;
+      }
+      case 'repeat':
+        return this.buildRepeat(node, next);
+    }
+  }
+
+  /**
+   * Build an alternation of literal strings as a trie, so that alternatives sharing a
+   * prefix share states (`my_function_0|my_function_1|...` keeps one state active on
+   * the common prefix instead of one per alternative). Matches the same strings as the
+   * plain alternation. Iterative: a literal may be thousands of characters long.
+   */
+  private buildWords(words: readonly (readonly number[])[], next: number): number {
+    interface TrieNode {
+      readonly children: Map<number, TrieNode>;
+      terminal: boolean;
+    }
+    const root: TrieNode = { children: new Map(), terminal: false };
+    for (const word of words) {
+      let at = root;
+      for (const code of word) {
+        let child = at.children.get(code);
+        if (child === undefined) {
+          child = { children: new Map(), terminal: false };
+          at.children.set(code, child);
+        }
+        at = child;
+      }
+      at.terminal = true;
+    }
+    // Each entry: a trie node, and the character state whose `out` is that node's entry
+    // (-1 for the root, whose entry is the result).
+    let rootEntry = next;
+    const pending: Array<{ node: TrieNode; via: number }> = [{ node: root, via: -1 }];
+    for (let task = pending.pop(); task !== undefined; task = pending.pop()) {
+      if (++this.steps > MAX_BUILD_STEPS) reject('pattern expands beyond the work cap');
+      const branches: number[] = [];
+      if (task.node.terminal) branches.push(next);
+      for (const [code, child] of task.node.children) {
+        const state = this.add(K_CHAR, -1, -1, {
+          ranges: [[code, code]],
+          negated: false,
+        });
+        branches.push(state);
+        pending.push({ node: child, via: state });
+      }
+      let entry = branches[branches.length - 1];
+      for (let i = branches.length - 2; i >= 0; i--) {
+        entry = this.add(K_SPLIT, branches[i], entry, null);
+      }
+      if (branches.length === 0) entry = next;
+      if (task.via === -1) rootEntry = entry;
+      else this.out[task.via] = entry;
+    }
+    return rootEntry;
+  }
+
+  private buildRepeat(node: Extract<Node, { kind: 'repeat' }>, next: number): number {
+    // Reject before expanding: a count beyond the cap cannot fit whatever the body is.
+    if (node.min > MAX_STATES) reject('repetition count beyond the state cap');
+    let cont: number;
+    if (node.max === Infinity) {
+      const loop = this.add(K_SPLIT, -1, next, null);
+      this.out[loop] = this.build(node.node, loop);
+      cont = loop;
+    } else {
+      if (node.max - node.min > MAX_STATES) reject('repetition count beyond the state cap');
+      cont = next;
+      for (let i = node.min; i < node.max; i++) {
+        cont = this.add(K_SPLIT, this.build(node.node, cont), next, null);
+      }
+    }
+    for (let i = 0; i < node.min; i++) cont = this.build(node.node, cont);
+    return cont;
+  }
+}
+
+/** Shared by {@link LinearRegex.startStates} entries that reach the match state. */
+const NO_STATES: readonly number[] = [];
+
+/** Empty-transition closure of the start state under one assertion context. */
+interface StartClosure {
+  /** True when the match state is reachable without consuming a character. */
+  readonly matches: boolean;
+  /** Character states reachable without consuming a character. */
+  readonly chars: readonly number[];
+}
+
+/** A compiled pattern. `test` has the same yes/no contract as `RegExp.prototype.test`. */
+export class LinearRegex {
+  /** Number of NFA states, exposed so tests can assert the structural bound. */
+  readonly stateCount: number;
+  /**
+   * True once the work budget (this matcher's own, or the shared one) ran out; later
+   * unseen names are answered false.
+   */
+  exhausted = false;
+  /** State visits spent so far, against {@link MAX_TOTAL_WORK}. */
+  work = 0;
+  private readonly kind: readonly number[];
+  private readonly out: readonly number[];
+  private readonly out1: readonly number[];
+  private readonly arg: ReadonlyArray<CharSet | number | null>;
+  private readonly start: number;
+  private readonly mark: Int32Array;
+  private readonly stack: number[] = [];
+  private stamp = 0;
+  /** Start closures by assertion context (see {@link contextAt}). */
+  private readonly startClosures: Array<StartClosure | undefined> = new Array(16);
+  /** Character states of a start closure that accept one code unit, by context and unit. */
+  private readonly startStates = new Map<number, readonly number[]>();
+  private readonly verdicts = new Map<string, boolean>();
+
+  constructor(
+    /** The pattern text this matcher was compiled from (after any POSIX-class translation). */
+    readonly source: string,
+    nfa: Nfa,
+    start: number,
+    /** Allowance shared with other matchers; they all stop when it is spent. */
+    private readonly shared?: SharedWorkBudget,
+  ) {
+    this.kind = nfa.kind;
+    this.out = nfa.out;
+    this.out1 = nfa.out1;
+    this.arg = nfa.arg;
+    this.start = start;
+    this.stateCount = nfa.kind.length;
+    this.mark = new Int32Array(this.stateCount);
+  }
+
+  /** True when the pattern matches anywhere in `name` (an unanchored search). */
+  test(name: string): boolean {
+    const known = this.verdicts.get(name);
+    if (known !== undefined) return known;
+    if (this.work >= MAX_TOTAL_WORK || this.shared?.isSpent === true) {
+      this.exhausted = true;
+      return false;
+    }
+    const verdict = this.search(name);
+    // A search the budget cut short has no verdict; do not remember it.
+    if (!this.exhausted && this.verdicts.size < MAX_MEMO_ENTRIES) this.verdicts.set(name, verdict);
+    return verdict;
+  }
+
+  /** Count `visits` state visits against this matcher's cap and the shared budget. */
+  private charge(visits: number): void {
+    this.work += visits;
+    this.shared?.charge(visits);
+  }
+
+  private search(name: string): boolean {
+    const length = name.length;
+    let current: number[] = [];
+    let following: number[] = [];
+    this.stamp++;
+    if (this.seed(current, name, 0)) return true;
+    for (let p = 0; p < length; p++) {
+      if (this.work > MAX_TOTAL_WORK || this.shared?.isSpent === true) {
+        this.exhausted = true;
+        return false;
+      }
+      const c = name.charCodeAt(p);
+      this.stamp++;
+      following.length = 0;
+      this.charge(current.length);
+      for (let i = 0; i < current.length; i++) {
+        const s = current[i];
+        if (inSet(this.arg[s] as CharSet, c) && this.add(following, this.out[s], name, p + 1)) {
+          return true;
+        }
+      }
+      // Unanchored search: a match may also begin at the next position.
+      if (this.seed(following, name, p + 1)) return true;
+      const swap = current;
+      current = following;
+      following = swap;
+    }
+    return false;
+  }
+
+  /**
+   * Start a match attempt at position `p`: true when the pattern matches there without
+   * consuming anything, otherwise the states that can consume `name[p]` are added to
+   * `list`. Those are the only start states worth keeping (the rest die on the next
+   * step), and looking them up by code unit keeps a long alternation from costing
+   * one visit per alternative at every position.
+   */
+  private seed(list: number[], name: string, p: number): boolean {
+    const context = contextAt(name, p);
+    const closure = (this.startClosures[context] ??= this.closeStart(context));
+    if (closure.matches) return true;
+    if (p === name.length) return false;
+    const c = name.charCodeAt(p);
+    const key = context * 0x10000 + c;
+    let states = this.startStates.get(key);
+    if (states === undefined) {
+      states = closure.chars.filter((s) => inSet(this.arg[s] as CharSet, c));
+      if (this.startStates.size < 4096) this.startStates.set(key, states);
+    }
+    this.charge(1 + states.length);
+    for (let i = 0; i < states.length; i++) {
+      const s = states[i];
+      if (this.mark[s] !== this.stamp) {
+        this.mark[s] = this.stamp;
+        list.push(s);
+      }
+    }
+    return false;
+  }
+
+  /** Closure of the start state where the assertion outcomes are those of `context`. */
+  private closeStart(context: number): StartClosure {
+    const seen = new Uint8Array(this.stateCount);
+    const chars: number[] = [];
+    const stack = [this.start];
+    while (stack.length > 0) {
+      const s = stack.pop() as number;
+      if (seen[s] === 1) continue;
+      seen[s] = 1;
+      switch (this.kind[s]) {
+        case K_MATCH:
+          return { matches: true, chars: NO_STATES };
+        case K_CHAR:
+          chars.push(s);
+          break;
+        case K_SPLIT:
+          stack.push(this.out1[s], this.out[s]);
+          break;
+        default:
+          if (holdsIn(this.arg[s] as number, context)) stack.push(this.out[s]);
+      }
+    }
+    return { matches: false, chars };
+  }
+
+  /**
+   * Follow empty transitions from `state` at position `p`, pushing character states
+   * onto `list`. Returns true on reaching the match state. A state is entered at most
+   * once per list (the stamp), which also stops empty-loop cycles such as `(a*)*`.
+   * Iterative: a long alternation is a long chain of splits.
+   */
+  private add(list: number[], state: number, name: string, p: number): boolean {
+    const stack = this.stack;
+    stack.length = 0;
+    stack.push(state);
+    while (stack.length > 0) {
+      const s = stack.pop() as number;
+      if (this.mark[s] === this.stamp) continue;
+      this.mark[s] = this.stamp;
+      this.charge(1);
+      switch (this.kind[s]) {
+        case K_MATCH:
+          return true;
+        case K_CHAR:
+          list.push(s);
+          break;
+        case K_SPLIT:
+          stack.push(this.out1[s], this.out[s]);
+          break;
+        default:
+          if (holdsIn(this.arg[s] as number, contextAt(name, p))) stack.push(this.out[s]);
+      }
+    }
+    return false;
+  }
+}
+
+const CTX_BOL = 1;
+const CTX_EOL = 2;
+const CTX_WORD_BEFORE = 4;
+const CTX_WORD_AFTER = 8;
+
+/** What the assertions can observe at position `p`: the two ends and word-ness either side. */
+function contextAt(name: string, p: number): number {
+  let context = 0;
+  if (p === 0) context |= CTX_BOL;
+  else if (isWordUnit(name.charCodeAt(p - 1))) context |= CTX_WORD_BEFORE;
+  if (p === name.length) context |= CTX_EOL;
+  else if (isWordUnit(name.charCodeAt(p))) context |= CTX_WORD_AFTER;
+  return context;
+}
+
+function holdsIn(assertion: number, context: number): boolean {
+  switch (assertion) {
+    case A_BOL:
+      return (context & CTX_BOL) !== 0;
+    case A_EOL:
+      return (context & CTX_EOL) !== 0;
+    default: {
+      const before = (context & CTX_WORD_BEFORE) !== 0;
+      const after = (context & CTX_WORD_AFTER) !== 0;
+      return assertion === A_WORDB ? before !== after : before === after;
+    }
+  }
+}
+
+function inSet(set: CharSet, c: number): boolean {
+  let hit = false;
+  const ranges = set.ranges;
+  for (let i = 0; i < ranges.length; i++) {
+    const r = ranges[i];
+    if (c < r[0]) break; // ranges are sorted
+    if (c <= r[1]) {
+      hit = true;
+      break;
+    }
+  }
+  return hit !== set.negated;
+}
+
+/** The outcome of {@link compileLinearRegexDetailed}: a matcher, or why there is none. */
+export type LinearRegexResult =
+  | { readonly regex: LinearRegex }
+  | { readonly regex: null; readonly reason: string };
+
+/**
+ * Compile a JavaScript-syntax pattern to a linear-time matcher. When the pattern is
+ * invalid, unsupported or too large the result carries the reason instead. Never throws.
+ * A `shared` budget makes the matcher draw on it as well as on its own cap, and the
+ * pattern's NFA states count against the budget's allowance of states.
+ */
+export function compileLinearRegexDetailed(
+  source: string,
+  shared?: SharedWorkBudget,
+): LinearRegexResult {
+  // With nothing left of the state allowance, refuse without even parsing the pattern.
+  const room = shared?.statesLeft ?? MAX_STATES;
+  if (room <= 0) return { regex: null, reason: STATE_ALLOWANCE_REASON };
+  if (source.length > MAX_PATTERN_LENGTH) {
+    return { regex: null, reason: `pattern is longer than ${MAX_PATTERN_LENGTH} characters` };
+  }
+  try {
+    const ast = new Parser(source).parse();
+    // The build stops at the allowance, so a pattern that does not fit never has its NFA
+    // allocated in full.
+    const nfa = room < MAX_STATES ? new Nfa(room, STATE_ALLOWANCE_REASON) : new Nfa();
+    const match = nfa.add(K_MATCH, -1, -1, null);
+    const start = nfa.build(ast, match);
+    shared?.reserveStates(nfa.kind.length);
+    return { regex: new LinearRegex(source, nfa, start, shared) };
+  } catch (err) {
+    // `Reject` is the expected path; a stack overflow or any other failure also means
+    // "cannot match safely", which for an exportPattern is the same as never matching.
+    if (err instanceof Reject && err.message === STATE_ALLOWANCE_REASON) shared?.closeStates(room);
+    return {
+      regex: null,
+      reason: err instanceof Reject ? err.message : 'pattern could not be compiled',
+    };
+  }
+}
+
+/** {@link compileLinearRegexDetailed} without the reason: null when there is no matcher. */
+export function compileLinearRegex(source: string, shared?: SharedWorkBudget): LinearRegex | null {
+  return compileLinearRegexDetailed(source, shared).regex;
+}
diff --git a/gitnexus/src/core/ingestion/languages/r/namespace-imports.ts b/gitnexus/src/core/ingestion/languages/r/namespace-imports.ts
new file mode 100644
index 000000000..ac0d86841
--- /dev/null
+++ b/gitnexus/src/core/ingestion/languages/r/namespace-imports.ts
@@ -0,0 +1,798 @@
+/**
+ * NAMESPACE `importFrom()` parsing for R packages.
+ *
+ * `parseRNamespaceImportFrom` is a pure, package-blind tokenizer: it reads the
+ * text of one NAMESPACE file and returns every `importFrom(pkg, name, ...)`
+ * pair in file order. It deliberately returns *all* entries — including a
+ * package importing from itself and duplicate names from different packages —
+ * because those policy decisions (own-package drop, last-wins, external-package
+ * skip) belong to the consumer that knows the workspace, not to the parser.
+ *
+ * The tokenizer ({@link scanRNamespaceDirectives}) is generic (directive head +
+ * balanced argument list across newlines, honouring `"…"`, `'…'` and backtick
+ * quoting, `#` comments stripped outside quotes). Two consumers sit on it:
+ * {@link parseRNamespaceImportFrom} (`importFrom` only; `import`,
+ * `importClassesFrom` and `importMethodsFrom` are deferred) and
+ * {@link parseRNamespaceExports} (`export`, `exportClasses`, `exportMethods`,
+ * `S3method`, `exportPattern`). `useDynLib` and anything under an
+ * `if (…)` / `else` conditional are ignored. Unbalanced or garbled input never
+ * throws: a malformed directive is discarded and scanning RESYNCHRONISES at the
+ * next line that begins, at column 0, with `identifier(` (see
+ * {@link resyncAfterMalformed}); everything parsed before and after is kept.
+ * Quoted strings never span lines, and a column-0 `identifier(` line ends any
+ * argument list still open, so a broken directive cannot swallow those after it.
+ *
+ * Runtime import direction is `language-config.ts` → this file; any type from
+ * `language-config.ts` must be taken with `import type` only, so no runtime
+ * import cycle forms.
+ *
+ * The second half of the file binds those entries to workspace definitions:
+ * {@link populateRNamespaceImports} synthesises `named` imports for
+ * `importFrom()` names that a *local* package provides, and
+ * {@link resolveRImportTarget}'s `named` branch (`import-resolvers/r.ts`)
+ * resolves them using {@link rFileTopLevel} / {@link rPackageDirForFile}.
+ *
+ * The file also hosts the pieces of `pkg::name()` qualifier handling that the
+ * global-name-fallback veto ({@link isRGlobalNameFallbackPlausible}) shares
+ * with `qualified-call.ts`: {@link parseRQualifier} and the per-package
+ * definition-count registry. The qualified-call decisions themselves live in
+ * `qualified-call.ts`.
+ */
+
+import type { ParsedFile, ParsedImport } from 'gitnexus-shared';
+import type { RPackageConfig } from './package-config.js';
+import { unescapeRString } from './export-pattern.js';
+import { resolveRNamedImport } from '../../import-resolvers/r.js';
+
+/** One `importFrom(pkg, name)` pair, in NAMESPACE file order. */
+export interface RNamespaceImportFromEntry {
+  readonly pkg: string;
+  readonly name: string;
+}
+
+const IMPORT_FROM_DIRECTIVES: ReadonlySet<string> = new Set(['importFrom']);
+
+/** Directives whose arguments name exported symbols (`S3method` is handled separately). */
+const EXPORT_NAME_DIRECTIVES: ReadonlySet<string> = new Set([
+  'export',
+  'exportClasses',
+  'exportMethods',
+]);
+
+const EXPORT_DIRECTIVES: ReadonlySet<string> = new Set([
+  ...EXPORT_NAME_DIRECTIVES,
+  'S3method',
+  'exportPattern',
+]);
+
+/** Directives whose following statement is conditional and therefore ignored. */
+const CONDITIONAL_HEADS: ReadonlySet<string> = new Set(['if', 'else']);
+
+const isIdentStart = (ch: string): boolean => /[A-Za-z_.]/.test(ch);
+const isIdentPart = (ch: string): boolean => /[A-Za-z0-9_.]/.test(ch);
+const isQuote = (ch: string): boolean => ch === '"' || ch === "'" || ch === '`';
+
+/**
+ * Advance past a quoted region starting at `start` (which holds the opening
+ * quote). Returns the index just after the closing quote, or `-1` when the
+ * quote does not close on the same line. Backslash escapes the next character
+ * (R string rules; harmless inside backticks). Quotes never span lines: a
+ * NAMESPACE directive argument is a one-line token, and letting a stray quote
+ * run on would pair with a later one and swallow the directives between them.
+ */
+function skipQuoted(text: string, start: number): number {
+  const quote = text[start];
+  for (let i = start + 1; i < text.length; i++) {
+    const ch = text[i];
+    if (ch === '\n') return -1;
+    if (ch === '\\') {
+      i++;
+      if (text[i] === '\n') return -1;
+      continue;
+    }
+    if (ch === quote) return i + 1;
+  }
+  return -1;
+}
+
+function skipLineComment(text: string, start: number): number {
+  const nl = text.indexOf('\n', start);
+  return nl === -1 ? text.length : nl + 1;
+}
+
+/** A directive-looking line start: `identifier(` (no leading whitespace, no space before `(`). */
+const DIRECTIVE_LINE_START = /[A-Za-z_.][A-Za-z0-9_.]*\(/y;
+
+/** True when `i` is the start of a line (column 0) that begins with `identifier(`. */
+function isDirectiveLineStart(text: string, i: number): boolean {
+  if (i > 0 && text[i - 1] !== '\n') return false;
+  DIRECTIVE_LINE_START.lastIndex = i;
+  return DIRECTIVE_LINE_START.test(text);
+}
+
+/**
+ * Resynchronisation point after a malformed directive that began at `from`: the
+ * start of the first line AFTER the line containing `from` that begins, at
+ * column 0, with `identifier(`; `text.length` when there is none. The result
+ * is always greater than `from` (or the end of text), so callers make forward
+ * progress and each failure costs at most one pass over the text it skips.
+ */
+function resyncAfterMalformed(text: string, from: number): number {
+  let nl = text.indexOf('\n', from);
+  while (nl !== -1) {
+    const lineStart = nl + 1;
+    if (isDirectiveLineStart(text, lineStart)) return lineStart;
+    nl = text.indexOf('\n', lineStart);
+  }
+  return text.length;
+}
+
+/**
+ * Parse a balanced `( … )` group whose opening paren is at `openIdx`. Returns
+ * the comma-separated top-level arguments (raw, comment-stripped, unquoted only
+ * at the outer layer) and the index just after the closing paren, or `null`
+ * when the group is unbalanced, holds an unterminated quote, or is still open
+ * when a line starting `identifier(` at column 0 begins (which bounds the scan,
+ * so an unbalanced group cannot run to the end of the file).
+ */
+function parseArgs(text: string, openIdx: number): { args: string[]; end: number } | null {
+  const args: string[] = [];
+  let current = '';
+  let depth = 0;
+  for (let i = openIdx; i < text.length; ) {
+    if (i > openIdx && isDirectiveLineStart(text, i)) return null;
+    const ch = text[i];
+    if (ch === '#') {
+      i = skipLineComment(text, i);
+      continue;
+    }
+    if (isQuote(ch)) {
+      const end = skipQuoted(text, i);
+      if (end === -1) return null;
+      current += text.slice(i, end);
+      i = end;
+      continue;
+    }
+    if (ch === '(') {
+      depth++;
+      if (depth > 1) current += ch;
+      i++;
+      continue;
+    }
+    if (ch === ')') {
+      depth--;
+      if (depth === 0) {
+        args.push(current);
+        return { args, end: i + 1 };
+      }
+      current += ch;
+      i++;
+      continue;
+    }
+    if (ch === ',' && depth === 1) {
+      args.push(current);
+      current = '';
+      i++;
+      continue;
+    }
+    current += ch;
+    i++;
+  }
+  return null;
+}
+
+/**
+ * Strip whitespace and one layer of surrounding quotes/backticks from a raw
+ * argument. Returns `''` for empty or non-simple arguments (unterminated quote,
+ * or anything that is not a single bare/quoted token) so callers can skip them.
+ */
+function normaliseArg(raw: string): string {
+  const trimmed = raw.trim();
+  if (!trimmed) return '';
+  const first = trimmed[0];
+  if (isQuote(first)) {
+    if (trimmed.length < 2 || trimmed[trimmed.length - 1] !== first) return '';
+    const end = skipQuoted(trimmed, 0);
+    if (end !== trimmed.length) return '';
+    return trimmed.slice(1, -1).trim();
+  }
+  // Bare token: reject anything containing whitespace, quotes, or parens (e.g. `x = y`, nested calls).
+  if (/[\s"'`()=]/.test(trimmed)) return '';
+  return trimmed;
+}
+
+/**
+ * Skip one statement following an `if (…)` / `else`: either a `{ … }` block or a
+ * single directive call. Returns the index to resume scanning from.
+ */
+function skipConditionalBody(text: string, from: number): number {
+  let i = from;
+  while (i < text.length && /\s/.test(text[i])) i++;
+  if (i >= text.length) return i;
+  if (text[i] === '{') {
+    const blockStart = i;
+    let depth = 0;
+    for (; i < text.length; ) {
+      const ch = text[i];
+      if (ch === '#') {
+        i = skipLineComment(text, i);
+        continue;
+      }
+      if (isQuote(ch)) {
+        const end = skipQuoted(text, i);
+        if (end === -1) return resyncAfterMalformed(text, blockStart);
+        i = end;
+        continue;
+      }
+      if (ch === '{') depth++;
+      else if (ch === '}') {
+        depth--;
+        if (depth === 0) return i + 1;
+      }
+      i++;
+    }
+    return resyncAfterMalformed(text, blockStart); // unterminated `{ … }`
+  }
+  if (isIdentStart(text[i])) {
+    let j = i + 1;
+    while (j < text.length && isIdentPart(text[j])) j++;
+    const head = text.slice(i, j);
+    if (CONDITIONAL_HEADS.has(head)) return j; // `else if (…)` — let the main loop handle the chain.
+    while (j < text.length && /\s/.test(text[j])) j++;
+    if (text[j] === '(') {
+      const group = parseArgs(text, j);
+      return group ? group.end : resyncAfterMalformed(text, i);
+    }
+    return j;
+  }
+  return i;
+}
+
+/** One top-level NAMESPACE directive: its head and its raw (comment-stripped) arguments. */
+interface RawDirective {
+  readonly head: string;
+  readonly args: readonly string[];
+}
+
+/**
+ * Tokenise NAMESPACE text into the top-level directives whose head is in
+ * `heads`, in file order. Conditional (`if` / `else`) bodies are skipped, and
+ * directives nested inside another directive's arguments are never emitted.
+ * Never throws. A malformed directive (unbalanced group, unterminated quote,
+ * unterminated `{` block) is discarded and scanning resumes at the next line
+ * starting `identifier(` at column 0 ({@link resyncAfterMalformed}); everything
+ * before and after is kept. Directives indented after a malformed one are
+ * dropped with it.
+ */
+function scanRNamespaceDirectives(text: string, heads: ReadonlySet<string>): RawDirective[] {
+  const directives: RawDirective[] = [];
+  let i = 0;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === '#') {
+      i = skipLineComment(text, i);
+      continue;
+    }
+    if (isQuote(ch)) {
+      const end = skipQuoted(text, i);
+      if (end === -1) {
+        i = resyncAfterMalformed(text, i); // stray unterminated quote
+        continue;
+      }
+      i = end;
+      continue;
+    }
+    if (!isIdentStart(ch)) {
+      i++;
+      continue;
+    }
+
+    let j = i + 1;
+    while (j < text.length && isIdentPart(text[j])) j++;
+    const head = text.slice(i, j);
+    let k = j;
+    while (k < text.length && /\s/.test(text[k])) k++;
+
+    if (text[k] !== '(') {
+      // `else` may be followed directly by a directive with no parens of its own.
+      if (head === 'else') {
+        i = skipConditionalBody(text, k);
+        continue;
+      }
+      i = j;
+      continue;
+    }
+
+    const group = parseArgs(text, k);
+    if (!group) {
+      i = resyncAfterMalformed(text, i); // discard this directive, resume at the next one
+      continue;
+    }
+    i = group.end;
+
+    if (CONDITIONAL_HEADS.has(head)) {
+      i = skipConditionalBody(text, i);
+      continue;
+    }
+    if (heads.has(head)) directives.push({ head, args: group.args });
+  }
+  return directives;
+}
+
+/**
+ * Extract every `importFrom(pkg, name, ...)` pair from NAMESPACE text, in file
+ * order. Never throws; returns `[]` for empty, garbled or unbalanced input.
+ */
+export function parseRNamespaceImportFrom(text: string): RNamespaceImportFromEntry[] {
+  const entries: RNamespaceImportFromEntry[] = [];
+  for (const { args } of scanRNamespaceDirectives(text, IMPORT_FROM_DIRECTIVES)) {
+    const values = args.map(normaliseArg);
+    const pkg = values[0];
+    if (!pkg) continue;
+    for (let n = 1; n < values.length; n++) {
+      if (values[n]) entries.push({ pkg, name: values[n] });
+    }
+  }
+  return entries;
+}
+
+/** What a NAMESPACE file exports, as read by {@link parseRNamespaceExports}. */
+export interface RNamespaceExports {
+  /** Names from `export()`, `exportClasses()`, `exportMethods()` and `S3method()` (the third argument, else `generic.class`), in file order. */
+  readonly namedExports: readonly string[];
+  /** `exportPattern()` arguments, R-unescaped (an R string `"\\."` yields the regex source `\.`), in file order. */
+  readonly exportPatterns: readonly string[];
+}
+
+/**
+ * The single-token string argument of `exportPattern()`, R-unescaped, or `''`
+ * when the argument is empty, not a quoted string, or unterminated. Only `"`
+ * and `'` quote a string in R (a backticked name is a symbol, not a pattern).
+ */
+function exportPatternArg(raw: string): string {
+  const trimmed = raw.trim();
+  const quote = trimmed[0];
+  if (quote !== '"' && quote !== "'") return '';
+  if (skipQuoted(trimmed, 0) !== trimmed.length) return '';
+  return unescapeRString(trimmed.slice(1, -1));
+}
+
+/**
+ * Extract the export directives from NAMESPACE text: `export`, `exportClasses`
+ * and `exportMethods` names, `S3method(generic, class[, method])` as `method`
+ * (else `generic.class`), and `exportPattern("…")` sources. Multi-line, quoted,
+ * backticked, commented and CRLF input is handled like {@link
+ * parseRNamespaceImportFrom}. Non-simple arguments (named, nested calls) are
+ * skipped. Never throws; returns empty lists for empty or garbled input.
+ */
+export function parseRNamespaceExports(text: string): RNamespaceExports {
+  const namedExports: string[] = [];
+  const exportPatterns: string[] = [];
+  for (const { head, args } of scanRNamespaceDirectives(text, EXPORT_DIRECTIVES)) {
+    if (head === 'exportPattern') {
+      for (const raw of args) {
+        const pattern = exportPatternArg(raw);
+        if (pattern) exportPatterns.push(pattern);
+      }
+    } else if (head === 'S3method') {
+      const generic = normaliseArg(args[0] ?? '');
+      const cls = normaliseArg(args[1] ?? '');
+      if (generic && cls) {
+        // The optional third argument names the function registered as the method;
+        // without it the method is `generic.class`.
+        const method = normaliseArg(args[2] ?? '');
+        namedExports.push(method || `${generic}.${cls}`);
+      }
+    } else {
+      for (const raw of args) {
+        const name = normaliseArg(raw);
+        if (name) namedExports.push(name);
+      }
+    }
+  }
+  return { namedExports, exportPatterns };
+}
+
+// ─── Package lookup ─────────────────────────────────────────────────────────
+
+/** A local R package located by {@link rPackageDirForFile}. */
+export interface RPackageLocation {
+  /** `Package:` name from `DESCRIPTION`. */
+  readonly name: string;
+  /** Package directory relative to the repo root; `''` for a root-level package. */
+  readonly dir: string;
+}
+
+/** `R/` directory prefix of a package dir (`'R/'` for a root-level package). */
+export function rRDirPrefix(pkgDir: string): string {
+  return pkgDir === '' ? 'R/' : `${pkgDir}/R/`;
+}
+
+/**
+ * The local package whose `<pkgDir>/R/**` contains `filePath`, or `undefined`.
+ *
+ * NAMESPACE effects apply only to a package's `R/` sources (R loads nothing
+ * else into the namespace), so files under `tests/`, `scripts/`, `inst/`, a
+ * root-level `plumber.R`, … belong to no package here. When package dirs nest,
+ * the longest matching dir wins. A root-level package (`dir === ''`) is
+ * handled without ever building a `'' + '/'` prefix.
+ */
+export function rPackageDirForFile(
+  filePath: string,
+  cfg: RPackageConfig | null | undefined,
+): RPackageLocation | undefined {
+  if (cfg === null || cfg === undefined) return undefined;
+  const normalized = filePath.replace(/\\/g, '/');
+  let best: RPackageLocation | undefined;
+  for (const [name, dir] of cfg.packages) {
+    if (!normalized.startsWith(rRDirPrefix(dir))) continue;
+    if (best === undefined || dir.length > best.dir.length) best = { name, dir };
+  }
+  return best;
+}
+
+/**
+ * The directory of the package whose `R/` sources contain `filePath`, or `undefined`.
+ *
+ * Unlike {@link rPackageDirForFile} this considers every directory that has a NAMESPACE as
+ * well as every registered package, so the nearest enclosing package owns a file and a nested
+ * package without a NAMESPACE never inherits the enclosing package's. The longest matching
+ * directory wins; the root package (`''`) is matched without building a `'' + '/'` prefix.
+ */
+export function rOwningPackageDir(
+  filePath: string,
+  cfg: RPackageConfig | null | undefined,
+): string | undefined {
+  if (cfg === null || cfg === undefined) return undefined;
+  const normalized = filePath.replace(/\\/g, '/');
+  let best: string | undefined;
+  const consider = (dir: string): void => {
+    if (!normalized.startsWith(rRDirPrefix(dir))) return;
+    if (best === undefined || dir.length > best.length) best = dir;
+  };
+  for (const dir of cfg.packages.values()) consider(dir);
+  for (const dir of cfg.namespaceInfoByPackageDir.keys()) consider(dir);
+  return best;
+}
+
+/**
+ * True when `filePath` sits under the `R/` directory of any package discovery read a
+ * `DESCRIPTION` for: a registered package, a directory with a NAMESPACE, or a same-name copy
+ * recorded only in {@link RPackageConfig.packageDirs}. Such a file belongs to the package its
+ * `DESCRIPTION` names, whatever its directory is called.
+ */
+export function rFileBelongsToDiscoveredPackage(
+  filePath: string,
+  cfg: RPackageConfig | null | undefined,
+): boolean {
+  if (cfg === null || cfg === undefined) return false;
+  if (rOwningPackageDir(filePath, cfg) !== undefined) return true;
+  if (cfg.packageDirs === undefined) return false;
+  const normalized = filePath.replace(/\\/g, '/');
+  for (const dir of cfg.packageDirs) if (normalized.startsWith(rRDirPrefix(dir))) return true;
+  return false;
+}
+
+// ─── Top-level definitions of a parsed file ────────────────────────────────
+
+/** Def kinds an R `importFrom()` (or a `pkg::name()` call) can bind to (functions and R6/R5/S4 classes). */
+export const TOP_LEVEL_BINDABLE_TYPES: ReadonlySet<string> = new Set(['Function', 'Class']);
+
+/** What one R file defines at top level, read from its Module scope. */
+export interface RFileTopLevel {
+  /** Names of top-level function/class definitions, exactly as bound (backticks kept). */
+  readonly names: ReadonlySet<string>;
+  /** For each dotted name in {@link names}, the text after its last `.`. */
+  readonly dottedTails: ReadonlySet<string>;
+}
+
+const EMPTY_TOP_LEVEL: RFileTopLevel = { names: new Set(), dottedTails: new Set() };
+const topLevelCache = new WeakMap<ParsedFile, RFileTopLevel>();
+
+/**
+ * Top-level definitions of `parsed`, read from the Module scope's hoisted
+ * bindings.
+ *
+ * Since R scope queries anchor a `@scope.function` on every named function, a top-level function def is
+ * owned by its *own* Function scope and only its binding is hoisted into the
+ * Module scope, so neither the Module scope's `ownedDefs` nor the flat
+ * `localDefs` (which also lists nested functions and R6/R5 members) answers
+ * "is `name` defined at top level?". A `local`-origin Module binding to a
+ * function/class def does. Bindings are read at extraction time, before
+ * `finalizeScopeModel` adds import/wildcard bindings.
+ */
+export function rFileTopLevel(parsed: ParsedFile): RFileTopLevel {
+  const cached = topLevelCache.get(parsed);
+  if (cached !== undefined) return cached;
+  const moduleScope = parsed.scopes.find((s) => s.id === parsed.moduleScope);
+  let result = EMPTY_TOP_LEVEL;
+  if (moduleScope !== undefined) {
+    const names = new Set<string>();
+    const dottedTails = new Set<string>();
+    for (const [name, refs] of moduleScope.bindings) {
+      if (!refs.some((r) => r.origin === 'local' && TOP_LEVEL_BINDABLE_TYPES.has(r.def.type))) {
+        continue;
+      }
+      names.add(name);
+      const dot = name.lastIndexOf('.');
+      if (dot >= 0) dottedTails.add(name.slice(dot + 1));
+    }
+    result = { names, dottedTails };
+  }
+  topLevelCache.set(parsed, result);
+  return result;
+}
+
+// ─── Import synthesis (populateWorkspaceReferences) ─────────────────────────
+
+/**
+ * Per local package, the set of names it defines at top level in its `R/`
+ * files, recorded by {@link populateRNamespaceImports} for the packages that
+ * take part in an `importFrom()` (as caller or as provider). Keyed by the
+ * `resolutionConfig` object, which reaches both this hook and the
+ * free-call-fallback veto. A missing entry means "cannot decide".
+ */
+const packageTopLevelNames = new WeakMap<object, ReadonlyMap<string, ReadonlySet<string>>>();
+
+/** Recorded top-level names per package for `resolutionConfig`, if the hook ran with imports. */
+export function rRecordedPackageTopLevelNames(
+  resolutionConfig: unknown,
+): ReadonlyMap<string, ReadonlySet<string>> | undefined {
+  if (typeof resolutionConfig !== 'object' || resolutionConfig === null) return undefined;
+  return packageTopLevelNames.get(resolutionConfig);
+}
+
+interface CallerPlan {
+  readonly dir: string;
+  /** Surviving `name → provider package` after last-wins / self-drop / external-skip. */
+  readonly bindable: ReadonlyMap<string, string>;
+}
+
+/**
+ * Synthesise `named` imports for NAMESPACE `importFrom(pkg, name)` entries
+ * whose `pkg` is a local package, into every `R/` file of the caller package.
+ *
+ * NOTE: `populateWorkspaceReferences` is documented as reference-site
+ * enrichment; it is reused here (same call site and ctx as the Zig static
+ * gating precedent) because it runs before `finalizeScopeModel`, receives the
+ * mutable `ParsedFile[]`, and also runs over warm-cache ParsedFiles, so the
+ * synthesised imports are never persisted stale. If this is ever upstreamed,
+ * propose widening that contract's doc string.
+ *
+ * Order of operations per caller package:
+ *  1. last-wins over ALL entries for a name, in file order, external
+ *     packages included (R replaces the earlier `importFrom` binding);
+ *  2. drop the surviving entry when its `pkg` is the caller itself;
+ *  3. skip it when its `pkg` is not a local package (an earlier local entry
+ *     never resurrects);
+ *  4. skip it when the caller's own package defines `name` at top level in
+ *     any `R/` file (the own namespace masks its imports; `rMergeBindings`
+ *     only shadows within a single scope);
+ *  5. append a `named` import to every `R/` file of the caller package.
+ */
+export function populateRNamespaceImports(
+  parsedFiles: ParsedFile[],
+  ctx: { readonly resolutionConfig?: unknown },
+): void {
+  const cfg = (ctx.resolutionConfig as RPackageConfig | null | undefined) ?? null;
+  if (cfg === null || cfg.packages.size === 0) return;
+
+  // Steps 1-3: collapse each caller's entries; note which packages we need names for.
+  const plans = new Map<string, CallerPlan>();
+  const needNamesFor = new Set<string>();
+  for (const [callerName, dir] of cfg.packages) {
+    const info = cfg.namespaceInfoByPackageDir.get(dir);
+    if (info === undefined || info.importFrom.length === 0) continue;
+    const last = new Map<string, string>();
+    for (const entry of info.importFrom) last.set(entry.name, entry.pkg);
+    const bindable = new Map<string, string>();
+    for (const [name, pkg] of last) {
+      if (cfg.packages.has(pkg)) needNamesFor.add(pkg); // the fallback veto reads the provider's names too
+      if (pkg === callerName || !cfg.packages.has(pkg)) continue;
+      bindable.set(name, pkg);
+    }
+    if (bindable.size === 0) continue;
+    plans.set(callerName, { dir, bindable });
+    needNamesFor.add(callerName);
+  }
+  if (plans.size === 0) return;
+
+  // One pass over the parsed files: group caller files, collect top-level names.
+  const namesByPackage = new Map<string, Set<string>>();
+  const callerFiles = new Map<string, number[]>();
+  for (let i = 0; i < parsedFiles.length; i++) {
+    const location = rPackageDirForFile(parsedFiles[i].filePath, cfg);
+    if (location === undefined) continue;
+    if (needNamesFor.has(location.name)) {
+      let names = namesByPackage.get(location.name);
+      if (names === undefined) namesByPackage.set(location.name, (names = new Set()));
+      for (const name of rFileTopLevel(parsedFiles[i]).names) names.add(name);
+    }
+    if (plans.has(location.name)) {
+      const indices = callerFiles.get(location.name);
+      if (indices === undefined) callerFiles.set(location.name, [i]);
+      else indices.push(i);
+    }
+  }
+  for (const pkg of needNamesFor) if (!namesByPackage.has(pkg)) namesByPackage.set(pkg, new Set());
+  packageTopLevelNames.set(cfg, namesByPackage);
+
+  // Steps 4-5.
+  for (const [callerName, plan] of plans) {
+    const ownNames = namesByPackage.get(callerName);
+    const synthesised: Extract<ParsedImport, { kind: 'named' }>[] = [];
+    for (const [name, pkg] of plan.bindable) {
+      if (ownNames?.has(name) === true) continue;
+      // `null` means the name can never bind. A synthesised import for it would stay unresolved
+      // yet count as an explicit name claim, suppressing the documented `global-name-fallback`.
+      // (Importing the resolver forms a cycle with import-resolvers/r.ts; every use is deferred
+      // to call time, so it is safe at runtime.)
+      if (resolveRNamedImport(cfg, pkg, name, parsedFiles) === null) continue;
+      synthesised.push({ kind: 'named', localName: name, importedName: name, targetRaw: pkg });
+    }
+    if (synthesised.length === 0) continue;
+    for (const index of callerFiles.get(callerName) ?? []) {
+      const parsed = parsedFiles[index];
+      const fresh = synthesised.filter(
+        (imp) =>
+          !parsed.parsedImports.some(
+            (existing) =>
+              existing.kind === 'named' &&
+              existing.localName === imp.localName &&
+              existing.targetRaw === imp.targetRaw,
+          ),
+      );
+      if (fresh.length === 0) continue;
+      parsedFiles[index] = Object.freeze({
+        ...parsed,
+        parsedImports: Object.freeze([...parsed.parsedImports, ...fresh]),
+      });
+    }
+  }
+}
+
+// ─── `pkg::name()` qualifier helpers ────────────────────────────────────────
+
+/**
+ * The package named by the text of an `@reference.qualified-name` capture (the
+ * whole `namespace_operator`, e.g. `pkg::f`, `pkg:::f`, `pkg ::: f`,
+ * `"pkg"::f`, `` `pkg`::f ``): the text before the first `::` / `:::`,
+ * trimmed, with one pair of surrounding `"`, `'` or backticks removed.
+ * `undefined` when there is no `::` or the package part is empty. The
+ * function name is not parsed here: it is the site's own `name`.
+ *
+ * Lives here (not in `qualified-call.ts`, which re-exports it) because the
+ * veto below needs it and `qualified-call.ts` imports this file.
+ */
+export function parseRQualifier(raw: string): string | undefined {
+  const match = /^([\s\S]*?)\s*:::?/.exec(raw);
+  if (match === null) return undefined;
+  let pkg = match[1].trim();
+  if (pkg.length >= 2 && /^(["'`])[\s\S]*\1$/.test(pkg)) pkg = pkg.slice(1, -1);
+  return pkg.length === 0 ? undefined : pkg;
+}
+
+/**
+ * Per local package, how many top-level definitions of each name it has in its
+ * `R/` files, recorded by `populateRQualifiedCalls` for the packages that some
+ * `pkg::name()` call in the workspace names. Keyed by the `resolutionConfig`
+ * object (like {@link packageTopLevelNames}), which reaches both that hook and
+ * the free-call-fallback veto. A missing entry means "cannot decide".
+ */
+const qualifiedDefinitionCounts = new WeakMap<
+  object,
+  ReadonlyMap<string, ReadonlyMap<string, number>>
+>();
+
+/** Record (replacing any earlier record) the per-package definition counts for `resolutionConfig`. */
+export function rRecordQualifiedDefinitionCounts(
+  resolutionConfig: object,
+  counts: ReadonlyMap<string, ReadonlyMap<string, number>>,
+): void {
+  qualifiedDefinitionCounts.set(resolutionConfig, counts);
+}
+
+/**
+ * Number of top-level definitions of `name` recorded for local package `pkg`,
+ * or `undefined` when nothing was recorded (hook did not run for that package).
+ */
+export function rQualifiedDefinitionCount(
+  resolutionConfig: object,
+  pkg: string,
+  name: string,
+): number | undefined {
+  const byName = qualifiedDefinitionCounts.get(resolutionConfig)?.get(pkg);
+  return byName === undefined ? undefined : (byName.get(name) ?? 0);
+}
+
+// ─── Global-name fallback veto (isGlobalNameFallbackPlausible) ──────────────
+
+/**
+ * Structural subset of the hook context `isRGlobalNameFallbackPlausible`
+ * reads; the shared contract's full context is assignable to it.
+ */
+export interface RGlobalNameFallbackContext {
+  readonly callerParsed: { readonly filePath: string };
+  readonly candidate: { readonly filePath: string };
+  /** Opaque `loadResolutionConfig` result; an {@link RPackageConfig} for R. */
+  readonly resolutionConfig?: unknown;
+  readonly site: { readonly name: string; readonly rawQualifiedName?: string };
+}
+
+/**
+ * Refuse a `global-name-fallback` guess that the caller package's NAMESPACE
+ * contradicts. Returns `false` (veto) only when ALL of these hold:
+ *
+ *  - the caller file lives under `<pkgDir>/R/**` of a package with a NAMESPACE
+ *    that has an `importFrom(P, <site.name>)` entry (the LAST such entry over
+ *    all entries, external packages included — the same last-wins rule the synthesised imports follow);
+ *  - `P` is not the caller's own package (a self-import binds nothing);
+ *  - the candidate lives under some package's `R/**`, and that package is
+ *    neither the caller's own (own namespace masks; a plain 0.5 fallback edge
+ *    until own-package binding exists) nor `P`;
+ *  - if `P` is local, it defines `site.name` at top level; otherwise `P`
+ *    re-exports the name from a third package and the candidate may be the
+ *    real origin (unknown per-package names = cannot decide = allow).
+ *
+ * Everything else — no config, caller outside a package `R/` (`tests/`,
+ * `scripts/`, root `plumber.R`), no entry, candidate outside any package
+ * `R/` — answers `true`, so `source()`/`library()` script flows are untouched.
+ *
+ * A qualified call `pkg::name()` (site carries `rawQualifiedName`) is judged
+ * by its qualifier first: with `pkg` a local package, a candidate
+ * inside `pkg` is plausible whatever the NAMESPACE says, and a candidate
+ * elsewhere is vetoed when `pkg` itself defines `name`. A `pkg` that defines
+ * nothing of that name (re-export), or that is not a local package, falls
+ * through to the NAMESPACE rules above.
+ *
+ * Known unsound shape, pinned by a characterisation test: `import(pkg)` is not
+ * tokenised, so a later `import(pkg)` that R would prefer is invisible.
+ */
+export function isRGlobalNameFallbackPlausible(ctx: RGlobalNameFallbackContext): boolean {
+  const cfg = ctx.resolutionConfig as RPackageConfig | null | undefined;
+  if (
+    typeof cfg !== 'object' ||
+    cfg === null ||
+    !(cfg.packages instanceof Map) ||
+    !(cfg.namespaceInfoByPackageDir instanceof Map)
+  ) {
+    return true;
+  }
+
+  // Qualified call `pkg::name()`: the source named the package, so the package
+  // outranks the caller's NAMESPACE. A candidate inside a local `pkg` is right;
+  // a candidate elsewhere contradicts the qualifier when `pkg` defines `name`
+  // itself. A `pkg` that defines nothing of that name (a re-export) or that has
+  // no recorded counts cannot be judged from here: fall through to the rules
+  // below, i.e. today's behaviour. An unknown or external `pkg` falls through
+  // too (external sites are dropped upstream, before any fallback tier).
+  const qualifier =
+    ctx.site.rawQualifiedName === undefined
+      ? undefined
+      : parseRQualifier(ctx.site.rawQualifiedName);
+  if (qualifier !== undefined && cfg.packages.has(qualifier)) {
+    if (rPackageDirForFile(ctx.candidate.filePath, cfg)?.name === qualifier) return true;
+    if ((rQualifiedDefinitionCount(cfg, qualifier, ctx.site.name) ?? 0) > 0) return false;
+  }
+
+  const caller = rPackageDirForFile(ctx.callerParsed.filePath, cfg);
+  if (caller === undefined) return true;
+  const importFrom = cfg.namespaceInfoByPackageDir.get(caller.dir)?.importFrom;
+  if (importFrom === undefined) return true;
+
+  let lastEntry: RNamespaceImportFromEntry | undefined;
+  for (const entry of importFrom) if (entry.name === ctx.site.name) lastEntry = entry;
+  if (lastEntry === undefined) return true;
+  const importedFrom = lastEntry.pkg;
+  if (importedFrom === caller.name) return true;
+
+  const candidatePkg = rPackageDirForFile(ctx.candidate.filePath, cfg);
+  if (candidatePkg === undefined) return true;
+  if (candidatePkg.name === caller.name || candidatePkg.name === importedFrom) return true;
+
+  if (cfg.packages.has(importedFrom)) {
+    const providerNames = rRecordedPackageTopLevelNames(cfg)?.get(importedFrom);
+    if (providerNames === undefined || !providerNames.has(ctx.site.name)) return true;
+  }
+  return false;
+}
diff --git a/gitnexus/src/core/ingestion/languages/r/naming-argument.ts b/gitnexus/src/core/ingestion/languages/r/naming-argument.ts
new file mode 100644
index 000000000..f379171d6
--- /dev/null
+++ b/gitnexus/src/core/ingestion/languages/r/naming-argument.ts
@@ -0,0 +1,187 @@
+/**
+ * Which argument of an R call names what the call defines or imports.
+ *
+ * `R_QUERIES` captures every string-valued argument of `setClass`,
+ * `setRefClass`, `setGeneric` and `setMethod`, and the scope query captures every
+ * identifier- or string-valued argument of `library`, `require` and `source` and
+ * every string argument of `setClass`/`setRefClass`. Only one of them is the
+ * definition's name or the import's source; the rest are `contains = "VIRTUAL"`,
+ * `valueClass = "numeric"`, the class slot of `setMethod("show", "Foo", ...)`,
+ * `lib.loc = libO`, and so on. The choice is made here, in code, rather than in the
+ * query: a tree-sitter query can only skip an unbounded run of leading
+ * comments and named arguments with a repeated sibling group, and that costs
+ * time quadratic in the argument count on every call in the file (a single
+ * `list(a0 = 0, ...)` with 16000 arguments took 18s). This check is linear: it
+ * reads each argument list once and caches the answer.
+ *
+ * R matches arguments by name first, then positionally. The naming argument is
+ * therefore the argument spelled with the call's first formal (`Class = "A"`),
+ * or, when no argument anywhere in the list is spelled that way, the first
+ * unnamed argument. Comments, commas and other named arguments may precede it,
+ * and a `Class = ...` after an unnamed argument takes the formal from it, so
+ * `setClass(a = "Q", "B", Class = "A")` names `A` only.
+ *
+ * A formal may be spelled bare, in backticks or in quotes (`Class`, `` `Class` ``,
+ * `"Class"`); all name the same argument. Partial matching of an abbreviated
+ * name (`Cl = "A"`) is not modelled.
+ */
+
+import type { SyntaxNode } from '../../utils/ast-helpers.js';
+import type { CaptureMap } from '../../language-provider.js';
+
+/** The first formal of each call whose first argument names what it defines or imports. */
+const NAMING_FORMAL: Readonly<Record<string, string>> = {
+  setClass: 'Class',
+  setRefClass: 'Class',
+  setGeneric: 'name',
+  setMethod: 'f',
+  library: 'package',
+  require: 'package',
+  source: 'file',
+};
+
+/** An argument's name with one pair of surrounding backticks or quotes removed. */
+function argumentNameText(name: SyntaxNode): string {
+  const text = name.text;
+  if (text.length >= 2) {
+    const first = text[0];
+    if ((first === '`' || first === '"' || first === "'") && text[text.length - 1] === first) {
+      return text.slice(1, -1);
+    }
+  }
+  return text;
+}
+
+/**
+ * Per tree, per (argument list, formal): the id of the unnamed argument that takes
+ * the formal, or null when none does. One pass over the argument list answers every
+ * later match in that list in constant time. Looking backwards from each match
+ * instead is quadratic in the number of preceding comments (sibling lookup is
+ * linear in the sibling's position), so the list is read forwards, once.
+ */
+const namingArgumentIds = new WeakMap<object, Map<string, number | null>>();
+
+function namingUnnamedArgumentId(argumentList: SyntaxNode, formal: string): number | null {
+  let perTree = namingArgumentIds.get(argumentList.tree);
+  if (perTree === undefined) {
+    perTree = new Map();
+    namingArgumentIds.set(argumentList.tree, perTree);
+  }
+  const key = `${argumentList.id}:${formal}`;
+  const cached = perTree.get(key);
+  if (cached !== undefined) return cached;
+
+  // The first unnamed argument takes the formal, unless an argument anywhere in the
+  // list is spelled with it (R matches by name first), which retracts that choice.
+  let found: number | null = null;
+  for (const child of argumentList.namedChildren) {
+    if (child.type !== 'argument') continue; // comment, comma
+    const name = child.childForFieldName('name');
+    if (name === null) {
+      found ??= child.id;
+    } else if (argumentNameText(name) === formal) {
+      found = null;
+      break;
+    }
+  }
+  perTree.set(key, found);
+  return found;
+}
+
+/**
+ * The argument R would match to `target` in a call to a function whose formals are
+ * `formals`, in order. R matches named arguments first (a name that spells a formal
+ * binds it) and then fills the formals that remain from the unnamed arguments, in
+ * order. Partial matching of abbreviated names (`sig =`) is not modelled. Returns
+ * null when no argument reaches `target`. Linear in the argument count; meant for
+ * the one call a definition hook is looking at, not for every call in a file.
+ */
+export function getRMatchedArgument(
+  argumentList: SyntaxNode,
+  formals: readonly string[],
+  target: string,
+): SyntaxNode | null {
+  const unnamed: SyntaxNode[] = [];
+  const named = new Set<string>();
+  for (const child of argumentList.namedChildren) {
+    if (child.type !== 'argument') continue; // comment, comma
+    const name = child.childForFieldName('name');
+    if (name === null) {
+      unnamed.push(child);
+      continue;
+    }
+    const text = argumentNameText(name);
+    if (text === target) return child;
+    named.add(text);
+  }
+  const remaining = formals.filter((formal) => !named.has(formal));
+  const index = remaining.indexOf(target);
+  return index === -1 ? null : (unnamed[index] ?? null);
+}
+
+/**
+ * True when `argument` (an `argument` node) is the one that names the call's
+ * definition, given the call's first `formal`.
+ */
+export function isRNamingArgument(argument: SyntaxNode, formal: string): boolean {
+  const ownName = argument.childForFieldName('name');
+  if (ownName !== null) return argumentNameText(ownName) === formal;
+  const argumentList = argument.parent;
+  if (argumentList === null) return false;
+  return namingUnnamedArgumentId(argumentList, formal) === argument.id;
+}
+
+/**
+ * True when a `R_QUERIES` match captured an argument of one of the calls above
+ * that is NOT the naming argument, so the definition it would mint is spurious.
+ * Matches of any other shape (R6, functions, slots, calls, imports) are never
+ * skipped. The legacy `@import` matches are discarded by the parse worker, so
+ * they are not considered here.
+ */
+export function isRNonNamingArgumentCapture(captureMap: CaptureMap): boolean {
+  const fn = captureMap['_fn'];
+  if (fn === undefined) return false;
+  const formal = NAMING_FORMAL[fn.text];
+  if (formal === undefined) return false;
+
+  // Definitions capture the string's content. Slot matches capture a named
+  // argument's identifier and are not ours.
+  const captured = captureMap['name'];
+  if (captured === undefined || captured.type !== 'string_content') return false;
+  const argument = captured.parent?.parent;
+  if (argument === undefined || argument === null || argument.type !== 'argument') return false;
+
+  return !isRNamingArgument(argument, formal);
+}
+
+/** The captures of a raw tree-sitter match, as the scope emitter sees them. */
+interface RawCapture {
+  readonly name: string;
+  readonly node: SyntaxNode;
+}
+
+/** Callee captures of the scope query's naming-argument patterns (`r/query.ts`). */
+const SCOPE_CALLEE_CAPTURES: ReadonlySet<string> = new Set(['_s4_decl', '_srcfn', '_libfn']);
+
+/**
+ * True when a scope-query match captured an argument of `setClass` /
+ * `setRefClass` (`@declaration.name`), `library` / `require` or `source`
+ * (`@import.source`) that is NOT the naming argument. The scope query captures
+ * every such argument; the emitter drops these matches.
+ */
+export function isRNonNamingScopeMatch(captures: readonly RawCapture[]): boolean {
+  const fn = captures.find((c) => SCOPE_CALLEE_CAPTURES.has(c.name));
+  if (fn === undefined) return false;
+  const formal = NAMING_FORMAL[fn.node.text];
+  if (formal === undefined) return false;
+
+  const captured = captures.find(
+    (c) => c.name === 'declaration.name' || c.name === 'import.source',
+  );
+  if (captured === undefined) return false;
+  const argument =
+    captured.node.type === 'string_content' ? captured.node.parent?.parent : captured.node.parent;
+  if (argument === undefined || argument === null || argument.type !== 'argument') return false;
+
+  return !isRNamingArgument(argument, formal);
+}
diff --git a/gitnexus/src/core/ingestion/languages/r/owner-hooks.ts b/gitnexus/src/core/ingestion/languages/r/owner-hooks.ts
new file mode 100644
index 000000000..084b48809
--- /dev/null
+++ b/gitnexus/src/core/ingestion/languages/r/owner-hooks.ts
@@ -0,0 +1,39 @@
+/**
+ * R owner hooks for the shared ingestion pipeline.
+ *
+ * R has no class syntax: R6 / RefClass members belong to a call or assignment
+ * (`Foo <- R6::R6Class(...)`, `setRefClass(...)`), not to an enclosing
+ * container node. `resolveMemberOwnerNode` hands the member extractors that
+ * owner node. Members whose owner is a string (`setMethod("area", "Circle",
+ * ...)`) or a top-level R6/RefClass call are instead tied to their class after
+ * all chunks merge: `definitionPropertiesExtractor` records the owner name as
+ * an `ownerNameHint`, resolved by R's `postParse` hook.
+ */
+
+import type { SyntaxNode } from '../../utils/ast-helpers.js';
+import type { DefinitionPropertiesContext } from '../../language-provider.js';
+import { findRFieldOwnerNode, getRTopLevelPropertyOwnerName } from '../../field-extractors/r.js';
+import { getRTopLevelMethodOwnerName } from '../../method-extractors/r.js';
+
+/** `LanguageProvider.resolveMemberOwnerNode` for R. */
+export const rResolveMemberOwnerNode = (definitionNode: SyntaxNode): SyntaxNode | null =>
+  findRFieldOwnerNode(definitionNode);
+
+/**
+ * `LanguageProvider.definitionPropertiesExtractor` for R: the deferred owner
+ * name (`ownerNameHint`) of a `Method`/`Property` whose owning class is named by
+ * a string argument or a top-level R6/RefClass call rather than a syntactic
+ * ancestor.
+ */
+export const rDefinitionProperties = (
+  ctx: DefinitionPropertiesContext,
+): Readonly<Record<string, unknown>> | undefined => {
+  const ownerNameHint =
+    ctx.nodeLabel === 'Method'
+      ? (getRTopLevelMethodOwnerName(ctx.definitionNode) ??
+        getRTopLevelPropertyOwnerName(ctx.definitionNode))
+      : ctx.nodeLabel === 'Property'
+        ? getRTopLevelPropertyOwnerName(ctx.definitionNode)
+        : null;
+  return ownerNameHint ? { ownerNameHint } : undefined;
+};
diff --git a/gitnexus/src/core/ingestion/languages/r/package-config.ts b/gitnexus/src/core/ingestion/languages/r/package-config.ts
new file mode 100644
index 000000000..e1d0e4d94
--- /dev/null
+++ b/gitnexus/src/core/ingestion/languages/r/package-config.ts
@@ -0,0 +1,407 @@
+import type { Dirent } from 'fs';
+import fs from 'fs/promises';
+import path from 'path';
+import {
+  parseRNamespaceExports,
+  parseRNamespaceImportFrom,
+  type RNamespaceImportFromEntry,
+} from './namespace-imports.js';
+import { compileRExportPatternDetailed, type RExportMatcher } from './export-pattern.js';
+import { SharedWorkBudget } from './linear-regex.js';
+import { isDev } from '../../utils/env.js';
+import { logger } from '../../../logger.js';
+
+/** An `exportPattern()` argument that was not compiled, and why. */
+export interface RDroppedExportPattern {
+  /** The pattern text as R would see it (the string value, after unescaping). */
+  readonly pattern: string;
+  readonly reason: string;
+}
+
+/** R package config parsed from DESCRIPTION files in a multi-package repo */
+export interface RPackageConfig {
+  /**
+   * Map of package name to directory path relative to repo root. When several
+   * directories declare the same `Package:` name the shallowest directory wins
+   * and, among equal depths, the one whose whole path string sorts first by
+   * code unit (so `a-b/x` beats `a/x`: `-` sorts before `/`); the others are
+   * not entries here (their NAMESPACE is still recorded in
+   * {@link namespaceInfoByPackageDir}, which is keyed by directory). Installed
+   * libraries and check output (`renv`, `packrat`, `revdep`, `<name>.Rcheck`) are
+   * not searched, so their packages are not entries here.
+   */
+  packages: Map<string, string>;
+  /** Package-scoped NAMESPACE config keyed by package dir relative to repo root. */
+  namespaceInfoByPackageDir: Map<string, RNamespaceInfo>;
+  /**
+   * Every directory (relative to the repo root, `''` for the root) in which discovery read a
+   * `DESCRIPTION` with a `Package:` line: the directories of {@link packages} plus the
+   * directories of same-name copies that lost to them, with or without a NAMESPACE. The
+   * qualifier-locality decision reads it, so that a file under such a directory's `R/` is not
+   * taken as evidence for a package named after its directory. Optional so that hand-built
+   * configs read as "the directories of {@link packages} and {@link namespaceInfoByPackageDir}".
+   */
+  packageDirs?: ReadonlySet<string>;
+  /**
+   * True when discovery cannot rule out an undiscovered package: a directory
+   * of the main walk could not be read, or a subtree the walk skipped (below
+   * the depth limit, or still queued when the directory cap stopped it) may
+   * hide a package. Skipped subtrees are scanned once more for `DESCRIPTION`
+   * files (see {@link hidesUndiscoveredPackage}); the flag is set only when
+   * that scan finds a `Package:` name absent from {@link packages}, exceeds
+   * its directory budget, or hits an unreadable path. A skipped subtree with
+   * no package inside (`tests/testthat/fixtures/...`, `inst/extdata/...`) or
+   * only a same-name copy of an already-discovered package does NOT truncate.
+   * A package missing from {@link packages} is then not proven absent from the
+   * repo, so `rQualifierLocality` answers `unknown` rather than `external`.
+   * This holds for an empty {@link packages} map too: a complete scan that found
+   * no package at all proves every qualifier external.
+   * Optional so that hand-built configs (tests, callers that never scan) read
+   * as "complete".
+   */
+  truncated?: boolean;
+}
+
+export interface RNamespaceInfo {
+  /** True when the package has a readable NAMESPACE file. */
+  hasNamespaceFile: boolean;
+  /** Explicit named exports from export()/exportClasses()/exportMethods()/S3method(). */
+  namedExports: Set<string>;
+  /** Precompiled matchers from exportPattern("..."), compiled once here so
+   *  `refineRExportStatus` doesn't recompile per node it checks. POSIX bracket
+   *  classes such as `[[:alpha:]]` are translated to JS equivalents first
+   *  (see `compileRExportPattern`). The matchers run in linear time, so a hostile
+   *  pattern cannot stall analysis. Patterns that fail to compile, or that the
+   *  linear-time matcher cannot handle, are dropped at this stage (they never match)
+   *  and listed in {@link droppedExportPatterns}. */
+  exportPatterns: RExportMatcher[];
+  /**
+   * Non-empty `exportPattern()` arguments that could not be compiled, with the reason.
+   * A dropped pattern exports nothing, so every name the pattern was meant to cover
+   * reads as unexported; `reportDroppedRExportPatterns` turns these into warnings.
+   * Optional so that hand-built configs read as "nothing dropped".
+   */
+  droppedExportPatterns?: readonly RDroppedExportPattern[];
+  /**
+   * How many further non-empty `exportPattern()` arguments were dropped but not listed in
+   * {@link droppedExportPatterns}, which holds at most {@link MAX_LISTED_DROPPED_PATTERNS}
+   * per package so that a NAMESPACE of hundreds of thousands of refused patterns cannot
+   * produce hundreds of thousands of warnings. Reported as one line.
+   */
+  omittedDroppedExportPatterns?: number;
+  /**
+   * The work budget this package's matchers draw on: a sub-budget of the load's. Absent on
+   * hand-built configs. {@link rExportPatternMatches} stops consulting the matchers once it
+   * is spent.
+   */
+  exportPatternBudget?: SharedWorkBudget;
+  /** `importFrom(pkg, name)` pairs in NAMESPACE file order (all entries, incl. self-imports and duplicates). */
+  importFrom: readonly RNamespaceImportFromEntry[];
+}
+
+/**
+ * Most patterns named in warnings per package, for dropped patterns (the rest are counted,
+ * see `omittedDroppedExportPatterns`) and for patterns cut short by the budget alike, so
+ * that a NAMESPACE of tens of thousands of patterns cannot produce as many warnings.
+ */
+export const MAX_LISTED_DROPPED_PATTERNS = 50;
+
+/**
+ * True when one of the package's `exportPattern()` matchers matches `name`. Once the
+ * package's work budget (or the load's) is spent it stops asking the matchers at all and
+ * answers false, so the cost no longer grows as patterns x names; the patterns it did not
+ * get to run are then reported by {@link reportRExportPatternProblems}.
+ */
+export function rExportPatternMatches(
+  info: Pick<RNamespaceInfo, 'exportPatterns' | 'exportPatternBudget'>,
+  name: string,
+): boolean {
+  const budget = info.exportPatternBudget;
+  for (const pattern of info.exportPatterns) {
+    if (budget?.isSpent === true) {
+      budget.cutShort = true;
+      return false;
+    }
+    if (pattern.test(name)) return true;
+  }
+  return false;
+}
+
+/** Longest pattern prefix quoted in a warning. */
+const QUOTED_PATTERN_LENGTH = 60;
+
+const quotePattern = (pattern: string): string =>
+  JSON.stringify(
+    pattern.length > QUOTED_PATTERN_LENGTH
+      ? `${pattern.slice(0, QUOTED_PATTERN_LENGTH)}...`
+      : pattern,
+  );
+
+/**
+ * Warn, once per pattern per package, about every `exportPattern()` that is not in
+ * effect: one dropped at load ({@link RNamespaceInfo.droppedExportPatterns}) or one
+ * whose matcher ran out of work budget since (names it had not yet decided were read as
+ * unexported). Call after the matchers have been used. A dropped pattern exports
+ * nothing, which would otherwise look exactly like a package that exports few names.
+ */
+export function reportRExportPatternProblems(config: RPackageConfig): void {
+  for (const [pkgDir, info] of config.namespaceInfoByPackageDir) {
+    const where = pkgDir === '' ? '.' : pkgDir;
+    for (const { pattern, reason } of info.droppedExportPatterns ?? []) {
+      logger.warn(
+        `R package ${where}: exportPattern(${quotePattern(pattern)}) was ignored (${reason}); ` +
+          `names it would export are treated as not exported`,
+      );
+    }
+    if ((info.omittedDroppedExportPatterns ?? 0) > 0) {
+      logger.warn(
+        `R package ${where}: ${info.omittedDroppedExportPatterns} further exportPattern() ` +
+          `arguments were ignored as well and are not listed; names they would export are ` +
+          `treated as not exported`,
+      );
+    }
+    const cutShort = info.exportPatternBudget?.cutShort === true;
+    let listed = 0;
+    let unlisted = 0;
+    for (const matcher of info.exportPatterns) {
+      if (matcher.exhausted !== true && !cutShort) continue;
+      if (listed >= MAX_LISTED_DROPPED_PATTERNS) {
+        unlisted++;
+        continue;
+      }
+      listed++;
+      logger.warn(
+        `R package ${where}: exportPattern(${quotePattern(matcher.source)}) exceeded its work ` +
+          `budget (its own, its package's or the repository's); ` +
+          `names it had not yet been tested against are treated as not exported`,
+      );
+    }
+    if (unlisted > 0) {
+      logger.warn(
+        `R package ${where}: ${unlisted} further exportPattern() arguments exceeded their work ` +
+          `budget as well and are not listed; names they had not yet been tested against are ` +
+          `treated as not exported`,
+      );
+    }
+  }
+}
+
+/** Directories never descended into, by the main walk and the hidden-package scan alike. */
+const SKIPPED_DIR_NAMES: ReadonlySet<string> = new Set(['node_modules', '.git', '.Rproj.user']);
+
+/**
+ * Directories R tooling fills with installed packages or check output: the renv project
+ * library, the packrat private library and the revdepcheck workspace. Each holds one
+ * `DESCRIPTION` per third-party package, none of which is part of the repository.
+ */
+const VENDORED_LIBRARY_DIR_NAMES: ReadonlySet<string> = new Set(['renv', 'packrat', 'revdep']);
+
+/** Suffix of the `<pkg>.Rcheck` directories `R CMD check` writes. */
+const RCHECK_SUFFIX = '.Rcheck';
+
+/**
+ * True for a directory that discovery must not enter. The match is on the directory's own
+ * name, exact and case-sensitive: `renv`, `packrat` or `revdep`, or `<something>.Rcheck`
+ * (a name that is only the suffix is not one). Look-alikes such as `renv-tools`, `Renv`,
+ * `revdeps` or `pkg.rcheck` are ordinary directories and may hold a real package.
+ */
+function isSkippedDirName(name: string): boolean {
+  return (
+    SKIPPED_DIR_NAMES.has(name) ||
+    VENDORED_LIBRARY_DIR_NAMES.has(name) ||
+    (name.length > RCHECK_SUFFIX.length && name.endsWith(RCHECK_SUFFIX))
+  );
+}
+
+/**
+ * Directory entries in code-unit name order. `readdir` order is filesystem-dependent
+ * (and `localeCompare` is locale-dependent), so every walk below reads through this to
+ * make what it visits, and what it finds first, the same on every machine.
+ */
+async function readDirSorted(dir: string): Promise<Dirent[]> {
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  return entries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+}
+
+/**
+ * Sort key that ranks the directories declaring one package name: fewer path segments
+ * first, then the whole `/`-separated relative path compared by code unit. Comparing keys
+ * with `<` therefore needs no help from the walk order. The depth is zero-padded so that
+ * it compares as a number; `''` (the repo root) has depth 0.
+ */
+function preferredPackageDir(pkgDir: string): string {
+  const depth = pkgDir === '' ? 0 : pkgDir.split('/').length;
+  return `${String(depth).padStart(6, '0')}\0${pkgDir}`;
+}
+
+/** Global directory budget for {@link hidesUndiscoveredPackage} across all its roots. */
+const HIDDEN_SCAN_BUDGET = 5000;
+
+/**
+ * Scan the subtrees the main walk skipped for a package it never discovered.
+ *
+ * Iterative DFS over `roots` under one global `budget` of directories (skipping
+ * the directories {@link isSkippedDirName} names, as the main walk does). Returns
+ * `true` (cannot rule a hidden package out) when the budget is exceeded, when a
+ * directory or `DESCRIPTION` cannot be read, or when a `DESCRIPTION` declares a
+ * `Package:` name that is not in `knownPackageNames`. Returns `false` when every
+ * subtree was scanned and holds no such package. Deterministic and read-only.
+ * The answer is a property of the set of directories, not of the order they are
+ * visited in (every `true` condition is order-independent and a `false` means the
+ * whole forest was read), but the walk still reads sorted so that it is reproducible.
+ */
+export async function hidesUndiscoveredPackage(
+  roots: readonly string[],
+  knownPackageNames: ReadonlySet<string>,
+  budget: number = HIDDEN_SCAN_BUDGET,
+): Promise<boolean> {
+  const stack = [...roots];
+  let remaining = budget;
+  for (let dir = stack.pop(); dir !== undefined; dir = stack.pop()) {
+    if (--remaining < 0) return true;
+    let entries;
+    try {
+      entries = await readDirSorted(dir);
+    } catch {
+      return true;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (!isSkippedDirName(entry.name)) stack.push(path.join(dir, entry.name));
+      } else if (entry.isFile() && entry.name === 'DESCRIPTION') {
+        try {
+          const content = await fs.readFile(path.join(dir, entry.name), 'utf-8');
+          const pkgMatch = content.match(/^Package:\s*(\S+)/m);
+          if (pkgMatch && !knownPackageNames.has(pkgMatch[1])) return true;
+        } catch {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+
+/**
+ * Discover the R packages of a repo. Always returns a config: a scan that finds
+ * no package yields an empty {@link RPackageConfig.packages} map, and its
+ * {@link RPackageConfig.truncated} flag says whether that result is complete
+ * (no `DESCRIPTION` anywhere, so no `pkg::fn()` qualifier names a local package)
+ * or merely what the bounded scan managed to see.
+ */
+export async function loadRPackageConfig(repoRoot: string): Promise<RPackageConfig> {
+  const packages = new Map<string, string>();
+  const namespaceInfoByPackageDir = new Map<string, RNamespaceInfo>();
+  const packageDirs = new Set<string>();
+  // One allowance (matching work and NFA states) for every exportPattern of every package
+  // found by this load, split into a sub-budget per package: the number of patterns a
+  // repository carries must not multiply the per-matcher cost.
+  const loadBudget = new SharedWorkBudget();
+  const scanQueue: { dir: string; depth: number }[] = [{ dir: repoRoot, depth: 0 }];
+  const maxDepth = 3;
+  const maxDirs = 200;
+  let dirsScanned = 0;
+  let truncated = false;
+  // Directories the walk never visits (depth limit, cap leftovers): scanned at the end.
+  const unvisited: string[] = [];
+
+  while (scanQueue.length > 0 && dirsScanned < maxDirs) {
+    const { dir, depth } = scanQueue.shift()!;
+    dirsScanned++;
+    try {
+      const entries = await readDirSorted(dir);
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          if (isSkippedDirName(entry.name)) continue;
+          const child = path.join(dir, entry.name);
+          if (depth < maxDepth) {
+            scanQueue.push({ dir: child, depth: depth + 1 });
+          } else {
+            // Below the depth limit: not visited by the walk; scanned below.
+            unvisited.push(child);
+          }
+        }
+        if (entry.isFile() && entry.name === 'DESCRIPTION') {
+          try {
+            const descPath = path.join(dir, entry.name);
+            const content = await fs.readFile(descPath, 'utf-8');
+            const pkgMatch = content.match(/^Package:\s*(\S+)/m);
+            if (pkgMatch) {
+              const pkgName = pkgMatch[1];
+              const pkgDir = path.relative(repoRoot, dir).replace(/\\/g, '/');
+              packageDirs.add(pkgDir);
+              // Same name in several directories: keep the preferred one, whatever the
+              // order the walk met them in (see preferredPackageDir).
+              const current = packages.get(pkgName);
+              if (
+                current === undefined ||
+                preferredPackageDir(pkgDir) < preferredPackageDir(current)
+              ) {
+                packages.set(pkgName, pkgDir);
+                if (isDev) {
+                  logger.info(`📦 Found R package: ${pkgName} at ${pkgDir}`);
+                }
+              }
+
+              const nsPath = path.join(dir, 'NAMESPACE');
+              try {
+                const nsContent = await fs.readFile(nsPath, 'utf-8');
+                const parsedExports = parseRNamespaceExports(nsContent);
+                const namedExports = new Set<string>(parsedExports.namedExports);
+                // POSIX classes are translated; an uncompilable pattern is skipped (never
+                // matches) and recorded so the caller can say so.
+                const exportPatterns: RExportMatcher[] = [];
+                const droppedExportPatterns: RDroppedExportPattern[] = [];
+                let omittedDropped = 0;
+                // This package's share of the load's budget: one hostile package cannot
+                // take all of it and leave the packages after it without their patterns.
+                const packageBudget = loadBudget.child();
+                for (const pattern of new Set(parsedExports.exportPatterns)) {
+                  const compiled = compileRExportPatternDetailed(pattern, packageBudget);
+                  if ('reason' in compiled) {
+                    if (droppedExportPatterns.length < MAX_LISTED_DROPPED_PATTERNS) {
+                      droppedExportPatterns.push({ pattern, reason: compiled.reason });
+                    } else {
+                      omittedDropped++;
+                    }
+                  } else {
+                    exportPatterns.push(compiled.matcher);
+                  }
+                }
+
+                namespaceInfoByPackageDir.set(pkgDir, {
+                  hasNamespaceFile: true,
+                  namedExports,
+                  exportPatterns,
+                  droppedExportPatterns,
+                  omittedDroppedExportPatterns: omittedDropped,
+                  exportPatternBudget: packageBudget,
+                  importFrom: parseRNamespaceImportFrom(nsContent),
+                });
+              } catch {
+                // No NAMESPACE file or can't read it
+              }
+            }
+          } catch {
+            // Can't read DESCRIPTION: the package it declares was not discovered.
+            truncated = true;
+          }
+        }
+      }
+    } catch {
+      // Can't read directory: whatever it holds was not discovered.
+      truncated = true;
+    }
+  }
+
+  // Directories still queued when the cap stopped the walk were never visited either.
+  for (const { dir } of scanQueue) unvisited.push(dir);
+  if (
+    !truncated &&
+    unvisited.length > 0 &&
+    (await hidesUndiscoveredPackage(unvisited, new Set(packages.keys())))
+  ) {
+    truncated = true;
+  }
+  return { packages, namespaceInfoByPackageDir, packageDirs, truncated };
+}
diff --git a/gitnexus/src/core/ingestion/languages/r/post-parse.ts b/gitnexus/src/core/ingestion/languages/r/post-parse.ts
new file mode 100644
index 000000000..cc9b26da4
--- /dev/null
+++ b/gitnexus/src/core/ingestion/languages/r/post-parse.ts
@@ -0,0 +1,161 @@
+/**
+ * R post-parse hooks.
+ *
+ * R classes are expressed as function calls (`R6::R6Class("Name", ...)`,
+ * `setClass("Name", ...)`, `setMethod("fn", "ClassName", ...)`) rather than
+ * tree-sitter class syntax, so the worker cannot always find the enclosing
+ * class node via a parent walk. When that happens, the worker stores the
+ * owner name as an `ownerNameHint` string on the symbol/graph node.
+ *
+ * After parsing is complete and the TypeRegistry is fully populated, we
+ * resolve every `ownerNameHint` to a real `ownerId` and:
+ *   1. Patch `node.properties.ownerId`
+ *   2. Mutate the SymbolDefinition's `ownerId` (shared ref across registries)
+ *   3. Register the symbol into MutableMethodRegistry / MutableFieldRegistry
+ *   4. Emit the HAS_METHOD / HAS_PROPERTY graph edge
+ *
+ * NAMESPACE-aware export refinement also runs here — ExportChecker doesn't have
+ * a file-path context, so it defaults all R symbols to public. Once we know
+ * which package's `R/` directory each file lives in, we flip `isExported` to false
+ * for symbols that aren't in the NAMESPACE exports.
+ */
+
+import type { KnowledgeGraph } from '../../../graph/types.js';
+import type { MutableSemanticModel } from '../../model/semantic-model.js';
+import type { PostParseContext } from '../../language-provider.js';
+import {
+  loadRPackageConfig,
+  reportRExportPatternProblems,
+  rExportPatternMatches,
+  type RNamespaceInfo,
+  type RPackageConfig,
+} from './package-config.js';
+import { rOwningPackageDir } from './namespace-imports.js';
+import type { GraphNode } from 'gitnexus-shared';
+import { SupportedLanguages } from 'gitnexus-shared';
+import { generateId } from '../../../../lib/utils.js';
+
+type EdgeLabel = 'HAS_METHOD' | 'HAS_PROPERTY';
+
+/**
+ * Resolve R deferred owner hints into ownerIds. Runs post-parse, after all
+ * Class symbols have been registered into the TypeRegistry.
+ */
+export const attachDeferredROwners = (
+  graph: KnowledgeGraph,
+  model: MutableSemanticModel,
+  nodeLabel: 'Method' | 'Property',
+  edgeType: EdgeLabel,
+): void => {
+  graph.forEachNode((node: GraphNode) => {
+    // Skip immediately for non-R nodes — avoids doing any further work per node
+    // in this full-graph traversal for repos with no R files at all.
+    if (node.properties.language !== SupportedLanguages.R) return;
+    if (node.label !== nodeLabel) return;
+
+    // If we already have a resolved ownerId, the hint is redundant — drop it.
+    if (typeof node.properties.ownerId === 'string') {
+      delete node.properties.ownerNameHint;
+      return;
+    }
+
+    const ownerNameHint =
+      typeof node.properties.ownerNameHint === 'string' ? node.properties.ownerNameHint : null;
+    if (!ownerNameHint) return;
+
+    const classDefs = model.types.lookupClassByName(ownerNameHint);
+    if (classDefs.length !== 1) return; // ambiguous or not found — leave hint for debugging
+    const ownerId = classDefs[0].nodeId;
+
+    // 1. Patch the graph node.
+    node.properties.ownerId = ownerId;
+    delete node.properties.ownerNameHint;
+
+    // 2. Mutate the SymbolDefinition in place (shared ref across indexes).
+    const filePath = typeof node.properties.filePath === 'string' ? node.properties.filePath : '';
+    const name = typeof node.properties.name === 'string' ? node.properties.name : '';
+    const defs = model.symbols.lookupExactAll(filePath, name);
+    const def = defs.find((d) => d.nodeId === node.id);
+    if (def) {
+      def.ownerId = ownerId;
+
+      // 3. Explicitly register into the owner-scoped registry so resolveMemberCall
+      //    can find the symbol via MethodRegistry / FieldRegistry.
+      if (nodeLabel === 'Method') {
+        model.methods.register(ownerId, name, def);
+      } else {
+        model.fields.register(ownerId, name, def);
+      }
+    }
+
+    // 4. Emit the HAS_METHOD / HAS_PROPERTY edge.
+    graph.addRelationship({
+      id: generateId(edgeType, `${ownerId}->${node.id}`),
+      sourceId: ownerId,
+      targetId: node.id,
+      type: edgeType,
+      confidence: 1.0,
+      reason: '',
+    });
+  });
+};
+
+/**
+ * Refine R export status based on NAMESPACE files. A file belongs to the package whose
+ * `R/` directory contains it (the nearest enclosing discovered package; R loads nothing else
+ * into a package namespace), so only `R/` symbols are tested against that package's NAMESPACE:
+ * a symbol that package does not export is flipped to `isExported: false`. Files outside every
+ * package's `R/` (`tests/`, `vignettes/`, `inst/`, scripts, ...) and packages without a
+ * NAMESPACE file keep the default public behaviour; a nested package without a NAMESPACE does
+ * not inherit its enclosing package's.
+ */
+export const refineRExportStatus = (
+  graph: KnowledgeGraph,
+  rPackageConfig: RPackageConfig | null,
+): void => {
+  if (!rPackageConfig || rPackageConfig.namespaceInfoByPackageDir.size === 0) return;
+
+  // Nodes of one file share an owner; resolve it once per file.
+  const ownerByFile = new Map<string, RNamespaceInfo | undefined>();
+  const namespaceInfoFor = (filePath: string): RNamespaceInfo | undefined => {
+    if (ownerByFile.has(filePath)) return ownerByFile.get(filePath);
+    const pkgDir = rOwningPackageDir(filePath, rPackageConfig);
+    const info =
+      pkgDir === undefined ? undefined : rPackageConfig.namespaceInfoByPackageDir.get(pkgDir);
+    ownerByFile.set(filePath, info);
+    return info;
+  };
+
+  graph.forEachNode((node: GraphNode) => {
+    if (node.properties.language !== SupportedLanguages.R) return;
+    const filePath = typeof node.properties.filePath === 'string' ? node.properties.filePath : '';
+    if (!filePath) return;
+
+    const nsInfo = namespaceInfoFor(filePath);
+    if (!nsInfo || !nsInfo.hasNamespaceFile) return;
+
+    const name = typeof node.properties.name === 'string' ? node.properties.name : '';
+    if (!name) return;
+
+    if (nsInfo.namedExports.has(name)) return; // explicit export — keep public
+    // exportPatterns are precompiled linear-time matchers (see loadRPackageConfig) — no per-node recompile.
+    const matched = rExportPatternMatches(nsInfo, name);
+    if (matched) return;
+
+    // Not in NAMESPACE → not exported.
+    node.properties.isExported = false;
+  });
+};
+
+/**
+ * R's `LanguageProvider.postParse` hook: deferred owner attach for methods and
+ * properties, then NAMESPACE-driven export refinement. Runs once per analyze,
+ * after every chunk is merged and before scope resolution.
+ */
+export const rPostParse = async (ctx: PostParseContext): Promise<void> => {
+  attachDeferredROwners(ctx.graph, ctx.model, 'Method', 'HAS_METHOD');
+  attachDeferredROwners(ctx.graph, ctx.model, 'Property', 'HAS_PROPERTY');
+  const config = await loadRPackageConfig(ctx.repoPath);
+  refineRExportStatus(ctx.graph, config);
+  reportRExportPatternProblems(config);
+};
diff --git a/gitnexus/src/core/ingestion/languages/r/qualified-call.ts b/gitnexus/src/core/ingestion/languages/r/qualified-call.ts
new file mode 100644
index 000000000..e1f8bc047
--- /dev/null
+++ b/gitnexus/src/core/ingestion/languages/r/qualified-call.ts
@@ -0,0 +1,243 @@
+/**
+ * R `pkg::name()` / `pkg:::name()` qualified calls.
+ *
+ * The scope query captures the whole `namespace_operator` as
+ * `@reference.qualified-name`, so a call site carries `rawQualifiedName`
+ * (`pkg::f`). Without it every tier discards the qualifier and guesses by
+ * name: `dplyr::filter()` binds to an unrelated local `filter`, and
+ * `mypkg::tidy()` inside a wrapper named `tidy` binds to the wrapper itself.
+ *
+ * {@link populateRQualifiedCalls} runs at `populateWorkspaceReferences` time
+ * (before `finalizeScopeModel`, on cold and warm-cache runs alike, with the
+ * workspace's `RPackageConfig`) and decides each qualified site by the
+ * {@link rQualifierLocality} of its package:
+ *
+ *  - `external` (not local, and package discovery completed): the site is
+ *    dropped from `referenceSites`, so no tier can guess an edge for it;
+ *  - `local` with exactly one top-level definition of the name in the
+ *    package's `R/` files: that definition is recorded per call site and
+ *    returned by {@link resolveRQualifiedFreeCall}, which the free-call
+ *    fallback consults before every lexical tier (a precise 0.85 edge);
+ *  - `local` with two or more such definitions (same file or across files):
+ *    the site is dropped (every valid target is inside the named package, so
+ *    any edge would be provably wrong);
+ *  - `local` with no definition (a re-export, or a name defined some other
+ *    way) and `unknown` locality: the site is left untouched, i.e. today's
+ *    behaviour.
+ *
+ * The per-package definition counts are also recorded for the
+ * global-name-fallback veto (`isRGlobalNameFallbackPlausible`).
+ *
+ * Import direction: this file imports `namespace-imports.ts`, never the other
+ * way round, so `parseRQualifier` and the definition-count registry live there
+ * and are re-exported here.
+ */
+
+import type { ParsedFile, ReferenceSite, SymbolDefinition } from 'gitnexus-shared';
+import type { RPackageConfig } from './package-config.js';
+import {
+  parseRQualifier,
+  rFileBelongsToDiscoveredPackage,
+  rPackageDirForFile,
+  rRecordQualifiedDefinitionCounts,
+  TOP_LEVEL_BINDABLE_TYPES,
+} from './namespace-imports.js';
+
+export { parseRQualifier } from './namespace-imports.js';
+
+/** Whether a qualifier's package is a package of the analysed repo. */
+export type RQualifierLocality = 'local' | 'external' | 'unknown';
+
+/**
+ * True when `filePath` sits under a `<pkg>/R/` directory: a `/`-delimited path
+ * segment equal to `pkg` immediately followed by `R/` (`pkg/R/a.R`,
+ * `deep/x/pkg/R/a.R`; not `mypkg/R/a.R`, not `pkg/scripts/a.R`).
+ *
+ * The directory name stands in for the package name only for a file that no discovered
+ * package owns (the fallback for a package whose `DESCRIPTION` discovery missed or that has
+ * none). A file under a discovered package's `R/` belongs to the package its `DESCRIPTION`
+ * names, whatever its directory is called, so it is never evidence for another name.
+ */
+function isUnderPackageRDir(
+  pkg: string,
+  filePath: string,
+  cfg: RPackageConfig | null | undefined,
+): boolean {
+  const normalized = filePath.replace(/\\/g, '/');
+  if (!normalized.startsWith(`${pkg}/R/`) && !normalized.includes(`/${pkg}/R/`)) return false;
+  return !rFileBelongsToDiscoveredPackage(normalized, cfg);
+}
+
+/**
+ * Locality of the package named by a qualifier.
+ *
+ *  - `local`: `pkg` is in `cfg.packages`, or a parsed file sits under a
+ *    `<pkg>/R/` directory (a package whose `DESCRIPTION` discovery missed or
+ *    that has none; root-level packages are found through `cfg` only);
+ *  - `external`: not local, and `cfg` exists and its discovery was complete
+ *    (`!cfg.truncated`), so `pkg` provably is not part of the repo. This
+ *    includes a complete scan that found no package at all (no `DESCRIPTION`
+ *    anywhere): the config is then empty, not absent;
+ *  - `unknown`: not found, but discovery was truncated or there is no config
+ *    (hand-built callers), so `pkg` may still be a local package that was not seen.
+ *
+ * One predicate, so the populate step and the veto cannot disagree on "local".
+ */
+export function rQualifierLocality(
+  pkg: string,
+  cfg: RPackageConfig | null | undefined,
+  parsedFilePaths: ReadonlySet<string>,
+): RQualifierLocality {
+  if (cfg?.packages.has(pkg) === true) return 'local';
+  for (const filePath of parsedFilePaths) {
+    if (isUnderPackageRDir(pkg, filePath, cfg)) return 'local';
+  }
+  if (cfg === null || cfg === undefined) return 'unknown';
+  return cfg.truncated === true ? 'unknown' : 'external';
+}
+
+/**
+ * Call site → the single definition its `pkg::name()` qualifier names, for the
+ * current run. Module state, replaced wholesale by every
+ * {@link populateRQualifiedCalls} call. Keyed by file path and start position
+ * (the key `free-call-fallback.ts` uses for its handled sites), not by object
+ * identity, so it survives the frozen `ParsedFile` copies made after populate.
+ */
+let preciseBySite: Map<string, SymbolDefinition> = new Map();
+
+const siteKey = (filePath: string, atRange: { startLine: number; startCol: number }): string =>
+  `${filePath}:${atRange.startLine}:${atRange.startCol}`;
+
+function isQualifiedCall(site: ReferenceSite): site is ReferenceSite & {
+  readonly rawQualifiedName: string;
+} {
+  return site.kind === 'call' && site.rawQualifiedName !== undefined;
+}
+
+/**
+ * Per name, every top-level function/class definition (one entry per binding
+ * ref, so a same-file redefinition counts twice) of the given package files.
+ * Read from Module-scope `local` bindings at extraction time, like
+ * `rFileTopLevel`, but keeping the definitions rather than the names.
+ */
+function collectTopLevelDefinitions(files: readonly ParsedFile[]): Map<string, SymbolDefinition[]> {
+  const byName = new Map<string, SymbolDefinition[]>();
+  for (const parsed of files) {
+    const moduleScope = parsed.scopes.find((s) => s.id === parsed.moduleScope);
+    if (moduleScope === undefined) continue;
+    for (const [name, refs] of moduleScope.bindings) {
+      for (const ref of refs) {
+        if (ref.origin !== 'local' || !TOP_LEVEL_BINDABLE_TYPES.has(ref.def.type)) continue;
+        const list = byName.get(name);
+        if (list === undefined) byName.set(name, [ref.def]);
+        else list.push(ref.def);
+      }
+    }
+  }
+  return byName;
+}
+
+/**
+ * Decide every qualified call site of `parsedFiles` as described in the file
+ * header: drop external and duplicate-definition sites (in place, through
+ * frozen `ParsedFile` copies), record the precise target of single-definition
+ * sites, leave every other site untouched. Resets all module state first, so a
+ * run never sees the previous run's answers.
+ */
+export function populateRQualifiedCalls(
+  parsedFiles: ParsedFile[],
+  ctx: { readonly resolutionConfig?: unknown },
+): void {
+  preciseBySite = new Map();
+  const cfg = (ctx.resolutionConfig as RPackageConfig | null | undefined) ?? null;
+  if (cfg !== null) rRecordQualifiedDefinitionCounts(cfg, new Map());
+
+  // Packages named by some qualified call, and how local each one is.
+  let filePaths: Set<string> | undefined;
+  const localityByPackage = new Map<string, RQualifierLocality>();
+  for (const parsed of parsedFiles) {
+    for (const site of parsed.referenceSites) {
+      if (!isQualifiedCall(site)) continue;
+      const pkg = parseRQualifier(site.rawQualifiedName);
+      if (pkg === undefined || localityByPackage.has(pkg)) continue;
+      filePaths ??= new Set(parsedFiles.map((p) => p.filePath));
+      localityByPackage.set(pkg, rQualifierLocality(pkg, cfg, filePaths));
+    }
+  }
+  if (localityByPackage.size === 0) return;
+
+  // Top-level definitions of each named local package, by name.
+  const localPackages = [...localityByPackage].filter(([, l]) => l === 'local').map(([p]) => p);
+  const definitions = new Map<string, Map<string, SymbolDefinition[]>>();
+  if (localPackages.length > 0) {
+    const filesByPackage = localPackages.map((pkg) => ({ pkg, files: [] as ParsedFile[] }));
+    for (const parsed of parsedFiles) {
+      const owner = rPackageDirForFile(parsed.filePath, cfg)?.name;
+      for (const { pkg, files } of filesByPackage) {
+        // In the config a package owns its `R/` files (longest-dir wins); otherwise
+        // it is local only through the `<pkg>/R/` path, as `rQualifierLocality` decided.
+        const inPackage =
+          cfg?.packages.has(pkg) === true
+            ? owner === pkg
+            : isUnderPackageRDir(pkg, parsed.filePath, cfg);
+        if (inPackage) files.push(parsed);
+      }
+    }
+    for (const { pkg, files } of filesByPackage) {
+      definitions.set(pkg, collectTopLevelDefinitions(files));
+    }
+    if (cfg !== null) {
+      rRecordQualifiedDefinitionCounts(
+        cfg,
+        new Map(
+          [...definitions].map(([pkg, byName]) => [
+            pkg,
+            new Map([...byName].map(([name, defs]) => [name, defs.length])),
+          ]),
+        ),
+      );
+    }
+  }
+
+  // Decide each site.
+  for (let i = 0; i < parsedFiles.length; i++) {
+    const parsed = parsedFiles[i];
+    const kept: ReferenceSite[] = [];
+    for (const site of parsed.referenceSites) {
+      if (!isQualifiedCall(site)) {
+        kept.push(site);
+        continue;
+      }
+      const pkg = parseRQualifier(site.rawQualifiedName);
+      const locality = pkg === undefined ? 'unknown' : localityByPackage.get(pkg);
+      if (locality === 'external') continue;
+      if (locality === 'local' && pkg !== undefined) {
+        const found = definitions.get(pkg)?.get(site.name) ?? [];
+        if (found.length >= 2) continue;
+        if (found.length === 1) preciseBySite.set(siteKey(parsed.filePath, site.atRange), found[0]);
+      }
+      kept.push(site);
+    }
+    if (kept.length !== parsed.referenceSites.length) {
+      parsedFiles[i] = Object.freeze({ ...parsed, referenceSites: Object.freeze(kept) });
+    }
+  }
+}
+
+/**
+ * `ScopeResolver.resolveQualifiedFreeCall` for R: the definition
+ * {@link populateRQualifiedCalls} recorded for this call site, if any.
+ *
+ * The contract types `site` without its position; the runtime object is the
+ * `ReferenceSite`, which has `atRange`. That is read through a narrow cast
+ * here instead of widening the shared contract.
+ */
+export function resolveRQualifiedFreeCall(
+  site: object,
+  callerParsed: ParsedFile,
+): SymbolDefinition | undefined {
+  const atRange = (site as { readonly atRange?: { startLine: number; startCol: number } }).atRange;
+  return atRange === undefined
+    ? undefined
+    : preciseBySite.get(siteKey(callerParsed.filePath, atRange));
+}
diff --git a/gitnexus/src/core/ingestion/languages/r/query.ts b/gitnexus/src/core/ingestion/languages/r/query.ts
new file mode 100644
index 000000000..8aa2c337d
--- /dev/null
+++ b/gitnexus/src/core/ingestion/languages/r/query.ts
@@ -0,0 +1,348 @@
+/**
+ * Tree-sitter query for R scope captures (RFC #909 Ring 3).
+ *
+ * R has no dedicated class syntax — R6 classes are `R6Class(...)` calls, S4/R5
+ * classes are `setClass(...)`/`setRefClass(...)` calls — so this query mirrors
+ * the shapes the legacy `R_QUERIES` (`tree-sitter-queries.ts`) already proved
+ * queryable for structural extraction (the heritage shapes below have no
+ * counterpart there), renamed onto the scope-resolution capture vocabulary
+ * (`@scope.*`, `@declaration.*`, `@reference.*`, `@import.*`,
+ * `@type-binding.*`).
+ *
+ * R specifics encoded here:
+ *
+ *   - A Class scope spans the ENTIRE `R6Class(...)`/`setClass(...)` call
+ *     (the whole `binary_operator` for the `name <- R6Class(...)` shape),
+ *     not just `public = list(...)` — the `inherit=`/`contains=` argument
+ *     must fall inside the scope's range so the `@reference.inherits` sites
+ *     resolve against the deriving class's own scope.
+ *
+ *   - `@declaration.function`/`@declaration.class` anchor on the WHOLE
+ *     `name <- <rhs>` assignment (matching the legacy `@definition.*`
+ *     anchors exactly), so `resolveDefGraphId`'s position-based (Function)
+ *     and qualifiedName-keyed (Class) reconciliation lands on the SAME
+ *     graph node the legacy extractor already created.
+ *
+ *   - `@declaration.method` anchors on the `name = function(...)` ARGUMENT
+ *     inside `public =`/`private =`/`active =`/`methods = list(...)`.
+ *
+ *   - A def is owned by the innermost scope whose range EQUALS its anchor
+ *     range (`scope-extractor.ts` Pass 2), and `resolveCallerGraphId` walks
+ *     from a call site up to the first scope that owns a callable def. The
+ *     blanket `(function_definition) @scope.function` is strictly narrower
+ *     than the assignment/argument anchors, so on its own it never owns a
+ *     def: every named function/method would be owned by the module or
+ *     Class scope and every call in the file would be credited to the
+ *     FIRST callable in it. So each named-callable anchor also gets a
+ *     `@scope.function` on the SAME node, placed directly beside its
+ *     `@declaration.*` pattern below (the two must stay in lockstep — a
+ *     declaration anchor without a matching scope silently reverts that
+ *     shape to first-callable attribution). The def's own binding still
+ *     hoists to the PARENT scope (anchor range == scope range), so name
+ *     lookup is unchanged. The blanket rule is kept: it still covers
+ *     anonymous functions (`lapply(x, function(z) ...)`), which own nothing.
+ *     Calls in a Class body outside any method (an R6 field default, a
+ *     `setClass(validity = function...)` body) are credited to the Class.
+ *
+ *   - No `@declaration.qualified_name` is emitted for `@declaration.class`
+ *     — R's legacy extractor has no `classExtractor`, so a Class node's
+ *     `qualifiedName` today is the bare class-name text. Omitting the
+ *     capture lets `buildDefFromDeclarationMatch` default `qualifiedName`
+ *     to the bare name, matching the legacy node so `resolveDefGraphId`'s
+ *     name-keyed fallback finds it.
+ *
+ *   - S4/setGeneric/setMethod declarations are deliberately NOT captured
+ *     here — they are already produced by the legacy extractor via
+ *     R_QUERIES, independent of scope-resolution, and none of the target
+ *     scenarios needs a NEW declaration for them. Their inner
+ *     `function_definition` bodies still get a `@scope.function` from the
+ *     blanket rule below (an unnamed scope, harmless).
+ *
+ *   - `library()`/`require()` are wildcard imports (`@import.wildcard`) —
+ *     every top-level name of the named local package becomes visible,
+ *     unfiltered by NAMESPACE (see `rProvider.expandsWildcardTo`).
+ *     `source()` is a side-effect import (`@import.side-effect`) — it
+ *     establishes a file dependency but binds no name; cross-file free
+ *     calls into a `source()`d file resolve via `allowGlobalFreeCallFallback`
+ *     instead (`rScopeResolver`).
+ *
+ *   - `obj$method()` (the `extract_operator`, R's `$`) is a member call with
+ *     an explicit receiver — the same shape as Ruby's `obj.method`.
+ *     `Type$new(...)` is R6's constructor spelling: captured separately as
+ *     `@type-binding.constructor` so `x <- Type$new(...)` types `x`.
+ *
+ * Exposes lazy `Parser` and `Query` singletons so callers don't pay
+ * tree-sitter init cost per file.
+ */
+
+import Parser from 'tree-sitter';
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+import R from '@eagleoutice/tree-sitter-r';
+
+/**
+ * Exported for `value-ref-dispatchability.test.ts`-style whole-query readers.
+ * Not part of the provider surface — nothing else should import it.
+ */
+export const R_SCOPE_QUERY = `
+;; ── Scopes ───────────────────────────────────────────────────────────────
+
+(program) @scope.module
+
+(function_definition) @scope.function
+
+;; R6 class via namespace call (ClassName <- R6::R6Class(...)) — the scope
+;; spans the WHOLE assignment, including inherit=, so heritage sites resolve
+;; inside the deriving class's own scope.
+(binary_operator
+  lhs: (identifier)
+  rhs: (call
+    function: (namespace_operator
+      rhs: (identifier) @_r6ns_scope
+      (#match? @_r6ns_scope "^R6Class$")))) @scope.class
+
+;; R6 class via bare call (ClassName <- R6Class(...))
+(binary_operator
+  lhs: (identifier)
+  rhs: (call
+    function: (identifier) @_r6bare_scope
+    (#match? @_r6bare_scope "^R6Class$"))) @scope.class
+
+;; S4/R5 class (setClass(...) / setRefClass(...)) — scope spans the whole call.
+(call
+  function: (identifier) @_s4_scope
+  (#match? @_s4_scope "^(setClass|setRefClass)$")) @scope.class
+
+;; ── Declarations — functions ──────────────────────────────────────────────
+
+(binary_operator
+  lhs: (identifier) @declaration.name
+  rhs: (function_definition)) @declaration.function
+
+;; Function scope on the SAME assignment node as the declaration above, so the
+;; def is owned by its own scope (and calls inside the body attribute to it).
+;; This pattern and the \`@declaration.function\` pattern above must stay in
+;; lockstep — identical structure, identical anchor node (see file header).
+(binary_operator
+  lhs: (identifier)
+  rhs: (function_definition)) @scope.function
+
+;; ── Declarations — classes (name only; no qualified_name, see file header) ─
+;;
+;; The setClass/setRefClass declaration and the source/library/require imports
+;; below capture EVERY string (imports: identifier or string) argument of the call.
+;; \`emitRScopeCaptures\` keeps only the one that names the class or import
+;; (\`isRNonNamingScopeMatch\`): the argument spelled with the first formal, else the
+;; first unnamed one, so a leading comment or a named \`lib.loc =\` / \`local =\` does
+;; not change the answer. A query-level anchor cannot skip an unbounded run of
+;; leading comments and named arguments without a repeated sibling group, which
+;; is quadratic in the argument count on every call.
+
+(binary_operator
+  lhs: (identifier) @declaration.name
+  rhs: (call
+    function: (namespace_operator
+      rhs: (identifier) @_r6ns_decl
+      (#match? @_r6ns_decl "^R6Class$")))) @declaration.class
+
+(binary_operator
+  lhs: (identifier) @declaration.name
+  rhs: (call
+    function: (identifier) @_r6bare_decl
+    (#match? @_r6bare_decl "^R6Class$"))) @declaration.class
+
+(call
+  function: (identifier) @_s4_decl
+  (#match? @_s4_decl "^(setClass|setRefClass)$")
+  arguments: (arguments
+    (argument
+      value: (string
+        content: (string_content) @declaration.name)))) @declaration.class
+
+;; ── Declarations — R6/R5 methods ──────────────────────────────────────────
+
+;; R6 methods via namespace call (inside public/private/active = list(...))
+(binary_operator
+  lhs: (identifier) @_class1
+  rhs: (call
+    function: (namespace_operator
+      rhs: (identifier) @_r6ns_m
+      (#match? @_r6ns_m "^R6Class$"))
+    arguments: (arguments
+      (argument
+        name: (identifier) @_section1
+        (#match? @_section1 "^(public|private|active)$")
+        value: (call
+          function: (identifier) @_listfn1
+          (#match? @_listfn1 "^list$")
+          arguments: (arguments
+            (argument
+              name: (identifier) @declaration.name
+              value: (function_definition)) @declaration.method))))))
+
+;; R6 methods via bare call (inside public/private/active = list(...))
+(binary_operator
+  lhs: (identifier) @_class2
+  rhs: (call
+    function: (identifier) @_r6bare_m
+    (#match? @_r6bare_m "^R6Class$")
+    arguments: (arguments
+      (argument
+        name: (identifier) @_section2
+        (#match? @_section2 "^(public|private|active)$")
+        value: (call
+          function: (identifier) @_listfn2
+          (#match? @_listfn2 "^list$")
+          arguments: (arguments
+            (argument
+              name: (identifier) @declaration.name
+              value: (function_definition)) @declaration.method))))))
+
+;; R5 methods (inside setRefClass(... methods = list(...)))
+(binary_operator
+  lhs: (identifier) @_class3
+  rhs: (call
+    function: (identifier) @_refFn_m
+    (#match? @_refFn_m "^setRefClass$")
+    arguments: (arguments
+      (argument
+        name: (identifier) @_methods3
+        (#match? @_methods3 "^methods$")
+        value: (call
+          function: (identifier) @_listfn3
+          (#match? @_listfn3 "^list$")
+          arguments: (arguments
+            (argument
+              name: (identifier) @declaration.name
+              value: (function_definition)) @declaration.method))))))
+
+;; Function scope on the SAME \`name = function(...)\` argument node that the
+;; three \`@declaration.method\` patterns above anchor on, so each R6/R5 method
+;; def is owned by its own Function scope (a child of the Class scope) rather
+;; than by the Class scope. Deliberately generic — any named function-valued
+;; argument — so it cannot drift from the three long nesting patterns above; it
+;; is inert for non-method arguments (\`FUN = function...\`, \`error = function(e)\`
+;; own no defs, and calls inside them walk up to the enclosing callable). The
+;; declaration patterns above and this pattern must stay in lockstep.
+(argument
+  name: (identifier)
+  value: (function_definition)) @scope.function
+
+;; ── Imports ────────────────────────────────────────────────────────────────
+
+;; source("path.R") — side-effect: establishes a file dependency, binds no name.
+(call
+  function: (identifier) @_srcfn
+  (#match? @_srcfn "^source$")
+  arguments: (arguments
+    (argument
+      value: [(identifier) (string)] @import.source))) @import.side-effect
+
+;; library("pkg") / require("pkg") — wildcard: every top-level name of the
+;; named local package becomes visible (rProvider.expandsWildcardTo).
+(call
+  function: (identifier) @_libfn
+  (#match? @_libfn "^(library|require)$")
+  arguments: (arguments
+    (argument
+      value: [(identifier) (string)] @import.source))) @import.wildcard
+
+;; ── Type bindings — R6 constructor (x <- Type$new(...)) ───────────────────
+
+(binary_operator
+  lhs: (identifier) @type-binding.name
+  rhs: (call
+    function: (extract_operator
+      lhs: (identifier) @type-binding.type
+      rhs: (identifier) @_newfn
+      (#match? @_newfn "^new$")))) @type-binding.constructor
+
+;; ── References — heritage: R6 inherit= ────────────────────────────────────
+
+(binary_operator
+  lhs: (identifier)
+  rhs: (call
+    function: (namespace_operator
+      rhs: (identifier) @_r6ns_h
+      (#match? @_r6ns_h "^R6Class$"))
+    arguments: (arguments
+      (argument
+        name: (identifier) @_inh1
+        (#match? @_inh1 "^inherit$")
+        value: (identifier) @reference.inherits))))
+
+(binary_operator
+  lhs: (identifier)
+  rhs: (call
+    function: (identifier) @_r6bare_h
+    (#match? @_r6bare_h "^R6Class$")
+    arguments: (arguments
+      (argument
+        name: (identifier) @_inh2
+        (#match? @_inh2 "^inherit$")
+        value: (identifier) @reference.inherits))))
+
+;; ── References — heritage: S4 contains= (single parent, incl. "VIRTUAL") ──
+
+(call
+  function: (identifier) @_s4h1
+  (#match? @_s4h1 "^(setClass|setRefClass)$")
+  arguments: (arguments
+    (argument
+      name: (identifier) @_contains1
+      (#match? @_contains1 "^(contains|CONTAINS)$")
+      value: (string
+        content: (string_content) @reference.inherits))))
+
+;; ── References — heritage: S4 contains=c(...) (multiple parents) ──────────
+
+(call
+  function: (identifier) @_s4h2
+  (#match? @_s4h2 "^(setClass|setRefClass)$")
+  arguments: (arguments
+    (argument
+      name: (identifier) @_contains2
+      (#match? @_contains2 "^(contains|CONTAINS)$")
+      value: (call
+        function: (identifier) @_cfn2
+        (#match? @_cfn2 "^c$")
+        arguments: (arguments
+          (argument
+            value: (string
+              content: (string_content) @reference.inherits)))))))
+
+;; ── References — calls ────────────────────────────────────────────────────
+
+;; Free calls: foo(x)
+(call
+  function: (identifier) @reference.name) @reference.call.free
+
+;; Namespaced calls: pkg::func() and pkg:::func(). The whole namespace_operator
+;; is captured as the qualified name so the qualifier survives the parse cache.
+(call
+  function: (namespace_operator
+    rhs: (identifier) @reference.name) @reference.qualified-name) @reference.call.free
+
+;; Member calls via $: obj$method()
+(call
+  function: (extract_operator
+    lhs: (identifier) @reference.receiver
+    rhs: (identifier) @reference.name)) @reference.call.member
+`;
+
+let _parser: Parser | null = null;
+let _query: Parser.Query | null = null;
+
+export function getRParser(): Parser {
+  if (_parser === null) {
+    _parser = new Parser();
+    _parser.setLanguage(R as Parameters<Parser['setLanguage']>[0]);
+  }
+  return _parser;
+}
+
+export function getRScopeQuery(): Parser.Query {
+  if (_query === null) {
+    _query = new Parser.Query(R as Parameters<Parser['setLanguage']>[0], R_SCOPE_QUERY);
+  }
+  return _query;
+}
diff --git a/gitnexus/src/core/ingestion/languages/r/scope-resolver.ts b/gitnexus/src/core/ingestion/languages/r/scope-resolver.ts
new file mode 100644
index 000000000..98175fe1a
--- /dev/null
+++ b/gitnexus/src/core/ingestion/languages/r/scope-resolver.ts
@@ -0,0 +1,235 @@
+/**
+ * R `ScopeResolver` registered in `SCOPE_RESOLVERS` and consumed by the
+ * generic `runScopeResolution` orchestrator.
+ *
+ * Thin wiring: import resolution reuses `resolveRImportTarget`
+ * (`import-resolvers/r.ts`), an adapter over the existing
+ * `resolveRImportInternal`, with the repo's local R packages
+ * threaded through `loadRPackageConfig`. Heritage (R6 `inherit=`, S4
+ * `contains=`) mostly rides the generic `@reference.inherits` mechanism —
+ * R6/S4 base names are ordinary scope-bound class names, unlike Ruby's
+ * `include`/`extend`, which are method calls. The one exception is S4's
+ * `contains = "VIRTUAL"` sentinel (`setClass(x, contains = "VIRTUAL", ...)`,
+ * R's spelling for an abstract base): no fixture ever declares
+ * `setClass("VIRTUAL", ...)`, so the generic scope-based lookup
+ * (`resolveInheritanceBaseInScope` / `findClassBindingInScope`) can never
+ * find a binding for it — that lookup is scope-model-only and never
+ * consults graph nodes directly. `emitRVirtualHeritageEdges` below mints
+ * the placeholder `VIRTUAL` graph node and its EXTENDS edge directly,
+ * mirroring Ruby's `emitRubyMixinEdges` shape for the same reason: a
+ * heritage target that R code names but never declares.
+ */
+
+import type { ParsedFile, ScopeId, SymbolDefinition } from 'gitnexus-shared';
+import { SupportedLanguages } from 'gitnexus-shared';
+import { buildMro, defaultLinearize } from '../../scope-resolution/passes/mro.js';
+import {
+  findEnclosingClassDef,
+  populateClassOwnedMembers,
+} from '../../scope-resolution/scope/walkers.js';
+import type { ScopeResolver } from '../../scope-resolution/contract/scope-resolver.js';
+import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
+import { resolveDefGraphId } from '../../scope-resolution/graph-bridge/ids.js';
+import type { GraphNodeLookup } from '../../scope-resolution/graph-bridge/node-lookup.js';
+import type { KnowledgeGraph } from '../../../graph/types.js';
+import { generateId } from '../../../../lib/utils.js';
+import { loadRPackageConfig } from './package-config.js';
+import { resolveRImportTarget } from '../../import-resolvers/r.js';
+import {
+  isRGlobalNameFallbackPlausible,
+  populateRNamespaceImports,
+  rFileTopLevel,
+} from './namespace-imports.js';
+import { rProvider } from '../r.js';
+import { populateRQualifiedCalls, resolveRQualifiedFreeCall } from './qualified-call.js';
+import { rArityCompatibility, rMergeBindings } from './simple-hooks.js';
+
+/** Literal string `"VIRTUAL"` graph id — one node shared by every S4 class
+ *  that names it as a base, minted lazily on first use. */
+const VIRTUAL_CLASS_NAME = 'VIRTUAL';
+
+/**
+ * Mint the `VIRTUAL` placeholder Class node (once) and an EXTENDS edge from
+ * every S4 class whose `contains=` names it. Scope is deliberately limited to
+ * the literal string `"VIRTUAL"`: other S4 base-type sentinels (`"numeric"`,
+ * `"list"`, …) are not treated as placeholder classes, which would be a
+ * separate design decision.
+ *
+ * Idempotent: re-seeds its dedup set from any `EXTENDS` edge already
+ * targeting a node named `VIRTUAL` before emitting, and re-uses the graph's
+ * existing `VIRTUAL` node instead of minting a second one when the
+ * orchestrator re-runs resolution.
+ */
+function emitRVirtualHeritageEdges(
+  graph: KnowledgeGraph,
+  _parsedFiles: readonly ParsedFile[],
+  nodeLookup: GraphNodeLookup,
+  scopes?: ScopeResolutionIndexes,
+): void {
+  if (scopes === undefined) return;
+
+  const virtualGraphId = generateId('Class', VIRTUAL_CLASS_NAME);
+  const emitted = new Set<string>();
+  for (const rel of graph.iterRelationshipsByType('EXTENDS')) {
+    if (rel.targetId === virtualGraphId) emitted.add(rel.sourceId);
+  }
+
+  let virtualNodeMinted = graph.getNode(virtualGraphId) !== undefined;
+
+  for (const site of scopes.referenceSites) {
+    if (site.kind !== 'inherits' || site.name !== VIRTUAL_CLASS_NAME) continue;
+    const callerClass = findEnclosingClassDef(site.inScope, scopes);
+    if (callerClass === undefined) continue;
+    const callerGraphId = resolveDefGraphId(callerClass.filePath, callerClass, nodeLookup);
+    if (callerGraphId === undefined || emitted.has(callerGraphId)) continue;
+
+    if (!virtualNodeMinted) {
+      graph.addNode({
+        id: virtualGraphId,
+        label: 'Class',
+        properties: { name: VIRTUAL_CLASS_NAME, filePath: callerClass.filePath },
+      });
+      virtualNodeMinted = true;
+    }
+    emitted.add(callerGraphId);
+    graph.addRelationship({
+      id: generateId('EXTENDS', `${callerGraphId}->${virtualGraphId}`),
+      sourceId: callerGraphId,
+      targetId: virtualGraphId,
+      type: 'EXTENDS',
+      confidence: 0.85,
+      reason: 'scope-resolution: inherits (virtual)',
+    });
+  }
+}
+
+/**
+ * Enumerate all top-level names exported from a target module scope's file.
+ * `library()`/`require()` are R's wildcard imports — every top-level name of
+ * the named local package becomes visible, UNFILTERED by NAMESPACE (a
+ * `library()`/`require()` call brings the whole package's namespace into
+ * scope regardless of what NAMESPACE declares as exported — confirmed by a
+ * fixture where `pkgA/NAMESPACE` does not export `ResultSet`, yet
+ * `require("pkgA")` must still resolve it).
+ *
+ * A bare name is dropped when the same file also defines a dotted top-level
+ * name with that tail (`foo` next to `print.foo`). The shared finalize indexes
+ * every def by the text after its last `.`, so `foo` would be bound to
+ * whichever of the two comes first in the file, and `print.foo` (an S3 method,
+ * never callable as `foo()`) can win. The dropped name resolves through the
+ * free-call fallback instead, where {@link rIsCallableVisibleFromCaller}
+ * removes the dotted def from the candidates. Order-blind, like the matching
+ * guard in `import-resolvers/r.ts`.
+ */
+export function expandRWildcardNames(
+  targetModuleScope: ScopeId,
+  parsedFiles: readonly ParsedFile[],
+): readonly string[] {
+  const target = parsedFiles.find((p) => p.moduleScope === targetModuleScope);
+  if (target === undefined) return [];
+  const { dottedTails } = rFileTopLevel(target);
+  const seen = new Set<string>();
+  const names: string[] = [];
+  for (const def of target.localDefs) {
+    const qn = def.qualifiedName;
+    if (qn === undefined || qn.length === 0 || qn.includes('.')) continue; // top-level only
+    if (dottedTails.has(qn)) continue; // shares its tail with an S3 method: see above
+    if (seen.has(qn)) continue;
+    seen.add(qn);
+    names.push(qn);
+  }
+  return names;
+}
+
+/**
+ * A bare R call `foo(x)` can never invoke a def whose name contains a `.`
+ * (`print.foo` is only reachable as `print.foo(...)` or through S3 dispatch),
+ * yet the free-call fallback's simple-name index keys it under `foo`. Refuse
+ * such candidates so `foo(x)` cannot collide with `print.foo`.
+ *
+ * Applies to every candidate the hook sees, including R6/R5 members whose
+ * qualified name is `Class.member`: a bare `member(x)` never reaches those
+ * either.
+ */
+export function rIsCallableVisibleFromCaller(ctx: {
+  readonly candidate: SymbolDefinition;
+}): boolean {
+  return !(ctx.candidate.qualifiedName ?? '').includes('.');
+}
+
+export const rScopeResolver: ScopeResolver = {
+  language: SupportedLanguages.R,
+  languageProvider: rProvider,
+  importEdgeReason: 'r-scope: import',
+
+  loadResolutionConfig: (repoPath: string) => loadRPackageConfig(repoPath),
+
+  resolveImportTarget: resolveRImportTarget,
+
+  expandsWildcardTo: (targetModuleScope, parsedFiles) =>
+    expandRWildcardNames(targetModuleScope, parsedFiles),
+
+  mergeBindings: rMergeBindings,
+  arityCompatibility: rArityCompatibility,
+
+  buildMro: (graph, parsedFiles, nodeLookup) =>
+    buildMro(graph, parsedFiles, nodeLookup, defaultLinearize),
+
+  populateOwners: (parsed: ParsedFile) => populateClassOwnedMembers(parsed),
+
+  emitHeritageEdges: (graph, parsedFiles, nodeLookup, scopes) =>
+    emitRVirtualHeritageEdges(graph, parsedFiles, nodeLookup, scopes),
+
+  // R has no `super`.
+  isSuperReceiver: () => false,
+
+  // R's dynamic-dispatch `self$field$method()` chains and R6/S4 field access
+  // benefit from the same heuristic Ruby/Python rely on.
+  fieldFallbackOnMethodLookup: true,
+
+  // `source()` is a side-effect import (binds no name) — a cross-file free
+  // call into a `source()`d file (e.g. `HelperFunc(x)`) has no lexical or
+  // import binding to resolve through, so it resolves via a unique
+  // workspace-wide name match instead. `library()`/`require()`'s own
+  // wildcard-bound names still resolve through `expandsWildcardTo` above;
+  // this only covers what that path cannot reach.
+  allowGlobalFreeCallFallback: true,
+
+  // A named import binds only to a MODULE-LEVEL definition of the target
+  // file. Without this, `findExportByName` indexes every `localDefs` entry by
+  // simple name, so an R6/R5 method named like an imported symbol could win
+  // the binding over the top-level function.
+  namedImportsBindTopLevelOnly: true,
+
+  // NAMESPACE `importFrom()` names provided by a LOCAL package become
+  // synthesised `named` imports (`resolveRImportTarget`'s named branch binds
+  // them). Runs before finalize and over warm-cache ParsedFiles too.
+  //
+  // Followed by `populateRQualifiedCalls`: it decides each
+  // `pkg::name()` site by the qualifier — drops external / ambiguous ones and
+  // records the single definition a local one names for
+  // `resolveQualifiedFreeCall` below. Import synthesis is unchanged and first.
+  populateWorkspaceReferences: (parsedFiles, ctx) => {
+    populateRNamespaceImports(parsedFiles, ctx);
+    populateRQualifiedCalls(parsedFiles, ctx);
+  },
+  resolveQualifiedFreeCall: resolveRQualifiedFreeCall,
+
+  // `populateRNamespaceImports` and `populateRQualifiedCalls` read only ParsedFile scopes, never source
+  // text: without this, merely declaring the hook makes the pipeline read the
+  // text of every R file on the main thread.
+  postExtractSourceTextPolicy: 'uncached-files',
+
+  // A bare call whose name the caller package's NAMESPACE imports from a
+  // package other than the one the unique-name guess landed in is impossible
+  // in R (see `isRGlobalNameFallbackPlausible` for the exact rule, the
+  // qualifier-first handling of `pkg::name()` calls and the documented
+  // `import()` limitation).
+  isGlobalNameFallbackPlausible: isRGlobalNameFallbackPlausible,
+
+  // The free-call fallback keys defs by the text after the last `.` of their
+  // qualified name, so an S3 method `print.foo` sits next to a bare `foo` and
+  // makes the bare call ambiguous (no edge). A bare call can never invoke a
+  // dotted def, so drop those candidates.
+  isCallableVisibleFromCaller: rIsCallableVisibleFromCaller,
+};
diff --git a/gitnexus/src/core/ingestion/languages/r/simple-hooks.ts b/gitnexus/src/core/ingestion/languages/r/simple-hooks.ts
new file mode 100644
index 000000000..bc81c30da
--- /dev/null
+++ b/gitnexus/src/core/ingestion/languages/r/simple-hooks.ts
@@ -0,0 +1,49 @@
+import type { BindingRef, Callsite, SymbolDefinition } from 'gitnexus-shared';
+
+const TIER: Record<BindingRef['origin'], number> = {
+  local: 0,
+  namespace: 1,
+  import: 2,
+  reexport: 3,
+  wildcard: 4,
+};
+
+/** Local declarations shadow imports; deterministic order within a tier.
+ *  Same shape as Zig's `zigMergeBindings` — R has no per-scope binding
+ *  precedence rule beyond "the tightest-origin binding wins". */
+export function rMergeBindings(
+  existing: readonly BindingRef[],
+  incoming: readonly BindingRef[],
+  _scopeId: string,
+): BindingRef[] {
+  const all = [...existing, ...incoming];
+  if (all.length === 0) return [];
+  let bestTier = 99;
+  for (const b of all) {
+    const t = TIER[b.origin] ?? 99;
+    if (t < bestTier) bestTier = t;
+  }
+  const byNode = new Map<string, BindingRef>();
+  for (const b of all) {
+    if ((TIER[b.origin] ?? 99) !== bestTier) continue;
+    if (!byNode.has(b.def.nodeId)) byNode.set(b.def.nodeId, b);
+  }
+  return [...byNode.values()].sort((a, b) => a.def.nodeId.localeCompare(b.def.nodeId));
+}
+
+/** R declarations carry no synthesized arity metadata (no `...`/default-arg
+ *  capture exists yet), so the comparison is always 'unknown' — a real bounds
+ *  check that turns on if arity captures are added later. Same rationale as
+ *  Zig's `zigArityCompatibility`. */
+export function rArityCompatibility(
+  callsite: Callsite,
+  def: SymbolDefinition,
+): 'compatible' | 'unknown' | 'incompatible' {
+  const max = def.parameterCount;
+  const min = def.requiredParameterCount;
+  if (max === undefined && min === undefined) return 'unknown';
+  if (!Number.isFinite(callsite.arity) || callsite.arity! < 0) return 'unknown';
+  if (min !== undefined && callsite.arity! < min) return 'incompatible';
+  if (max !== undefined && callsite.arity! > max) return 'incompatible';
+  return 'compatible';
+}
diff --git a/gitnexus/src/core/ingestion/method-extractors/r.ts b/gitnexus/src/core/ingestion/method-extractors/r.ts
new file mode 100644
index 000000000..30746779a
--- /dev/null
+++ b/gitnexus/src/core/ingestion/method-extractors/r.ts
@@ -0,0 +1,250 @@
+// gitnexus/src/core/ingestion/method-extractors/r.ts
+
+/**
+ * R method extractor — hand-written because R expresses classes and methods
+ * as function calls rather than dedicated syntax.
+ *
+ * Handles:
+ * - R6 methods: function entries in public/private/active list()
+ * - S4 setMethod(): owner hints for method implementations dispatched on signature
+ * - R5/setRefClass methods: methods = list(name = function(...) {...})
+ */
+
+import type { SyntaxNode } from '../utils/ast-helpers.js';
+import { SupportedLanguages } from 'gitnexus-shared';
+import { getRMatchedArgument } from '../languages/r/naming-argument.js';
+import { getRClassNameArgument } from '../field-extractors/r.js';
+import type {
+  MethodExtractor,
+  MethodExtractorContext,
+  ExtractedMethods,
+  MethodInfo,
+  MethodVisibility,
+  ParameterInfo,
+} from '../method-types.js';
+
+/** `setMethod`'s formals, in order (methods package). */
+const SET_METHOD_FORMALS: readonly string[] = [
+  'f',
+  'signature',
+  'definition',
+  'where',
+  'valueClass',
+  'sealed',
+];
+
+export const rMethodExtractor: MethodExtractor = {
+  language: SupportedLanguages.R,
+
+  isTypeDeclaration(node: SyntaxNode): boolean {
+    return isR6Class(node) || isRefClass(node);
+  },
+
+  extract(node: SyntaxNode, context: MethodExtractorContext): ExtractedMethods | null {
+    if (isR6Class(node)) return extractR6Methods(node, context);
+    if (isRefClass(node)) return extractRefClassMethods(node, context);
+    return null;
+  },
+};
+
+/** Resolve the owning class name for a top-level R setMethod("foo", "Bar", ...) definition. */
+export function getRTopLevelMethodOwnerName(node: SyntaxNode): string | null {
+  if (!isS4SetMethod(node)) return null;
+  const args = node.childForFieldName('arguments');
+  if (!args) return null;
+
+  // The owner is the `signature` argument, as R matches it (named first, then by position).
+  const signature = getRMatchedArgument(args, SET_METHOD_FORMALS, 'signature');
+  return extractQuotedString(signature?.childForFieldName('value') ?? null);
+}
+
+// ---------------------------------------------------------------------------
+// R6 method extraction
+// ---------------------------------------------------------------------------
+
+function extractR6Methods(
+  node: SyntaxNode,
+  context: MethodExtractorContext,
+): ExtractedMethods | null {
+  const ownerName = node.childForFieldName('lhs')?.text;
+  if (!ownerName) return null;
+
+  const call = node.childForFieldName('rhs');
+  if (!call) return null;
+
+  const args = call.childForFieldName('arguments');
+  if (!args) return null;
+
+  const methods: MethodInfo[] = [];
+
+  for (let i = 0; i < args.namedChildCount; i++) {
+    const arg = args.namedChild(i);
+    if (!arg || arg.type !== 'argument') continue;
+
+    const section = arg.childForFieldName('name')?.text;
+    if (section !== 'public' && section !== 'private' && section !== 'active') continue;
+
+    const visibility: MethodVisibility = section === 'private' ? 'private' : 'public';
+
+    const listCall = arg.childForFieldName('value');
+    if (!listCall || listCall.type !== 'call') continue;
+
+    const listArgs = listCall.childForFieldName('arguments');
+    if (!listArgs) continue;
+
+    for (let j = 0; j < listArgs.namedChildCount; j++) {
+      const entry = listArgs.namedChild(j);
+      if (!entry || entry.type !== 'argument') continue;
+
+      const nameNode = entry.childForFieldName('name');
+      const valueNode = entry.childForFieldName('value');
+      if (!nameNode || valueNode?.type !== 'function_definition') continue;
+
+      methods.push({
+        name: nameNode.text,
+        receiverType: null,
+        returnType: null,
+        parameters: extractRParameters(valueNode),
+        visibility,
+        isStatic: false,
+        isAbstract: false,
+        isFinal: false,
+        annotations: section === 'active' ? ['@active'] : [],
+        sourceFile: context.filePath,
+        line: entry.startPosition.row + 1,
+        column: entry.startPosition.column,
+      });
+    }
+  }
+
+  return methods.length > 0 ? { ownerName, methods } : null;
+}
+
+// ---------------------------------------------------------------------------
+// S4 / R5 (setRefClass) method extraction
+// ---------------------------------------------------------------------------
+
+function extractRefClassMethods(
+  node: SyntaxNode,
+  context: MethodExtractorContext,
+): ExtractedMethods | null {
+  const args = node.childForFieldName('arguments');
+  if (!args) return null;
+
+  // The class name is the argument that takes the `Class` formal (by name, else the
+  // first unnamed one), not the first string: `contains = "Base"` may precede it.
+  const ownerName = getRClassNameArgument(args);
+  if (!ownerName) return null;
+
+  const methods: MethodInfo[] = [];
+
+  // setRefClass(... methods = list(name = function(...) { ... }))
+  for (let i = 0; i < args.namedChildCount; i++) {
+    const arg = args.namedChild(i);
+    if (!arg || arg.type !== 'argument') continue;
+
+    const paramName = arg.childForFieldName('name')?.text;
+    if (paramName !== 'methods') continue;
+
+    const listCall = arg.childForFieldName('value');
+    if (!listCall || listCall.type !== 'call') continue;
+
+    const listArgs = listCall.childForFieldName('arguments');
+    if (!listArgs) continue;
+
+    for (let j = 0; j < listArgs.namedChildCount; j++) {
+      const entry = listArgs.namedChild(j);
+      if (!entry || entry.type !== 'argument') continue;
+
+      const nameNode = entry.childForFieldName('name');
+      const valueNode = entry.childForFieldName('value');
+      if (!nameNode || valueNode?.type !== 'function_definition') continue;
+
+      methods.push({
+        name: nameNode.text,
+        receiverType: null,
+        returnType: null,
+        parameters: extractRParameters(valueNode),
+        visibility: 'public',
+        isStatic: false,
+        isAbstract: false,
+        isFinal: false,
+        annotations: [],
+        sourceFile: context.filePath,
+        line: entry.startPosition.row + 1,
+        column: entry.startPosition.column,
+      });
+    }
+  }
+
+  return methods.length > 0 ? { ownerName, methods } : null;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function isR6Class(node: SyntaxNode): boolean {
+  if (node.type !== 'binary_operator') return false;
+  const rhs = node.childForFieldName('rhs');
+  if (!rhs || rhs.type !== 'call') return false;
+  const fn = rhs.childForFieldName('function');
+  if (!fn) return false;
+  if (fn.type === 'identifier' && fn.text === 'R6Class') return true;
+  if (fn.type === 'namespace_operator') {
+    return fn.childForFieldName('rhs')?.text === 'R6Class';
+  }
+  return false;
+}
+
+function isRefClass(node: SyntaxNode): boolean {
+  if (node.type !== 'call') return false;
+  const fn = node.childForFieldName('function');
+  return fn?.type === 'identifier' && fn.text === 'setRefClass';
+}
+
+function isS4SetMethod(node: SyntaxNode): boolean {
+  if (node.type !== 'call') return false;
+  const fn = node.childForFieldName('function');
+  return fn?.type === 'identifier' && fn.text === 'setMethod';
+}
+
+function extractQuotedString(node: SyntaxNode | null): string | null {
+  if (!node || node.type !== 'string') return null;
+  const content = node.namedChildren.find((c) => c.type === 'string_content');
+  return content?.text ?? node.text.replace(/^["']|["']$/g, '');
+}
+
+/** Extract parameter names from an R function_definition node. */
+function extractRParameters(fnNode: SyntaxNode): ParameterInfo[] {
+  const params: ParameterInfo[] = [];
+  const paramList = fnNode.childForFieldName('parameters');
+  if (!paramList) return params;
+
+  for (let i = 0; i < paramList.namedChildCount; i++) {
+    const param = paramList.namedChild(i);
+    if (!param) continue;
+
+    if (param.type === 'identifier') {
+      params.push({
+        name: param.text,
+        type: null,
+        isOptional: false,
+        isVariadic: param.text === '...',
+      });
+    } else if (param.type === 'argument') {
+      // Named argument with default value -> optional parameter
+      const nameNode = param.childForFieldName('name');
+      if (nameNode) {
+        params.push({
+          name: nameNode.text,
+          type: null,
+          isOptional: true,
+          isVariadic: false,
+        });
+      }
+    }
+  }
+
+  return params;
+}
diff --git a/gitnexus/src/core/ingestion/pipeline-phases/parse-impl.ts b/gitnexus/src/core/ingestion/pipeline-phases/parse-impl.ts
index cc72a04d5..07e773c98 100644
--- a/gitnexus/src/core/ingestion/pipeline-phases/parse-impl.ts
+++ b/gitnexus/src/core/ingestion/pipeline-phases/parse-impl.ts
@@ -105,7 +105,7 @@ import {
 import { normalizeExtractedRoutePath } from '../route-extractors/route-path.js';
 import { resolveOperands } from '../route-extractors/python-const-resolver.js';
 import type { ModuleConstants } from '../route-extractors/constant-resolver.js';
-import { prepareRouteConstantsByProvider } from '../language-provider.js';
+import { prepareRouteConstantsByProvider, runPostParseHooks } from '../language-provider.js';
 import {
   resolveInheritedSpringRoutes,
   type SharedSpringType,
@@ -1548,6 +1548,15 @@ export async function runChunkedParseAndResolve(
     }
   }
 
+  // Language post-parse hooks: whole-graph work a language can only do once every chunk is merged
+  // and before scope resolution (e.g. deferred owner resolution). Only languages with parsed files pay.
+  const presentLanguages = new Set<SupportedLanguages>();
+  for (const file of parseableScanned) {
+    const language = languageForScannedFile(file);
+    if (language !== null) presentLanguages.add(language);
+  }
+  await runPostParseHooks(presentLanguages, getProvider, { graph, model, repoPath });
+
   // Worker-path enrichment: if exportedTypeMap is empty (e.g. the worker pool
   // built TypeEnv inside workers without access to SymbolTable), reconstruct
   // the map from graph nodes + SymbolTable here in the main thread before
diff --git a/gitnexus/src/core/ingestion/scope-resolution/pipeline/registry.ts b/gitnexus/src/core/ingestion/scope-resolution/pipeline/registry.ts
index ee98e3807..82f7c681c 100644
--- a/gitnexus/src/core/ingestion/scope-resolution/pipeline/registry.ts
+++ b/gitnexus/src/core/ingestion/scope-resolution/pipeline/registry.ts
@@ -29,6 +29,7 @@ import { dartScopeResolver } from '../../languages/dart/scope-resolver.js';
 import { vueScopeResolver } from '../../languages/vue/scope-resolver.js';
 import { zigScopeResolver } from '../../languages/zig/scope-resolver.js';
 import { objectiveCScopeResolver } from '../../languages/objective-c/scope-resolver.js';
+import { rScopeResolver } from '../../languages/r/scope-resolver.js';
 
 /** Map of `SupportedLanguages` → `ScopeResolver`. The scope-resolution phase
  *  iterates this map directly — every registered resolver runs. This is the
@@ -55,4 +56,5 @@ export const SCOPE_RESOLVERS: ReadonlyMap<SupportedLanguages, ScopeResolver> = n
   [SupportedLanguages.Vue, vueScopeResolver],
   [SupportedLanguages.Zig, zigScopeResolver],
   [SupportedLanguages.ObjectiveC, objectiveCScopeResolver],
+  [SupportedLanguages.R, rScopeResolver],
 ]);
diff --git a/gitnexus/src/core/ingestion/tree-sitter-queries.ts b/gitnexus/src/core/ingestion/tree-sitter-queries.ts
index efc733844..c5b2c6134 100644
--- a/gitnexus/src/core/ingestion/tree-sitter-queries.ts
+++ b/gitnexus/src/core/ingestion/tree-sitter-queries.ts
@@ -3051,6 +3051,189 @@ export const ZIG_QUERIES = `
   function: (field_expression
     member: (identifier) @call.name)) @call
 `;
+export const R_QUERIES = `
+; ── Functions (name <- function(...) or name = function(...)) ────────────────
+(binary_operator
+  lhs: (identifier) @name
+  rhs: (function_definition)) @definition.function
+
+; ── S4 Classes (setClass("ClassName", ...)) ──────────────────────────────────
+; The S4 patterns below capture EVERY string argument of the call on purpose.
+; Which argument names the definition is decided by the provider's
+; \`shouldSkipDefinitionCapture\` (languages/r/naming-argument.ts): a query cannot skip an
+; unbounded run of leading comments and named arguments without a repeated
+; sibling group, which is quadratic in the argument count.
+(call
+  function: (identifier) @_fn
+  (#match? @_fn "^(setClass|setRefClass)$")
+  arguments: (arguments
+    (argument
+      value: (string
+        content: (string_content) @name)))) @definition.class
+
+; ── R6 Classes via namespace (ClassName <- R6::R6Class(...)) ─────────────────
+(binary_operator
+  lhs: (identifier) @name
+  rhs: (call
+    function: (namespace_operator
+      rhs: (identifier) @_nsfn
+      (#match? @_nsfn "^R6Class$")))) @definition.class
+
+; ── R6 Classes via bare call (ClassName <- R6Class(...)) ─────────────────────
+(binary_operator
+  lhs: (identifier) @name
+  rhs: (call
+    function: (identifier) @_r6fn
+    (#match? @_r6fn "^R6Class$"))) @definition.class
+
+; ── R6 Methods via namespace (inside public/private/active = list(...)) ─────
+(binary_operator
+  lhs: (identifier) @_class
+  rhs: (call
+    function: (namespace_operator
+      rhs: (identifier) @_nsfn2
+      (#match? @_nsfn2 "^R6Class$"))
+    arguments: (arguments
+      (argument
+        name: (identifier) @_section
+        (#match? @_section "^(public|private|active)$")
+        value: (call
+          function: (identifier) @_listfn
+          (#match? @_listfn "^list$")
+          arguments: (arguments
+            (argument
+              name: (identifier) @name
+              value: (function_definition)) @definition.method))))))
+
+; ── R6 Methods via bare call (inside public/private/active = list(...)) ─────
+(binary_operator
+  lhs: (identifier) @_class2
+  rhs: (call
+    function: (identifier) @_r6fn2
+    (#match? @_r6fn2 "^R6Class$")
+    arguments: (arguments
+      (argument
+        name: (identifier) @_section2
+        (#match? @_section2 "^(public|private|active)$")
+        value: (call
+          function: (identifier) @_listfn2
+          (#match? @_listfn2 "^list$")
+          arguments: (arguments
+            (argument
+              name: (identifier) @name
+              value: (function_definition)) @definition.method))))))
+
+; ── R5 Methods (inside setRefClass(... methods = list(...))) ─────────────────
+(binary_operator
+  lhs: (identifier) @_class3
+  rhs: (call
+    function: (identifier) @_refFn
+    (#match? @_refFn "^setRefClass$")
+    arguments: (arguments
+      (argument
+        name: (identifier) @_methods
+        (#match? @_methods "^methods$")
+        value: (call
+          function: (identifier) @_listfn3
+          (#match? @_listfn3 "^list$")
+          arguments: (arguments
+            (argument
+              name: (identifier) @name
+              value: (function_definition)) @definition.method))))))
+
+; ── S4 setGeneric() (generic function declaration) ───────────────────────────
+(call
+  function: (identifier) @_fn
+  (#match? @_fn "^setGeneric$")
+  arguments: (arguments
+    (argument
+      value: (string
+        content: (string_content) @name)))) @definition.function
+
+; ── S4 setMethod() (method implementation for a class) ──────────────────────
+(call
+  function: (identifier) @_fn
+  (#match? @_fn "^setMethod$")
+  arguments: (arguments
+    (argument
+      value: (string
+        content: (string_content) @name)))) @definition.method
+
+; ── All function calls ───────────────────────────────────────────────────────
+(call
+  function: (identifier) @call.name) @call
+
+; ── Namespaced calls (pkg::func()) ───────────────────────────────────────────
+(call
+  function: (namespace_operator
+    lhs: (identifier) @call.namespace
+    rhs: (identifier) @call.name)) @call
+
+; ── Member calls via $ (obj$method()) ───────────────────────────────────────
+(call
+  function: (extract_operator
+    rhs: (identifier) @call.name)) @call
+
+; ── Imports (library/require/source) ─────────────────────────────────────────
+(call
+  function: (identifier) @_fn
+  (#match? @_fn "^(library|require|source)$")
+  arguments: (arguments
+    (argument
+      value: [(identifier) (string)] @import.source))) @import
+
+; ── R6 Fields via namespace (non-function entries in public/private list()) ──
+(binary_operator
+  lhs: (identifier) @_class
+  rhs: (call
+    function: (namespace_operator
+      rhs: (identifier) @_nsfn
+      (#match? @_nsfn "^R6Class$"))
+    arguments: (arguments
+      (argument
+        name: (identifier) @_section
+        (#match? @_section "^(public|private)$")
+        value: (call
+          function: (identifier) @_listfn
+          (#match? @_listfn "^list$")
+          arguments: (arguments
+            (argument
+              name: (identifier) @name
+              value: [(string) (integer) (float) (true) (false) (null) (identifier) (call) (unary_operator) (binary_operator)] @_val) @definition.property))))))
+
+; ── R6 Fields via bare call ──────────────────────────────────────────────────
+(binary_operator
+  lhs: (identifier) @_class2
+  rhs: (call
+    function: (identifier) @_r6fn
+    (#match? @_r6fn "^R6Class$")
+    arguments: (arguments
+      (argument
+        name: (identifier) @_section2
+        (#match? @_section2 "^(public|private)$")
+        value: (call
+          function: (identifier) @_listfn2
+          (#match? @_listfn2 "^list$")
+          arguments: (arguments
+            (argument
+              name: (identifier) @name
+              value: [(string) (integer) (float) (true) (false) (null) (identifier) (call) (unary_operator) (binary_operator)] @_val2) @definition.property))))))
+
+; ── S4 slots / representation ────────────────────────────────────────────────
+(call
+  function: (identifier) @_fn
+  (#match? @_fn "^(setClass|setRefClass)$")
+  arguments: (arguments
+    (argument
+      name: (identifier) @_slotArg
+      (#match? @_slotArg "^(representation|slots|fields)$")
+      value: (call
+        function: (identifier) @_listfn
+        (#match? @_listfn "^(list|representation)$")
+        arguments: (arguments
+          (argument
+            name: (identifier) @name) @definition.property)))))
+`;
 
 import { SupportedLanguages } from 'gitnexus-shared';
 
@@ -3073,6 +3256,7 @@ export const LANGUAGE_QUERIES: Record<SupportedLanguages, string> = {
   [SupportedLanguages.Swift]: SWIFT_QUERIES,
   [SupportedLanguages.Dart]: DART_QUERIES,
   [SupportedLanguages.Vue]: TYPESCRIPT_QUERIES, // Vue <script> blocks are parsed as TypeScript
+  [SupportedLanguages.R]: R_QUERIES,
   [SupportedLanguages.Cobol]: '', // Standalone regex processor — no tree-sitter queries
   [SupportedLanguages.Zig]: ZIG_QUERIES,
 };
diff --git a/gitnexus/src/core/ingestion/type-extractors/r.ts b/gitnexus/src/core/ingestion/type-extractors/r.ts
new file mode 100644
index 000000000..b87e4d03e
--- /dev/null
+++ b/gitnexus/src/core/ingestion/type-extractors/r.ts
@@ -0,0 +1,270 @@
+import type {
+  LanguageTypeConfig,
+  ParameterExtractor,
+  TypeBindingExtractor,
+  InitializerExtractor,
+  ConstructorBindingScanner,
+} from './types.js';
+import type { SyntaxNode } from '../utils/ast-helpers.js';
+import { getRClassNameArgument } from '../field-extractors/r.js';
+
+/**
+ * R type extractor — roxygen2 annotation parsing.
+ *
+ * R has no static type system and roxygen2 has no type syntax: a `@param`
+ * description is free prose. A parameter is therefore typed from a roxygen
+ * comment only when the type is stated in an anchored form AND names a class
+ * the file defines:
+ *
+ *   #' @param repo UserRepo                 (the description is the type alone)
+ *   #' @param backup {UserRepo} a spare     (the type in braces, prose after it)
+ *   save <- function(repo, backup) { ... }
+ *
+ * Prose that merely starts with a capitalised word (`@param df Data frame of
+ * observations`) binds nothing, even when a class called `Data` exists, and a
+ * description may run over several lines: it is read up to the next tag.
+ * The type is bound for a formal of the documented function, inside that
+ * function only.
+ *
+ * Resolution tiers:
+ * - Tier 0: roxygen2 @param annotations (extractParameter binds each documented formal)
+ * - Tier 1: Constructor inference via `obj <- ClassName$new()` (R6) or `obj <- new("ClassName")` (S4)
+ */
+
+/** A `@param` tag: the parameter name and the description text that follows it. */
+interface RoxygenParam {
+  readonly name: string;
+  readonly description: string;
+}
+
+/** The whole description is a single type word: `UserRepo`. */
+const BARE_TYPE_RE = /^([A-Z][\w.]*)$/;
+
+/** The description starts with a braced type: `{UserRepo} the repository`. */
+const BRACED_TYPE_RE = /^\{([A-Z][\w.]*)\}(?:\s|$)/;
+
+/**
+ * Walk backwards through preceding sibling nodes collecting consecutive
+ * roxygen2 comment lines (`#'`). Returns the joined comment block text.
+ */
+const collectRoxygenBlock = (node: SyntaxNode): string => {
+  const commentTexts: string[] = [];
+  let sibling = node.previousSibling;
+  while (sibling) {
+    if (sibling.type === 'comment' && sibling.text.startsWith("#'")) {
+      commentTexts.unshift(sibling.text);
+    } else if (sibling.type === 'comment') {
+      // Regular comment (not roxygen2) — skip, don't break
+    } else if (sibling.isNamed) {
+      break;
+    }
+    sibling = sibling.previousSibling;
+  }
+  return commentTexts.join('\n');
+};
+
+/**
+ * Split a roxygen block into its `@param` tags. A tag's description is the
+ * rest of its line plus every following line up to the next `@tag`, joined by
+ * single spaces. A tag whose name is not one plain identifier (`x,y`, `...`,
+ * `na.rm`) is skipped, and its continuation lines belong to no tag.
+ */
+const parseRoxygenParams = (block: string): RoxygenParam[] => {
+  const params: RoxygenParam[] = [];
+  let name: string | undefined;
+  let parts: string[] = [];
+  const flush = (): void => {
+    if (name !== undefined) params.push({ name, description: parts.join(' ').trim() });
+    name = undefined;
+    parts = [];
+  };
+
+  for (const rawLine of block.split('\n')) {
+    const line = rawLine.replace(/^#'[ \t]*/, '').trim();
+    const tag = /^@(\w+)(?:[ \t]+(.*))?$/.exec(line);
+    if (tag) {
+      flush();
+      if (tag[1] !== 'param') continue;
+      const head = /^(\w+)(?:[ \t]+(.*))?$/.exec(tag[2] ?? '');
+      if (!head) continue;
+      name = head[1];
+      if (head[2]) parts.push(head[2]);
+    } else if (name !== undefined && line.length > 0) {
+      parts.push(line);
+    }
+  }
+  flush();
+  return params;
+};
+
+/** The type a `@param` description states in an anchored form, if any. */
+const anchoredType = (description: string): string | undefined =>
+  (BARE_TYPE_RE.exec(description) ?? BRACED_TYPE_RE.exec(description))?.[1];
+
+/**
+ * The class a node declares, in the shapes `query.ts` captures as
+ * `@declaration.class`: `X <- R6Class(...)` / `X <- R6::R6Class(...)`, and
+ * `setClass("X", ...)` / `setRefClass("X", ...)`.
+ */
+const declaredClassName = (node: SyntaxNode): string | undefined => {
+  if (node.type === 'binary_operator') {
+    const lhs = node.childForFieldName('lhs');
+    const rhs = node.childForFieldName('rhs');
+    if (lhs?.type !== 'identifier' || rhs?.type !== 'call') return undefined;
+    const fn = rhs.childForFieldName('function');
+    const calleeName =
+      fn?.type === 'namespace_operator' ? fn.childForFieldName('rhs')?.text : fn?.text;
+    return calleeName === 'R6Class' ? lhs.text : undefined;
+  }
+  if (node.type !== 'call') return undefined;
+  const fn = node.childForFieldName('function');
+  if (fn?.type !== 'identifier' || (fn.text !== 'setClass' && fn.text !== 'setRefClass')) {
+    return undefined;
+  }
+  // The class name is the argument that takes the `Class` formal, by name or else
+  // the first unnamed one; `contains = "Base"` ahead of `Class = "A"` is not it.
+  const args = node.childForFieldName('arguments');
+  return (args && getRClassNameArgument(args)) ?? undefined;
+};
+
+/** Class names defined anywhere in the file, built on first use and kept per tree. */
+const localClassNamesByTree = new WeakMap<object, ReadonlySet<string>>();
+const localClassNames = (node: SyntaxNode): ReadonlySet<string> => {
+  const cached = localClassNamesByTree.get(node.tree);
+  if (cached) return cached;
+  const names = new Set<string>();
+  for (const candidate of node.tree.rootNode.descendantsOfType(['binary_operator', 'call'])) {
+    const name = declaredClassName(candidate);
+    if (name !== undefined) names.add(name);
+  }
+  localClassNamesByTree.set(node.tree, names);
+  return names;
+};
+
+/**
+ * The roxygen2 `@param` types documented for an assigned function: the
+ * comment block directly above `name <- function(...)`, keyed by parameter
+ * name. Returns a map of paramName → typeName.
+ */
+const collectRoxygenParams = (assignment: SyntaxNode): Map<string, string> => {
+  const params = new Map<string, string>();
+  for (const { name, description } of parseRoxygenParams(collectRoxygenBlock(assignment))) {
+    const typeName = anchoredType(description);
+    if (typeName !== undefined && localClassNames(assignment).has(typeName)) {
+      params.set(name, typeName);
+    }
+  }
+  return params;
+};
+
+/**
+ * R node types that may carry type bindings.
+ * - `binary_operator`: function definitions use `name <- function(...)` which
+ *   tree-sitter-r parses as binary_operator nodes. Also used for constructor
+ *   assignments like `obj <- ClassName$new()`.
+ */
+const DECLARATION_NODE_TYPES: ReadonlySet<string> = new Set(['binary_operator']);
+
+/**
+ * R declaration extraction. Roxygen types are bound per formal by
+ * `extractParameter`, so a function definition binds nothing here: this
+ * hook runs in the scope that CONTAINS the assignment (the file, for a
+ * top-level function), and a type bound there would be visible in every
+ * function of the file.
+ */
+const extractDeclaration: TypeBindingExtractor = (
+  _node: SyntaxNode,
+  _env: Map<string, string>,
+): void => {
+  // Constructor bindings are made by extractInitializer; roxygen types by extractParameter.
+};
+
+/**
+ * R parameter extraction: the roxygen2 `@param` type of a formal.
+ *
+ * Runs once per formal with the env of the function that owns it, so the
+ * binding is visible inside that function only. The roxygen block is the one
+ * above the assignment `name <- function(...)` the formal belongs to; a name
+ * the block documents but the function does not have is never visited, and a
+ * function that is not the right-hand side of an assignment (a callback)
+ * is documented by nothing. The `...` formal is not an identifier and is
+ * skipped.
+ */
+const extractParameter: ParameterExtractor = (node: SyntaxNode, env: Map<string, string>): void => {
+  if (node.type !== 'parameter') return;
+  const name = node.childForFieldName('name');
+  if (name?.type !== 'identifier') return;
+
+  const fn = node.parent?.parent;
+  if (fn?.type !== 'function_definition') return;
+  const assignment = fn.parent;
+  if (assignment?.type !== 'binary_operator') return;
+  const rhs = assignment.childForFieldName('rhs');
+  if (rhs?.startIndex !== fn.startIndex || rhs.endIndex !== fn.endIndex) return;
+
+  const typeName = collectRoxygenParams(assignment).get(name.text);
+  if (typeName !== undefined) env.set(name.text, typeName);
+};
+
+/**
+ * R constructor inference:
+ * - R6: `obj <- ClassName$new(...)` → type is ClassName
+ * - S4: `obj <- new("ClassName", ...)` → type is ClassName
+ *
+ * Resolves against locally-known class names.
+ */
+const extractInitializer: InitializerExtractor = (node, env, classNames): void => {
+  const result = scanConstructorBinding(node);
+  if (!result) return;
+  if (env.has(result.varName)) return;
+  if (classNames.has(result.calleeName)) {
+    env.set(result.varName, result.calleeName);
+  }
+};
+
+/**
+ * R constructor binding scanner: captures both R6 `obj <- ClassName$new()`
+ * and S4 `obj <- new("ClassName", ...)` patterns.
+ */
+const scanConstructorBinding: ConstructorBindingScanner = (node) => {
+  if (node.type !== 'binary_operator') return undefined;
+  const lhs = node.childForFieldName('lhs');
+  const rhs = node.childForFieldName('rhs');
+  if (!lhs || !rhs) return undefined;
+  if (lhs.type !== 'identifier') return undefined;
+  if (rhs.type !== 'call') return undefined;
+
+  const fn = rhs.childForFieldName('function');
+  if (!fn) return undefined;
+
+  // R6 pattern: obj <- ClassName$new(...)
+  // tree-sitter-r parses `ClassName$new` as an `extract_operator` node
+  if (fn.type === 'extract_operator') {
+    const children = fn.namedChildren;
+    if (children.length >= 2) {
+      const className = children[0];
+      const method = children[1];
+      if (className?.type === 'identifier' && method?.text === 'new') {
+        return { varName: lhs.text, calleeName: className.text };
+      }
+    }
+  }
+
+  // S4 pattern: obj <- new("ClassName", ...)
+  if (fn.type === 'identifier' && fn.text === 'new') {
+    // `new(Class, ...)`: the class is the argument that takes the `Class` formal.
+    const args = rhs.childForFieldName('arguments');
+    const className = args && getRClassNameArgument(args);
+    if (className) return { varName: lhs.text, calleeName: className };
+  }
+
+  return undefined;
+};
+
+export const typeConfig: LanguageTypeConfig = {
+  declarationNodeTypes: DECLARATION_NODE_TYPES,
+  extractDeclaration,
+  extractParameter,
+  extractInitializer,
+  scanConstructorBinding,
+};
diff --git a/gitnexus/src/core/ingestion/workers/parse-worker.ts b/gitnexus/src/core/ingestion/workers/parse-worker.ts
index dffea704b..5de892845 100644
--- a/gitnexus/src/core/ingestion/workers/parse-worker.ts
+++ b/gitnexus/src/core/ingestion/workers/parse-worker.ts
@@ -14,6 +14,7 @@ import CPP from 'tree-sitter-cpp';
 import { getLanguageGrammar } from '../../tree-sitter/parser-loader.js';
 import Go from 'tree-sitter-go';
 import Rust from 'tree-sitter-rust';
+import R from '@eagleoutice/tree-sitter-r';
 import PHP from 'tree-sitter-php';
 import Ruby from 'tree-sitter-ruby';
 import { requireVendoredGrammar } from '../../tree-sitter/vendored-grammars.js';
@@ -607,6 +608,7 @@ const languageMap: Record<string, TreeSitterLanguage> = {
   ...(Kotlin ? { [SupportedLanguages.Kotlin]: Kotlin } : {}),
   [SupportedLanguages.PHP]: PHP.php_only,
   [SupportedLanguages.Ruby]: Ruby,
+  [SupportedLanguages.R]: R,
   [SupportedLanguages.Vue]: TypeScript.typescript,
   ...(Dart ? { [SupportedLanguages.Dart]: Dart } : {}),
   ...(Swift ? { [SupportedLanguages.Swift]: Swift } : {}),
@@ -687,7 +689,9 @@ function findEnclosingClassNode(node: SyntaxNode): SyntaxNode | null {
  * a type (`resolveFileTypeOwner`, e.g. a Zig file-struct), the tree root is
  * the owner node the method/field extractors should read members from. Same
  * root, same name as `findEnclosingClassInfo`'s root branch, so member ids and
- * owner ids agree.
+ * owner ids agree. Failing both, the provider's `resolveMemberOwnerNode` gets
+ * the last word (languages whose members belong to a call/assignment rather
+ * than an enclosing container node, e.g. R's `R6Class(...)`).
  */
 function findEnclosingClassNodeOrFileOwner(
   node: SyntaxNode,
@@ -696,10 +700,12 @@ function findEnclosingClassNodeOrFileOwner(
 ): SyntaxNode | null {
   const container = findEnclosingClassNode(node);
   if (container !== null) return container;
-  if (provider.resolveFileTypeOwner === undefined) return null;
-  let root: SyntaxNode = node;
-  while (root.parent) root = root.parent;
-  return provider.resolveFileTypeOwner(root, filePath) !== null ? root : null;
+  if (provider.resolveFileTypeOwner !== undefined) {
+    let root: SyntaxNode = node;
+    while (root.parent) root = root.parent;
+    if (provider.resolveFileTypeOwner(root, filePath) !== null) return root;
+  }
+  return provider.resolveMemberOwnerNode?.(node) ?? null;
 }
 
 /**
diff --git a/gitnexus/src/core/tree-sitter/parser-loader.ts b/gitnexus/src/core/tree-sitter/parser-loader.ts
index 47f3b19f0..0b403d229 100644
--- a/gitnexus/src/core/tree-sitter/parser-loader.ts
+++ b/gitnexus/src/core/tree-sitter/parser-loader.ts
@@ -131,6 +131,11 @@ const SOURCES: Record<string, GrammarSource> = {
     unavailableNote:
       'Ruby parsing requires `tree-sitter-ruby`. Check the install and native binding.',
   },
+  [SupportedLanguages.R]: {
+    load: () => _require('@eagleoutice/tree-sitter-r'),
+    unavailableNote:
+      'R parsing requires `@eagleoutice/tree-sitter-r`. Check the install and native binding.',
+  },
   [SupportedLanguages.Vue]: {
     load: () => _require('tree-sitter-typescript').typescript,
     unavailableNote:
diff --git a/gitnexus/src/storage/parse-cache.ts b/gitnexus/src/storage/parse-cache.ts
index c4a56ed56..0dbd7d9ce 100644
--- a/gitnexus/src/storage/parse-cache.ts
+++ b/gitnexus/src/storage/parse-cache.ts
@@ -858,7 +858,25 @@ import { copyV8CacheIfPresent, tryLoadV8Cache, writeV8CacheFile } from './v8-sid
 // and original graph positions. Both stores must re-extract v135 captures.
 // v137: Python module-accessor syntax proofs and exact assigned-call provenance
 // join the existing subtype capture payload. Re-extract v136 in both stores.
-const SCHEMA_BUMP = 137;
+// v138: R provider fixes, collapsed into one bump because none of them has
+// shipped. R scope queries anchor a `@scope.function` on every named-function
+// assignment and named function-valued argument (the same nodes the
+// `@declaration.function`/`@declaration.method` anchors use), so each def is
+// owned by its own Function scope instead of the module/Class scope, and
+// capture the `pkg::`/`pkg:::` qualifier of namespaced calls as
+// `@reference.qualified-name` so it reaches `site.rawQualifiedName`. The R
+// provider also keeps only the argument that names an S4 definition
+// (shouldSkipDefinitionCapture), so `setClass("A", contains = "VIRTUAL")` no
+// longer defines a Class `VIRTUAL`, `setGeneric(..., valueClass = "numeric")` a
+// Function `numeric`, nor `setMethod("show", "Foo", ...)` a Method `Foo`; the R
+// scope emitter likewise keeps only the argument that names a `setClass` class
+// or a `library`/`require`/`source` import, so `library(lib.loc = libO, pkgP)`
+// no longer imports `libO` and a comment before the first argument no longer
+// hides the class or import. Definitions and scope captures are parse-time
+// facts replayed verbatim from the warm cache, so stale ones (the pre-fix scope
+// tree, the unqualified call-site shape, the mis-selected arguments) would
+// persist on unchanged files; both stores must re-extract.
+const SCHEMA_BUMP = 138;
 const GITNEXUS_PKG_VERSION = (() => {
   try {
     // package.json sits at gitnexus/package.json — two levels up from
diff --git a/gitnexus/test/fixtures/lang-resolution/r-call-attribution/R/leaves.R b/gitnexus/test/fixtures/lang-resolution/r-call-attribution/R/leaves.R
new file mode 100644
index 000000000..a4e45d6e7
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-call-attribution/R/leaves.R
@@ -0,0 +1,38 @@
+# Synthetic leaf callees for the R caller-attribution fixture (no calls inside).
+leaf_a <- function() NULL
+leaf_b <- function() NULL
+leaf_c <- function() NULL
+leaf_d <- function() NULL
+leaf_e <- function() NULL
+leaf_f <- function() NULL
+leaf_g <- function() NULL
+leaf_h <- function() NULL
+leaf_i <- function() NULL
+leaf_j <- function() NULL
+leaf_k <- function() NULL
+leaf_l <- function() NULL
+leaf_m <- function() NULL
+leaf_n <- function() NULL
+leaf_o <- function() NULL
+leaf_p <- function() NULL
+leaf_q <- function() NULL
+leaf_r <- function() NULL
+leaf_s <- function() NULL
+leaf_t <- function() NULL
+leaf_u <- function() NULL
+leaf_v <- function() NULL
+leaf_w <- function() NULL
+leaf_x <- function() NULL
+leaf_y <- function() NULL
+leaf_z <- function() NULL
+leaf_aa <- function() NULL
+leaf_ab <- function() NULL
+leaf_ac <- function() NULL
+leaf_ad <- function() NULL
+leaf_ae <- function() NULL
+leaf_af <- function() NULL
+leaf_ag <- function() NULL
+leaf_ah <- function() NULL
+leaf_ai <- function() NULL
+leaf_aj <- function() NULL
+leaf_ak <- function() NULL
diff --git a/gitnexus/test/fixtures/lang-resolution/r-call-attribution/R/named_forms.R b/gitnexus/test/fixtures/lang-resolution/r-call-attribution/R/named_forms.R
new file mode 100644
index 000000000..3c22bc808
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-call-attribution/R/named_forms.R
@@ -0,0 +1,23 @@
+# Every file starts with a decoy first function: a call misattributed to the
+# file's first callable shows up as an edge from `decoy_named`.
+decoy_named <- function() leaf_a()
+
+arrow_fn <- function(x) leaf_b(x)
+equals_fn = function(x) leaf_c(x)
+super_fn <<- function(x) leaf_d(x)
+lambda_fn <- \(x) leaf_e(x)
+dotted.name.fn <- function(x) leaf_f(x)
+`backtick name fn` <- function(x) leaf_g(x)
+
+pair_one <- function() leaf_h(1); pair_two <- function() leaf_i(2)
+
+if (TRUE) cond_fn <- function() leaf_j(4)
+
+default_arg_fn <- function(a = leaf_k(1)) {
+  a
+}
+
+registry <- list()
+registry$member_fn <- function(x) leaf_l(x)
+
+res <- leaf_x(1)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-call-attribution/R/nesting.R b/gitnexus/test/fixtures/lang-resolution/r-call-attribution/R/nesting.R
new file mode 100644
index 000000000..169c93d04
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-call-attribution/R/nesting.R
@@ -0,0 +1,19 @@
+decoy_nesting <- function() leaf_m()
+
+outer <- function(x) {
+  inner <- function(y) leaf_n(y)
+  inner(x)
+  lapply(x, function(z) leaf_o(z))
+  sapply(x, FUN = function(z) leaf_p(z))
+  tryCatch(leaf_q(x), error = function(e) leaf_r(e))
+}
+
+level1 <- function() {
+  level2 <- function() {
+    level3 <- function() leaf_s()
+    level3()
+    leaf_t()
+  }
+  level2()
+  leaf_u()
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-call-attribution/R/r6_methods.R b/gitnexus/test/fixtures/lang-resolution/r-call-attribution/R/r6_methods.R
new file mode 100644
index 000000000..9955636f5
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-call-attribution/R/r6_methods.R
@@ -0,0 +1,26 @@
+decoy_r6 <- function() leaf_v()
+
+Widget <- R6::R6Class("Widget",
+  public = list(
+    cache = leaf_w(),
+    first = function() leaf_y(),
+    run = function() {
+      helper <- function() leaf_z()
+      helper()
+      lapply(1:3, function(i) leaf_aa(i))
+    },
+    relay = function() self$peer(),
+    peer = function() leaf_ab()
+  ),
+  private = list(
+    hidden = function() leaf_ac()
+  ),
+  active = list(
+    shown = function() leaf_ad()
+  )
+)
+
+Counter <- setRefClass("Counter", methods = list(
+  bump = function() leaf_ae(),
+  reset = function() leaf_af()
+))
diff --git a/gitnexus/test/fixtures/lang-resolution/r-call-attribution/R/s4.R b/gitnexus/test/fixtures/lang-resolution/r-call-attribution/R/s4.R
new file mode 100644
index 000000000..bfb66cc0b
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-call-attribution/R/s4.R
@@ -0,0 +1,6 @@
+decoy_s4 <- function() leaf_ag()
+
+setClass("Sq", representation(side = "numeric"))
+setGeneric("area", function(shape) standardGeneric("area"))
+setMethod("area", "Sq", function(shape) leaf_ah(shape))
+setClass("P", representation(x = "numeric"), validity = function(object) leaf_ai(object))
diff --git a/gitnexus/test/fixtures/lang-resolution/r-call-attribution/scripts/top_level.R b/gitnexus/test/fixtures/lang-resolution/r-call-attribution/scripts/top_level.R
new file mode 100644
index 000000000..76c12a9f9
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-call-attribution/scripts/top_level.R
@@ -0,0 +1,2 @@
+result <- leaf_aj(1)
+print(leaf_ak(result))
diff --git a/gitnexus/test/fixtures/lang-resolution/r-dotted-cross-file/other/DESCRIPTION b/gitnexus/test/fixtures/lang-resolution/r-dotted-cross-file/other/DESCRIPTION
new file mode 100644
index 000000000..ecf1b2927
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-dotted-cross-file/other/DESCRIPTION
@@ -0,0 +1,3 @@
+Package: other
+Title: Other
+Version: 0.1.0
diff --git a/gitnexus/test/fixtures/lang-resolution/r-dotted-cross-file/other/NAMESPACE b/gitnexus/test/fixtures/lang-resolution/r-dotted-cross-file/other/NAMESPACE
new file mode 100644
index 000000000..27554e40b
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-dotted-cross-file/other/NAMESPACE
@@ -0,0 +1 @@
+export(other_user)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-dotted-cross-file/other/R/use.R b/gitnexus/test/fixtures/lang-resolution/r-dotted-cross-file/other/R/use.R
new file mode 100644
index 000000000..bd9a65c7f
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-dotted-cross-file/other/R/use.R
@@ -0,0 +1,3 @@
+other_helper <- function(v) helper.util(v)
+other_print <- function(v) print.widget(v)
+other_plain <- function(v) plain_fn(v)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-dotted-cross-file/prov/DESCRIPTION b/gitnexus/test/fixtures/lang-resolution/r-dotted-cross-file/prov/DESCRIPTION
new file mode 100644
index 000000000..58fd50ad1
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-dotted-cross-file/prov/DESCRIPTION
@@ -0,0 +1,3 @@
+Package: prov
+Title: Provider
+Version: 0.1.0
diff --git a/gitnexus/test/fixtures/lang-resolution/r-dotted-cross-file/prov/NAMESPACE b/gitnexus/test/fixtures/lang-resolution/r-dotted-cross-file/prov/NAMESPACE
new file mode 100644
index 000000000..585353811
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-dotted-cross-file/prov/NAMESPACE
@@ -0,0 +1,3 @@
+export(helper.util)
+export(plain_fn)
+S3method(print, widget)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-dotted-cross-file/prov/R/defs.R b/gitnexus/test/fixtures/lang-resolution/r-dotted-cross-file/prov/R/defs.R
new file mode 100644
index 000000000..7fc82169e
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-dotted-cross-file/prov/R/defs.R
@@ -0,0 +1,3 @@
+helper.util <- function(x) x
+print.widget <- function(x, ...) invisible(x)
+plain_fn <- function(x) x
diff --git a/gitnexus/test/fixtures/lang-resolution/r-dotted-cross-file/prov/R/use.R b/gitnexus/test/fixtures/lang-resolution/r-dotted-cross-file/prov/R/use.R
new file mode 100644
index 000000000..7be457ef0
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-dotted-cross-file/prov/R/use.R
@@ -0,0 +1,3 @@
+same_pkg_helper <- function(v) helper.util(v)
+same_pkg_print <- function(v) print.widget(v)
+same_pkg_plain <- function(v) plain_fn(v)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-dotted-cross-file/scripts/bare.R b/gitnexus/test/fixtures/lang-resolution/r-dotted-cross-file/scripts/bare.R
new file mode 100644
index 000000000..c4fd75394
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-dotted-cross-file/scripts/bare.R
@@ -0,0 +1 @@
+bare_helper <- function(v) helper.util(v)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-dotted-cross-file/scripts/run.R b/gitnexus/test/fixtures/lang-resolution/r-dotted-cross-file/scripts/run.R
new file mode 100644
index 000000000..b1c2e1f3b
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-dotted-cross-file/scripts/run.R
@@ -0,0 +1,3 @@
+library(prov)
+script_helper <- function(v) helper.util(v)
+script_print <- function(v) print.widget(v)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-dotted-s3-collision/cons/DESCRIPTION b/gitnexus/test/fixtures/lang-resolution/r-dotted-s3-collision/cons/DESCRIPTION
new file mode 100644
index 000000000..3da631519
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-dotted-s3-collision/cons/DESCRIPTION
@@ -0,0 +1,3 @@
+Package: cons
+Title: Consumer
+Version: 0.1.0
diff --git a/gitnexus/test/fixtures/lang-resolution/r-dotted-s3-collision/cons/NAMESPACE b/gitnexus/test/fixtures/lang-resolution/r-dotted-s3-collision/cons/NAMESPACE
new file mode 100644
index 000000000..2b5a41351
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-dotted-s3-collision/cons/NAMESPACE
@@ -0,0 +1 @@
+export(use_foo)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-dotted-s3-collision/cons/R/cons.R b/gitnexus/test/fixtures/lang-resolution/r-dotted-s3-collision/cons/R/cons.R
new file mode 100644
index 000000000..8b4e1d325
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-dotted-s3-collision/cons/R/cons.R
@@ -0,0 +1,7 @@
+library(prov)
+use_foo <- function(v) foo(v)
+use_bar <- function(v) bar(v)
+use_baz <- function(v) baz(v)
+use_dotted <- function(x) print.foo(x)
+use_qux <- function(v) qux(v)
+use_odd <- function(v) `odd name`(v)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-dotted-s3-collision/prov/DESCRIPTION b/gitnexus/test/fixtures/lang-resolution/r-dotted-s3-collision/prov/DESCRIPTION
new file mode 100644
index 000000000..58fd50ad1
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-dotted-s3-collision/prov/DESCRIPTION
@@ -0,0 +1,3 @@
+Package: prov
+Title: Provider
+Version: 0.1.0
diff --git a/gitnexus/test/fixtures/lang-resolution/r-dotted-s3-collision/prov/NAMESPACE b/gitnexus/test/fixtures/lang-resolution/r-dotted-s3-collision/prov/NAMESPACE
new file mode 100644
index 000000000..65e09c213
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-dotted-s3-collision/prov/NAMESPACE
@@ -0,0 +1,7 @@
+export(foo)
+export(bar)
+export(baz)
+S3method(print, foo)
+S3method(print, bar)
+S3method(summary, baz)
+export(qux)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-dotted-s3-collision/prov/R/other.R b/gitnexus/test/fixtures/lang-resolution/r-dotted-s3-collision/prov/R/other.R
new file mode 100644
index 000000000..8eb28c97b
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-dotted-s3-collision/prov/R/other.R
@@ -0,0 +1,6 @@
+same_pkg_foo <- function(v) foo(v)
+same_pkg_bar <- function(v) bar(v)
+same_pkg_baz <- function(v) baz(v)
+dotted_call <- function(x) print.foo(x)
+same_pkg_qux <- function(v) qux(v)
+same_pkg_odd <- function(v) `odd name`(v)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-dotted-s3-collision/prov/R/prov.R b/gitnexus/test/fixtures/lang-resolution/r-dotted-s3-collision/prov/R/prov.R
new file mode 100644
index 000000000..00705b696
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-dotted-s3-collision/prov/R/prov.R
@@ -0,0 +1,12 @@
+print.foo <- function(x, ...) x
+foo <- function(v) structure(list(v = v), class = "foo")
+
+bar <- function(v) structure(list(v = v), class = "bar")
+print.bar <- function(x, ...) x
+
+baz <- function(v) v
+summary.baz <- function(object, ...) object
+
+qux <- function(v) v
+
+`odd name` <- function(v) v
diff --git a/gitnexus/test/fixtures/lang-resolution/r-dotted-s3-collision/scripts/run.R b/gitnexus/test/fixtures/lang-resolution/r-dotted-s3-collision/scripts/run.R
new file mode 100644
index 000000000..4fcac72fc
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-dotted-s3-collision/scripts/run.R
@@ -0,0 +1,4 @@
+library(prov)
+script_foo <- function(v) foo(v)
+script_bar <- function(v) bar(v)
+script_qux <- function(v) qux(v)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/DESCRIPTION b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/DESCRIPTION
new file mode 100644
index 000000000..4876b221a
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/DESCRIPTION
@@ -0,0 +1,3 @@
+Package: analytics
+Title: NAMESPACE Import Fixture Caller
+Version: 0.1.0
diff --git a/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/NAMESPACE b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/NAMESPACE
new file mode 100644
index 000000000..7a7bc9139
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/NAMESPACE
@@ -0,0 +1,37 @@
+export(run_all)
+# Single-line and multi-line importFrom() directives from local packages.
+importFrom(scorelib, tidy_scores)
+importFrom(
+  scorelib,
+  normalise_scores,
+  rank_scores
+)
+importFrom("scorelib", "quoted_fn")
+# Exported by scorelib, but also defined in this package: the own package masks it.
+importFrom(scorelib, own_dup)
+# Duplicate names: the later directive wins (legacyscore).
+importFrom(scorelib, dup_fn)
+importFrom(legacyscore, dup_fn)
+# Not exported by scorelib; never exported name with no definition; whole-package import.
+importFrom(scorelib, hidden_helper)
+importFrom(scorelib, no_such_fn)
+import(reportlib)
+# Dotted names cannot bind precisely.
+importFrom(scorelib, normalise.scores)
+importFrom(scorelib, tidy)
+importFrom(scorelib, tally)
+importFrom(scorelib, plain_fn)
+# R6 members versus top-level definitions.
+importFrom(scorelib, score_it)
+importFrom(scorelib, describe_run)
+# Re-export through a local provider (scorelib imports it from corelib).
+importFrom(scorelib, reexp_fn)
+# Nested function sharing a name with a later top-level function.
+importFrom(scorelib, nest_fn)
+# External packages never bind.
+importFrom(dplyr, mutate)
+# Cross-package decoy guesses the NAMESPACE contradicts (name-guess veto).
+importFrom(dplyr, filter)
+importFrom(scorelib, dup_ext)
+importFrom(dplyr, dup_ext)
+importFrom(dplyr, scripts_only_fn)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/R/decoy_first.R b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/R/decoy_first.R
new file mode 100644
index 000000000..ea38165ee
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/R/decoy_first.R
@@ -0,0 +1,3 @@
+# First function of the package in load order: a decoy that owns none of the
+# edges emitted from the functions written in later files.
+first_fn <- function(d) d
diff --git a/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/R/dotted_use.R b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/R/dotted_use.R
new file mode 100644
index 000000000..a0972c65b
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/R/dotted_use.R
@@ -0,0 +1,15 @@
+dotted_name_user <- function(d) {
+  normalise.scores(d)
+}
+
+print_before_bare_user <- function(d) {
+  tidy(d)
+}
+
+bare_before_print_user <- function(d) {
+  tally(d)
+}
+
+underscore_user <- function(d) {
+  plain_fn(d)
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/R/nested_use.R b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/R/nested_use.R
new file mode 100644
index 000000000..811ff6a3b
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/R/nested_use.R
@@ -0,0 +1,3 @@
+nested_user <- function(d) {
+  nest_fn(d)
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/R/own.R b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/R/own.R
new file mode 100644
index 000000000..7741ee072
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/R/own.R
@@ -0,0 +1,3 @@
+own_dup <- function(d) d
+# Same name as an externally imported function: the own definition masks the import.
+filter <- function(d) d
diff --git a/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/R/qualified_use.R b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/R/qualified_use.R
new file mode 100644
index 000000000..0efc3884e
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/R/qualified_use.R
@@ -0,0 +1,10 @@
+# Explicitly qualified call to a package the NAMESPACE does not import it from.
+qualified_user <- function(d) {
+  legacyscore::tidy_scores(d)
+}
+
+# Correctly qualified call to the package that really defines `mutate`, while the
+# NAMESPACE imports `mutate` from dplyr.
+qualified_mutate_user <- function(d) {
+  legacyscore::mutate(d)
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/R/r6_use.R b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/R/r6_use.R
new file mode 100644
index 000000000..0ce8297e8
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/R/r6_use.R
@@ -0,0 +1,7 @@
+r6_flag_user <- function(d) {
+  score_it(d)
+}
+
+r6_method_only_user <- function(d) {
+  describe_run(d)
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/R/reexport_use.R b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/R/reexport_use.R
new file mode 100644
index 000000000..5f99dff5c
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/R/reexport_use.R
@@ -0,0 +1,3 @@
+reexport_user <- function(d) {
+  reexp_fn(d)
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/R/second.R b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/R/second.R
new file mode 100644
index 000000000..fddfc34ac
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/R/second.R
@@ -0,0 +1,4 @@
+# A second R file: every R file of the package sees the NAMESPACE imports.
+second_user <- function(d) {
+  tidy_scores(d)
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/R/use.R b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/R/use.R
new file mode 100644
index 000000000..b497c6140
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/R/use.R
@@ -0,0 +1,11 @@
+run_all <- function(d) {
+  tidy_scores(d)
+  normalise_scores(d)
+  rank_scores(d)
+  quoted_fn(d)
+  own_dup(d)
+  dup_fn(d)
+  hidden_helper(d)
+  no_such_fn(d)
+  d
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/R/veto_use.R b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/R/veto_use.R
new file mode 100644
index 000000000..21128645c
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/R/veto_use.R
@@ -0,0 +1,17 @@
+# Callers for the name-guess veto scenarios. Each lives in its own function so the exact
+# call sets of the other fixture functions stay untouched.
+mutate_user <- function(d) {
+  mutate(d)
+}
+
+filter_user <- function(d) {
+  filter(d)
+}
+
+dup_ext_user <- function(d) {
+  dup_ext(d)
+}
+
+scripts_only_user <- function(d) {
+  scripts_only_fn(d)
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/scripts/helper.R b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/scripts/helper.R
new file mode 100644
index 000000000..f88f56a5a
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/scripts/helper.R
@@ -0,0 +1,2 @@
+# Script outside any package R/ directory: NAMESPACE imports do not apply here.
+scripts_only_fn <- function(d) d
diff --git a/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/tests/testthat/test-veto.R b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/tests/testthat/test-veto.R
new file mode 100644
index 000000000..9ab0e3f51
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/tests/testthat/test-veto.R
@@ -0,0 +1,4 @@
+# Outside the package R/ directory: NAMESPACE imports do not apply, so the name guess stands.
+test_mutate_user <- function(d) {
+  mutate(d)
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/tests/testthat/test-x.R b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/tests/testthat/test-x.R
new file mode 100644
index 000000000..d38482b7c
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/analytics/tests/testthat/test-x.R
@@ -0,0 +1,3 @@
+test_that_user <- function(d) {
+  tidy_scores(d)
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/corelib/DESCRIPTION b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/corelib/DESCRIPTION
new file mode 100644
index 000000000..fc54af712
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/corelib/DESCRIPTION
@@ -0,0 +1,3 @@
+Package: corelib
+Title: NAMESPACE Import Fixture Origin
+Version: 0.1.0
diff --git a/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/corelib/NAMESPACE b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/corelib/NAMESPACE
new file mode 100644
index 000000000..dd8405a31
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/corelib/NAMESPACE
@@ -0,0 +1 @@
+export(reexp_fn)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/corelib/R/c.R b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/corelib/R/c.R
new file mode 100644
index 000000000..6784b1965
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/corelib/R/c.R
@@ -0,0 +1 @@
+reexp_fn <- function(d) d
diff --git a/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/legacyscore/DESCRIPTION b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/legacyscore/DESCRIPTION
new file mode 100644
index 000000000..54b283547
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/legacyscore/DESCRIPTION
@@ -0,0 +1,3 @@
+Package: legacyscore
+Title: NAMESPACE Import Fixture Decoy
+Version: 0.1.0
diff --git a/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/legacyscore/NAMESPACE b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/legacyscore/NAMESPACE
new file mode 100644
index 000000000..fe3e3b7e0
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/legacyscore/NAMESPACE
@@ -0,0 +1,3 @@
+export(tidy_scores)
+export(dup_fn)
+export(mutate)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/legacyscore/R/l.R b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/legacyscore/R/l.R
new file mode 100644
index 000000000..8c36341a5
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/legacyscore/R/l.R
@@ -0,0 +1,3 @@
+tidy_scores <- function(d) d
+dup_fn <- function(d) d
+mutate <- function(d) d
diff --git a/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/scorelib/DESCRIPTION b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/scorelib/DESCRIPTION
new file mode 100644
index 000000000..297c17b2a
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/scorelib/DESCRIPTION
@@ -0,0 +1,3 @@
+Package: scorelib
+Title: NAMESPACE Import Fixture Provider
+Version: 0.1.0
diff --git a/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/scorelib/NAMESPACE b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/scorelib/NAMESPACE
new file mode 100644
index 000000000..9980c0e84
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/scorelib/NAMESPACE
@@ -0,0 +1,17 @@
+export(tidy_scores)
+export(normalise_scores)
+export(rank_scores)
+export(quoted_fn)
+export(own_dup)
+export(dup_fn)
+export(no_such_fn)
+export(normalise.scores)
+export(tidy)
+export(tally)
+export(plain_fn)
+export(score_it)
+export(describe_run)
+export(reexp_fn)
+export(nest_fn)
+importFrom(corelib, reexp_fn)
+export(dup_ext)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/scorelib/R/dotted.R b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/scorelib/R/dotted.R
new file mode 100644
index 000000000..5de739876
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/scorelib/R/dotted.R
@@ -0,0 +1,7 @@
+# S3-style dotted definitions: a dotted def is indexed under its last segment.
+print.tidy <- function(x, ...) x
+tidy <- function(d) d
+normalise.scores <- function(d) d
+
+tally <- function(d) d
+print.tally <- function(x, ...) x
diff --git a/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/scorelib/R/dup.R b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/scorelib/R/dup.R
new file mode 100644
index 000000000..b9deefb81
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/scorelib/R/dup.R
@@ -0,0 +1,5 @@
+# Also defined (and exported) by legacyscore, which the importer names last.
+dup_fn <- function(d) d
+# Exported here, but the importer names an external package last: no binding, and the
+# unique-name guess to this definition is contradicted by the NAMESPACE.
+dup_ext <- function(d) d
diff --git a/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/scorelib/R/internal.R b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/scorelib/R/internal.R
new file mode 100644
index 000000000..00c702b42
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/scorelib/R/internal.R
@@ -0,0 +1,2 @@
+# Not listed in NAMESPACE: defined but not exported.
+hidden_helper <- function(d) d
diff --git a/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/scorelib/R/nested.R b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/scorelib/R/nested.R
new file mode 100644
index 000000000..b55592d80
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/scorelib/R/nested.R
@@ -0,0 +1,6 @@
+nest_host <- function(d) {
+  nest_fn <- function(y) y
+  nest_fn(d)
+}
+
+nest_fn <- function(d) d
diff --git a/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/scorelib/R/own_dup.R b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/scorelib/R/own_dup.R
new file mode 100644
index 000000000..a41b9ac12
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/scorelib/R/own_dup.R
@@ -0,0 +1,2 @@
+# Also defined in the importing package, whose own definition masks this one.
+own_dup <- function(d) d
diff --git a/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/scorelib/R/plain.R b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/scorelib/R/plain.R
new file mode 100644
index 000000000..808ade737
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/scorelib/R/plain.R
@@ -0,0 +1 @@
+plain_fn <- function(d) d
diff --git a/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/scorelib/R/r6.R b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/scorelib/R/r6.R
new file mode 100644
index 000000000..af3531be5
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/scorelib/R/r6.R
@@ -0,0 +1,15 @@
+Scorer <- R6::R6Class("Scorer",
+  public = list(
+    # Method defined BEFORE the top-level function of the same name.
+    score_it = function(d) d
+  )
+)
+
+score_it <- function(d) d
+
+Reporter <- R6::R6Class("Reporter",
+  public = list(
+    # Only a method: no top-level function carries this name.
+    describe_run = function(d) d
+  )
+)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/scorelib/R/s.R b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/scorelib/R/s.R
new file mode 100644
index 000000000..ef42032f4
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/scorelib/R/s.R
@@ -0,0 +1,4 @@
+tidy_scores <- function(d) d
+normalise_scores <- function(d) d
+rank_scores <- function(d) d
+quoted_fn <- function(d) d
diff --git a/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/vendor/dplyr.py b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/vendor/dplyr.py
new file mode 100644
index 000000000..55924f7a7
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-namespace-imports/vendor/dplyr.py
@@ -0,0 +1,4 @@
+# Same-named file in another language: an external R package must never
+# suffix-match it.
+def mutate(d):
+    return d
diff --git a/gitnexus/test/fixtures/lang-resolution/r-native-pipes/pkgmain/DESCRIPTION b/gitnexus/test/fixtures/lang-resolution/r-native-pipes/pkgmain/DESCRIPTION
new file mode 100644
index 000000000..480a062f1
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-native-pipes/pkgmain/DESCRIPTION
@@ -0,0 +1,3 @@
+Package: pkgmain
+Title: Native Pipe Fixture Main
+Version: 0.1.0
diff --git a/gitnexus/test/fixtures/lang-resolution/r-native-pipes/pkgmain/NAMESPACE b/gitnexus/test/fixtures/lang-resolution/r-native-pipes/pkgmain/NAMESPACE
new file mode 100644
index 000000000..e31a0772b
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-native-pipes/pkgmain/NAMESPACE
@@ -0,0 +1 @@
+export(stage_one)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-native-pipes/pkgmain/R/a.R b/gitnexus/test/fixtures/lang-resolution/r-native-pipes/pkgmain/R/a.R
new file mode 100644
index 000000000..32ec2c2a4
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-native-pipes/pkgmain/R/a.R
@@ -0,0 +1,54 @@
+stage_one <- function(d) d
+stage_two <- function(d, k) d
+stage_three <- function(d, data) d
+uniq_helper <- function(d) d
+amb_stage <- function(d) d
+
+# Module-level pipe: sourced from the File node.
+piped_top <- c(1, 2) |> stage_one() |> stage_two(3)
+
+# Placeholder argument: `_` is not a call and produces no edge.
+placeholder_user <- function(df) {
+  df |> stage_three(data = _)
+}
+
+# Lambda stage: the call inside the lambda belongs to the enclosing function.
+lambda_user <- function(df) {
+  df |> (\(d) uniq_helper(d))()
+}
+
+# Namespaced stage, unique name in another package (bound precisely by its qualifier).
+ns_user <- function(df) {
+  df |> pkgother::ext_fn() |> stage_one()
+}
+
+# Namespaced stage whose name is also defined in THIS file.
+ns_amb_user <- function(df) {
+  df |> pkgother::amb_stage()
+}
+
+# Multi-line chain, leading `|>` on continuation lines, builtin `paste` stage.
+multiline_user <- function(df) {
+  df |>
+    stage_one() |>
+    stage_two(2) |>
+    paste("x") |>
+    stage_three(data = _)
+}
+
+# R6 method chain ending in a self$ member stage.
+Cls <- R6::R6Class("Cls", public = list(
+  run = function(df) {
+    df |> stage_one() |> self$post()
+  },
+  post = function(d) d
+))
+
+plain_user <- function(df) {
+  uniq_helper(df)
+}
+
+# Member stage on an object of unknown type.
+member_user <- function(obj, df) {
+  df |> obj$method(1) |> stage_one()
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-native-pipes/pkgmain/R/b.R b/gitnexus/test/fixtures/lang-resolution/r-native-pipes/pkgmain/R/b.R
new file mode 100644
index 000000000..15f627637
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-native-pipes/pkgmain/R/b.R
@@ -0,0 +1,19 @@
+Type <- R6::R6Class("Type", public = list(
+  score = function(d) d
+))
+
+# Member stage on a typed local (constructed via Type$new()).
+typed_user <- function(df) {
+  obj <- Type$new()
+  df |> obj$score() |> stage_one()
+}
+
+# Backticked stage with no definition anywhere.
+bt_user <- function(df) {
+  df |> `my fn`() |> stage_two(1)
+}
+
+# Same name defined in both other packages.
+ns_amb2_user <- function(df) {
+  df |> pkgother::amb_only() |> pkgthird::amb_only()
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-native-pipes/pkgmain/R/decoy_first.R b/gitnexus/test/fixtures/lang-resolution/r-native-pipes/pkgmain/R/decoy_first.R
new file mode 100644
index 000000000..5a8b15ffb
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-native-pipes/pkgmain/R/decoy_first.R
@@ -0,0 +1,5 @@
+# First function of the package in load order: a decoy that must own only its
+# own pipe edge, never the edges of pipes written in later functions/files.
+decoy_first <- function(d) {
+  d |> uniq_helper()
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-native-pipes/pkgmain/R/nested.R b/gitnexus/test/fixtures/lang-resolution/r-native-pipes/pkgmain/R/nested.R
new file mode 100644
index 000000000..6d5a02f30
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-native-pipes/pkgmain/R/nested.R
@@ -0,0 +1,9 @@
+# Nested function sharing a name with a later top-level function.
+nested_outer <- function(d) {
+  nest_fn <- function(x) x
+  d |> nest_fn() |> stage_two(1)
+}
+nest_fn <- function(x) x
+nested_caller <- function(d) {
+  d |> nest_fn()
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-native-pipes/pkgother/DESCRIPTION b/gitnexus/test/fixtures/lang-resolution/r-native-pipes/pkgother/DESCRIPTION
new file mode 100644
index 000000000..6c456d81d
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-native-pipes/pkgother/DESCRIPTION
@@ -0,0 +1,3 @@
+Package: pkgother
+Title: Native Pipe Fixture Other
+Version: 0.1.0
diff --git a/gitnexus/test/fixtures/lang-resolution/r-native-pipes/pkgother/R/e.R b/gitnexus/test/fixtures/lang-resolution/r-native-pipes/pkgother/R/e.R
new file mode 100644
index 000000000..d7a598953
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-native-pipes/pkgother/R/e.R
@@ -0,0 +1,3 @@
+ext_fn <- function(d) d
+amb_stage <- function(d) d
+amb_only <- function(d) d
diff --git a/gitnexus/test/fixtures/lang-resolution/r-native-pipes/pkgthird/DESCRIPTION b/gitnexus/test/fixtures/lang-resolution/r-native-pipes/pkgthird/DESCRIPTION
new file mode 100644
index 000000000..2f8199363
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-native-pipes/pkgthird/DESCRIPTION
@@ -0,0 +1,3 @@
+Package: pkgthird
+Title: Native Pipe Fixture Third
+Version: 0.1.0
diff --git a/gitnexus/test/fixtures/lang-resolution/r-native-pipes/pkgthird/R/t.R b/gitnexus/test/fixtures/lang-resolution/r-native-pipes/pkgthird/R/t.R
new file mode 100644
index 000000000..6740c0f23
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-native-pipes/pkgthird/R/t.R
@@ -0,0 +1 @@
+amb_only <- function(d) d
diff --git a/gitnexus/test/fixtures/lang-resolution/r-no-description-truncated/R/a.R b/gitnexus/test/fixtures/lang-resolution/r-no-description-truncated/R/a.R
new file mode 100644
index 000000000..6361c801a
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-no-description-truncated/R/a.R
@@ -0,0 +1,3 @@
+# No DESCRIPTION is discovered at or above depth 3, but deep/a/b/c/impl (below the
+# depth limit) holds one, so package discovery cannot prove dplyr is external.
+filter <- function(d) d
diff --git a/gitnexus/test/fixtures/lang-resolution/r-no-description-truncated/R/b.R b/gitnexus/test/fixtures/lang-resolution/r-no-description-truncated/R/b.R
new file mode 100644
index 000000000..c70ed5269
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-no-description-truncated/R/b.R
@@ -0,0 +1,3 @@
+run_ext <- function(d) {
+  dplyr::filter(d)
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-no-description-truncated/deep/a/b/c/impl/DESCRIPTION b/gitnexus/test/fixtures/lang-resolution/r-no-description-truncated/deep/a/b/c/impl/DESCRIPTION
new file mode 100644
index 000000000..32cd616da
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-no-description-truncated/deep/a/b/c/impl/DESCRIPTION
@@ -0,0 +1,2 @@
+Package: hiddenpkg
+Version: 0.1
diff --git a/gitnexus/test/fixtures/lang-resolution/r-no-description-truncated/deep/a/b/c/impl/R/x.R b/gitnexus/test/fixtures/lang-resolution/r-no-description-truncated/deep/a/b/c/impl/R/x.R
new file mode 100644
index 000000000..3f887bd85
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-no-description-truncated/deep/a/b/c/impl/R/x.R
@@ -0,0 +1 @@
+hidden_fn <- function() 1
diff --git a/gitnexus/test/fixtures/lang-resolution/r-no-description/R/a.R b/gitnexus/test/fixtures/lang-resolution/r-no-description/R/a.R
new file mode 100644
index 000000000..7cfc0c730
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-no-description/R/a.R
@@ -0,0 +1,5 @@
+# Local definitions that share their names with dplyr verbs. There is no
+# DESCRIPTION anywhere in this repo, so no package is local.
+filter <- function(d) d
+
+mutate <- function(d) d
diff --git a/gitnexus/test/fixtures/lang-resolution/r-no-description/R/b.R b/gitnexus/test/fixtures/lang-resolution/r-no-description/R/b.R
new file mode 100644
index 000000000..c70ed5269
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-no-description/R/b.R
@@ -0,0 +1,3 @@
+run_ext <- function(d) {
+  dplyr::filter(d)
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-no-description/scripts/run.R b/gitnexus/test/fixtures/lang-resolution/r-no-description/scripts/run.R
new file mode 100644
index 000000000..901a3f3eb
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-no-description/scripts/run.R
@@ -0,0 +1,9 @@
+select <- function(d) d
+
+run_same <- function(d) {
+  dplyr::mutate(d)
+}
+
+run_decoy <- function(d) {
+  dplyr::select(d)
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-non-indexed/.Renviron b/gitnexus/test/fixtures/lang-resolution/r-non-indexed/.Renviron
new file mode 100644
index 000000000..0e9b57512
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-non-indexed/.Renviron
@@ -0,0 +1 @@
+R_LIBS_USER=~/R/library
diff --git a/gitnexus/test/fixtures/lang-resolution/r-non-indexed/.Rprofile b/gitnexus/test/fixtures/lang-resolution/r-non-indexed/.Rprofile
new file mode 100644
index 000000000..fa1f846ea
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-non-indexed/.Rprofile
@@ -0,0 +1 @@
+rprofile_fn <- function() 1
diff --git a/gitnexus/test/fixtures/lang-resolution/r-non-indexed/analysis.Rmd b/gitnexus/test/fixtures/lang-resolution/r-non-indexed/analysis.Rmd
new file mode 100644
index 000000000..1941cdafd
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-non-indexed/analysis.Rmd
@@ -0,0 +1,3 @@
+# Valid R on purpose: if this extension were ever routed to the R parser the
+# function below would be indexed, so the negative test can actually fail.
+rmd_fn <- function() 1
diff --git a/gitnexus/test/fixtures/lang-resolution/r-non-indexed/real.R b/gitnexus/test/fixtures/lang-resolution/r-non-indexed/real.R
new file mode 100644
index 000000000..540e3f529
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-non-indexed/real.R
@@ -0,0 +1,2 @@
+# Positive control: a plain .R file is indexed.
+indexed_control <- function() 1
diff --git a/gitnexus/test/fixtures/lang-resolution/r-non-indexed/report.qmd b/gitnexus/test/fixtures/lang-resolution/r-non-indexed/report.qmd
new file mode 100644
index 000000000..9762f0f27
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-non-indexed/report.qmd
@@ -0,0 +1,2 @@
+# Valid R on purpose (see analysis.Rmd).
+qmd_fn <- function() 1
diff --git a/gitnexus/test/fixtures/lang-resolution/r-package-layout/DESCRIPTION b/gitnexus/test/fixtures/lang-resolution/r-package-layout/DESCRIPTION
new file mode 100644
index 000000000..688be2a5a
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-package-layout/DESCRIPTION
@@ -0,0 +1,2 @@
+Package: layoutroot
+Version: 1.0
diff --git a/gitnexus/test/fixtures/lang-resolution/r-package-layout/NAMESPACE b/gitnexus/test/fixtures/lang-resolution/r-package-layout/NAMESPACE
new file mode 100644
index 000000000..2c5ef0f5c
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-package-layout/NAMESPACE
@@ -0,0 +1 @@
+export(root_exported)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-package-layout/R/root.R b/gitnexus/test/fixtures/lang-resolution/r-package-layout/R/root.R
new file mode 100644
index 000000000..9969a07be
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-package-layout/R/root.R
@@ -0,0 +1,7 @@
+root_exported <- function() {
+  1
+}
+
+root_hidden <- function() {
+  2
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-package-layout/inst/scripts/run.R b/gitnexus/test/fixtures/lang-resolution/r-package-layout/inst/scripts/run.R
new file mode 100644
index 000000000..63a6e7774
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-package-layout/inst/scripts/run.R
@@ -0,0 +1,3 @@
+root_inst_script <- function() {
+  root_exported()
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-package-layout/pkgs/inner/DESCRIPTION b/gitnexus/test/fixtures/lang-resolution/r-package-layout/pkgs/inner/DESCRIPTION
new file mode 100644
index 000000000..0920fce31
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-package-layout/pkgs/inner/DESCRIPTION
@@ -0,0 +1,2 @@
+Package: layoutinner
+Version: 1.0
diff --git a/gitnexus/test/fixtures/lang-resolution/r-package-layout/pkgs/inner/R/inner.R b/gitnexus/test/fixtures/lang-resolution/r-package-layout/pkgs/inner/R/inner.R
new file mode 100644
index 000000000..ab1446bc1
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-package-layout/pkgs/inner/R/inner.R
@@ -0,0 +1,3 @@
+inner_fn <- function() {
+  1
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-package-layout/pkgs/nested/DESCRIPTION b/gitnexus/test/fixtures/lang-resolution/r-package-layout/pkgs/nested/DESCRIPTION
new file mode 100644
index 000000000..4082ecaa8
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-package-layout/pkgs/nested/DESCRIPTION
@@ -0,0 +1,2 @@
+Package: layoutnested
+Version: 1.0
diff --git a/gitnexus/test/fixtures/lang-resolution/r-package-layout/pkgs/nested/NAMESPACE b/gitnexus/test/fixtures/lang-resolution/r-package-layout/pkgs/nested/NAMESPACE
new file mode 100644
index 000000000..26f2ea5df
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-package-layout/pkgs/nested/NAMESPACE
@@ -0,0 +1 @@
+export(nested_exported)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-package-layout/pkgs/nested/R/nested.R b/gitnexus/test/fixtures/lang-resolution/r-package-layout/pkgs/nested/R/nested.R
new file mode 100644
index 000000000..a6b9b342e
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-package-layout/pkgs/nested/R/nested.R
@@ -0,0 +1,7 @@
+nested_exported <- function() {
+  1
+}
+
+nested_hidden <- function() {
+  2
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-package-layout/pkgs/nested/tests/testthat/test-nested.R b/gitnexus/test/fixtures/lang-resolution/r-package-layout/pkgs/nested/tests/testthat/test-nested.R
new file mode 100644
index 000000000..c8b94c9fd
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-package-layout/pkgs/nested/tests/testthat/test-nested.R
@@ -0,0 +1,3 @@
+nested_test_helper <- function() {
+  nested_exported()
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-package-layout/scripts/use.R b/gitnexus/test/fixtures/lang-resolution/r-package-layout/scripts/use.R
new file mode 100644
index 000000000..eee6950d9
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-package-layout/scripts/use.R
@@ -0,0 +1,5 @@
+library(layoutroot)
+
+root_script_entry <- function() {
+  root_exported()
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-package-layout/tests/testthat/test-root.R b/gitnexus/test/fixtures/lang-resolution/r-package-layout/tests/testthat/test-root.R
new file mode 100644
index 000000000..95d626872
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-package-layout/tests/testthat/test-root.R
@@ -0,0 +1,3 @@
+root_test_helper <- function() {
+  root_exported()
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-package-layout/vignettes/demo.R b/gitnexus/test/fixtures/lang-resolution/r-package-layout/vignettes/demo.R
new file mode 100644
index 000000000..50d16ba33
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-package-layout/vignettes/demo.R
@@ -0,0 +1,3 @@
+root_vignette_helper <- function() {
+  root_exported()
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/DESCRIPTION b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/DESCRIPTION
new file mode 100644
index 000000000..d196d08ca
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/DESCRIPTION
@@ -0,0 +1,4 @@
+Package: pkgA
+Title: Test Package A
+Version: 0.1.0
+Imports: pkgB
diff --git a/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/NAMESPACE b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/NAMESPACE
new file mode 100644
index 000000000..4a79e704b
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/NAMESPACE
@@ -0,0 +1,6 @@
+export(AddOutlierStatuses)
+export(HelperFunc)
+export(my.helper.func)
+export(PackageScoped)
+export(SuperAssignFunc)
+importFrom(pkgB, CleanData)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/R/add_outliers.R b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/R/add_outliers.R
new file mode 100644
index 000000000..317d3959b
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/R/add_outliers.R
@@ -0,0 +1,11 @@
+#' Add outlier statuses to data
+#'
+#' @param data DataFrame the input data
+#' @param outliers DataFrame outlier records
+#' @return DataFrame with outlier statuses added
+#' @export
+AddOutlierStatuses <- function(data, outliers) {
+  clean <- pkgB::CleanData(data)
+  result <- merge(clean, outliers, by = "id", all.x = TRUE)
+  result
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/R/dot_names.R b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/R/dot_names.R
new file mode 100644
index 000000000..c7ba18441
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/R/dot_names.R
@@ -0,0 +1,4 @@
+#' A dot-named function (legal R identifier — dots are valid in names)
+my.helper.func <- function(x) {
+  x
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/R/export_scope.R b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/R/export_scope.R
new file mode 100644
index 000000000..dae415991
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/R/export_scope.R
@@ -0,0 +1,6 @@
+#' Exported only from pkgA
+#'
+#' @export
+PackageScoped <- function() {
+  TRUE
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/R/models.R b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/R/models.R
new file mode 100644
index 000000000..c1b00430c
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/R/models.R
@@ -0,0 +1,29 @@
+# S4 class definition
+setClass("DataModel", contains = "VIRTUAL", slots = list(
+  name = "character",
+  value = "numeric"
+))
+
+# R5 reference class
+DataProcessor <- setRefClass("DataProcessor",
+  fields = list(data = "data.frame"),
+  methods = list(
+    process = function() {
+      self$data
+    }
+  )
+)
+
+# R6 class
+library(R6)
+ResultSet <- R6::R6Class("ResultSet",
+  public = list(
+    items = NULL,
+    initialize = function(items = list()) {
+      self$items <- items
+    },
+    count = function() {
+      length(self$items)
+    }
+  )
+)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/R/r6_advanced.R b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/R/r6_advanced.R
new file mode 100644
index 000000000..dcb41d59e
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/R/r6_advanced.R
@@ -0,0 +1,26 @@
+library(R6)
+AdvancedR6 <- R6::R6Class("AdvancedR6",
+  public = list(
+    name = "default",
+    active_count = 0L,
+    initialize = function(name) {
+      self$name <- name
+    },
+    get_name = function() {
+      self$name
+    }
+  ),
+  private = list(
+    secret_key = NULL,
+    internal_flag = TRUE,
+    compute = function() {
+      private$secret_key
+    }
+  ),
+  active = list(
+    display_name = function(value) {
+      if (missing(value)) return(self$name)
+      self$name <- value
+    }
+  )
+)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/R/r6_bare.R b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/R/r6_bare.R
new file mode 100644
index 000000000..1fad77c4c
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/R/r6_bare.R
@@ -0,0 +1,10 @@
+# R6 class via bare R6Class() call (no R6:: namespace prefix)
+BareR6 <- R6Class("BareR6",
+  public = list(
+    value = 42,
+    get_value = function() {
+      self$value
+    }
+  ),
+  inherit = Parent
+)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/R/s3.R b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/R/s3.R
new file mode 100644
index 000000000..7c0d6a794
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/R/s3.R
@@ -0,0 +1,13 @@
+#' Generic description function
+describe <- function(x) {
+  UseMethod("describe")
+}
+
+describe.FancyWidget <- function(x) {
+  x
+}
+
+#' @param widget FancyWidget widget under analysis
+render_widget <- function(widget) {
+  describe(widget)
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/R/s4_and_r6.R b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/R/s4_and_r6.R
new file mode 100644
index 000000000..d19397c69
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/R/s4_and_r6.R
@@ -0,0 +1,41 @@
+# S4 generic and method
+setGeneric("validate", function(object, ...) standardGeneric("validate"))
+setMethod("validate", "DataModel", function(object, ...) {
+  length(object@name) > 0
+})
+
+# R6 base class
+Parent <- R6::R6Class("Parent",
+  public = list(
+    greet = function() "hi"
+  )
+)
+
+# R6 with inheritance
+Child <- R6::R6Class("Child",
+  inherit = Parent,
+  public = list(
+    greet = function() "hello"
+  )
+)
+
+# Functions used by pipe-chain resolution tests
+clean_native <- function(data) {
+  data
+}
+
+transform_native <- function(data) {
+  data
+}
+
+clean_magrittr <- function(data) {
+  data
+}
+
+transform_magrittr <- function(data) {
+  data
+}
+
+# Pipe usage
+result <- data |> clean_native() |> transform_native()
+result2 <- data %>% clean_magrittr() %>% transform_magrittr()
diff --git a/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/R/s4_multi_parent.R b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/R/s4_multi_parent.R
new file mode 100644
index 000000000..50bbbf8fa
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/R/s4_multi_parent.R
@@ -0,0 +1,3 @@
+setClass("BaseA", slots = list(a_field = "numeric"))
+setClass("BaseB", slots = list(b_field = "character"))
+setClass("MultiChild", contains = c("BaseA", "BaseB"))
diff --git a/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/R/super_assign.R b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/R/super_assign.R
new file mode 100644
index 000000000..d4482437b
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/R/super_assign.R
@@ -0,0 +1,7 @@
+#' Function defined with <<- super-assignment
+#'
+#' @param x Numeric input
+#' @return Numeric result
+SuperAssignFunc <<- function(x) {
+  x + 1
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/R/utils.R b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/R/utils.R
new file mode 100644
index 000000000..d6197cceb
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgA/R/utils.R
@@ -0,0 +1,7 @@
+#' A helper function using = assignment
+#'
+#' @param x Numeric input value
+#' @return Numeric the transformed value
+HelperFunc = function(x) {
+  x * 2
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-packages/pkgB/DESCRIPTION b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgB/DESCRIPTION
new file mode 100644
index 000000000..44e322767
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgB/DESCRIPTION
@@ -0,0 +1,3 @@
+Package: pkgB
+Title: Test Package B
+Version: 0.1.0
diff --git a/gitnexus/test/fixtures/lang-resolution/r-packages/pkgB/NAMESPACE b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgB/NAMESPACE
new file mode 100644
index 000000000..74eec96d3
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgB/NAMESPACE
@@ -0,0 +1,5 @@
+export(CleanData)
+exportPattern("^Pattern")
+S3method(print, FancyWidget)
+exportClasses(ExportedS4Class)
+exportMethods(exportedMethod)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-packages/pkgB/R/clean_data.R b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgB/R/clean_data.R
new file mode 100644
index 000000000..251a3014f
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgB/R/clean_data.R
@@ -0,0 +1,8 @@
+#' Clean input data
+#'
+#' @param raw_data DataFrame the raw data
+#' @return DataFrame cleaned data
+#' @export
+CleanData <- function(raw_data) {
+  raw_data[complete.cases(raw_data), ]
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-packages/pkgB/R/export_namespace_variants.R b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgB/R/export_namespace_variants.R
new file mode 100644
index 000000000..671fed5bc
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgB/R/export_namespace_variants.R
@@ -0,0 +1,7 @@
+PatternScoped <- function() {
+  TRUE
+}
+
+print.FancyWidget <- function(x) {
+  x
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-packages/pkgB/R/export_scope.R b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgB/R/export_scope.R
new file mode 100644
index 000000000..53951df52
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgB/R/export_scope.R
@@ -0,0 +1,3 @@
+PackageScoped <- function() {
+  FALSE
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-packages/pkgB/R/s4_export_test.R b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgB/R/s4_export_test.R
new file mode 100644
index 000000000..5dd920337
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgB/R/s4_export_test.R
@@ -0,0 +1,2 @@
+setClass("ExportedS4Class", slots = list(data = "list"))
+setGeneric("exportedMethod", function(object) standardGeneric("exportedMethod"))
diff --git a/gitnexus/test/fixtures/lang-resolution/r-packages/pkgC/DESCRIPTION b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgC/DESCRIPTION
new file mode 100644
index 000000000..51a067cfd
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgC/DESCRIPTION
@@ -0,0 +1,3 @@
+Package: pkgC
+Title: Test Package C (no NAMESPACE)
+Version: 0.1.0
diff --git a/gitnexus/test/fixtures/lang-resolution/r-packages/pkgC/R/default_export.R b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgC/R/default_export.R
new file mode 100644
index 000000000..76a9bea22
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-packages/pkgC/R/default_export.R
@@ -0,0 +1,10 @@
+#' A function with roxygen @export tag
+#'
+#' @export
+RoxygenExported <- function() {
+  TRUE
+}
+
+NoExportTag <- function() {
+  FALSE
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-packages/scripts/run_analysis.R b/gitnexus/test/fixtures/lang-resolution/r-packages/scripts/run_analysis.R
new file mode 100644
index 000000000..2e337d993
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-packages/scripts/run_analysis.R
@@ -0,0 +1,14 @@
+# Standalone script using source() and library()
+source("pkgA/R/utils.R")
+library("pkgB")
+
+result <- HelperFunc(42)
+clean <- CleanData(result)
+print(clean)
+
+# R6 method call resolution
+rs <- ResultSet$new(list(1, 2, 3))
+n <- rs$count()
+
+# require() should resolve identically to library()
+require("pkgA")
diff --git a/gitnexus/test/fixtures/lang-resolution/r-qualified-calls-deep-fixtures/caller/DESCRIPTION b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls-deep-fixtures/caller/DESCRIPTION
new file mode 100644
index 000000000..19b328e0a
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls-deep-fixtures/caller/DESCRIPTION
@@ -0,0 +1,2 @@
+Package: deepcaller
+Version: 0.1
diff --git a/gitnexus/test/fixtures/lang-resolution/r-qualified-calls-deep-fixtures/caller/NAMESPACE b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls-deep-fixtures/caller/NAMESPACE
new file mode 100644
index 000000000..16aed1d2a
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls-deep-fixtures/caller/NAMESPACE
@@ -0,0 +1,2 @@
+export(external_user)
+export(own_user)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-qualified-calls-deep-fixtures/caller/R/calls.R b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls-deep-fixtures/caller/R/calls.R
new file mode 100644
index 000000000..445b85c5b
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls-deep-fixtures/caller/R/calls.R
@@ -0,0 +1,15 @@
+# The package's tests/testthat/fixtures/ directory sits below the depth-3 discovery limit
+# (repo/caller/tests/testthat/fixtures) but holds no package, so discovery is complete:
+# `dplyr` is certainly external and the qualified call must not bind to the local decoy.
+
+# Same-file decoy for the external qualifier below.
+filter <- function(d) d
+
+external_user <- function(d) {
+  dplyr::filter(d)
+}
+
+# A qualifier naming this (discovered) package still binds precisely (own_fn is in util.R).
+own_user <- function(d) {
+  deepcaller::own_fn(d)
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-qualified-calls-deep-fixtures/caller/R/util.R b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls-deep-fixtures/caller/R/util.R
new file mode 100644
index 000000000..ea92c8340
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls-deep-fixtures/caller/R/util.R
@@ -0,0 +1 @@
+own_fn <- function(d) d
diff --git a/gitnexus/test/fixtures/lang-resolution/r-qualified-calls-deep-fixtures/caller/tests/testthat/fixtures/data/raw/sample.csv b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls-deep-fixtures/caller/tests/testthat/fixtures/data/raw/sample.csv
new file mode 100644
index 000000000..1e70a9659
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls-deep-fixtures/caller/tests/testthat/fixtures/data/raw/sample.csv
@@ -0,0 +1,2 @@
+id,value
+1,2
diff --git a/gitnexus/test/fixtures/lang-resolution/r-qualified-calls-truncated/caller/DESCRIPTION b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls-truncated/caller/DESCRIPTION
new file mode 100644
index 000000000..1431fc39e
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls-truncated/caller/DESCRIPTION
@@ -0,0 +1,3 @@
+Package: caller
+Title: Qualified Call Fixture Truncated Discovery
+Version: 0.1.0
diff --git a/gitnexus/test/fixtures/lang-resolution/r-qualified-calls-truncated/caller/NAMESPACE b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls-truncated/caller/NAMESPACE
new file mode 100644
index 000000000..37b192e9f
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls-truncated/caller/NAMESPACE
@@ -0,0 +1 @@
+export(unknown_user)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-qualified-calls-truncated/caller/R/calls.R b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls-truncated/caller/R/calls.R
new file mode 100644
index 000000000..71a7dbb27
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls-truncated/caller/R/calls.R
@@ -0,0 +1,23 @@
+# Package discovery stops at directory depth 3, so the packages under deep/a/b/c/ are never
+# found: whether they are local is UNKNOWN, and the qualified sites must be left as they are.
+
+# Same-file decoys for the two qualifiers below.
+unk_fn <- function(d) d
+filter <- function(d) d
+
+# `invisiblepkg` is a real package (DESCRIPTION `Package:` in deep/a/b/c/impl), invisible to
+# discovery, and its directory name does not match: nothing shows it is local.
+unknown_user <- function(d) {
+  invisiblepkg::unk_fn(d)
+}
+
+# With discovery truncated this cannot be shown to be external either.
+truncated_external_user <- function(d) {
+  dplyr::filter(d)
+}
+
+# `pathpkg` has no DESCRIPTION, but its parsed files sit under `pathpkg/R/`.
+path_local_user <- function(d) {
+  pathpkg::path_fn(d)
+}
+path_fn <- function(d) d
diff --git a/gitnexus/test/fixtures/lang-resolution/r-qualified-calls-truncated/deep/a/b/c/impl/DESCRIPTION b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls-truncated/deep/a/b/c/impl/DESCRIPTION
new file mode 100644
index 000000000..b432c9faa
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls-truncated/deep/a/b/c/impl/DESCRIPTION
@@ -0,0 +1,3 @@
+Package: invisiblepkg
+Title: Package Invisible To Discovery
+Version: 0.1.0
diff --git a/gitnexus/test/fixtures/lang-resolution/r-qualified-calls-truncated/deep/a/b/c/impl/R/x.R b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls-truncated/deep/a/b/c/impl/R/x.R
new file mode 100644
index 000000000..c9112ea8d
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls-truncated/deep/a/b/c/impl/R/x.R
@@ -0,0 +1 @@
+unk_fn <- function(d) d
diff --git a/gitnexus/test/fixtures/lang-resolution/r-qualified-calls-truncated/deep/a/b/c/pathpkg/R/p.R b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls-truncated/deep/a/b/c/pathpkg/R/p.R
new file mode 100644
index 000000000..de513dbc8
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls-truncated/deep/a/b/c/pathpkg/R/p.R
@@ -0,0 +1 @@
+path_fn <- function(d) d
diff --git a/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/altlib/DESCRIPTION b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/altlib/DESCRIPTION
new file mode 100644
index 000000000..a0f89d39f
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/altlib/DESCRIPTION
@@ -0,0 +1,3 @@
+Package: altlib
+Title: Qualified Call Fixture Decoy Provider
+Version: 0.1.0
diff --git a/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/altlib/NAMESPACE b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/altlib/NAMESPACE
new file mode 100644
index 000000000..03ef472f9
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/altlib/NAMESPACE
@@ -0,0 +1,2 @@
+export(shared)
+export(libshared)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/altlib/R/alt.R b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/altlib/R/alt.R
new file mode 100644
index 000000000..0b76fe76d
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/altlib/R/alt.R
@@ -0,0 +1,2 @@
+shared <- function(d) d
+libshared <- function(d) d
diff --git a/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/caller/DESCRIPTION b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/caller/DESCRIPTION
new file mode 100644
index 000000000..32cf7f99d
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/caller/DESCRIPTION
@@ -0,0 +1,3 @@
+Package: caller
+Title: Qualified Call Fixture Caller
+Version: 0.1.0
diff --git a/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/caller/NAMESPACE b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/caller/NAMESPACE
new file mode 100644
index 000000000..eb978aa7d
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/caller/NAMESPACE
@@ -0,0 +1,3 @@
+export(local_user)
+# Decoy: names altlib, but the calls below are explicitly qualified with locallib.
+importFrom(altlib, shared)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/caller/R/duplicate_calls.R b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/caller/R/duplicate_calls.R
new file mode 100644
index 000000000..5b4d229c2
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/caller/R/duplicate_calls.R
@@ -0,0 +1,15 @@
+# Qualified calls to names that duplicate inside the named package (no single valid target).
+
+# `twice` is defined twice in ONE file of duplib (a redefinition); this file holds a decoy.
+twice <- function(d) d
+
+dup_same_file_user <- function(d) {
+  duplib::twice(d)
+}
+
+# `across` is defined in two DIFFERENT files of duplib; this file holds a decoy.
+across <- function(d) d
+
+dup_cross_file_user <- function(d) {
+  duplib::across(d)
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/caller/R/external_calls.R b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/caller/R/external_calls.R
new file mode 100644
index 000000000..ca22ef5f9
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/caller/R/external_calls.R
@@ -0,0 +1,21 @@
+# Qualified calls to packages that are not part of the repository (certainly external).
+# Each name collides with a local definition that the qualifier rules out.
+
+# Same-file decoy.
+filter <- function(d) d
+
+external_same_file_user <- function(d) {
+  dplyr::filter(d)
+}
+
+# The colliding definition lives in another local package (provlib), not in this file.
+external_other_pkg_user <- function(d) {
+  dplyr::mutate(d)
+}
+
+# `:::` to an external package.
+internal_helper <- function(d) d
+
+external_internal_user <- function(d) {
+  dplyr:::internal_helper(d)
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/caller/R/local_calls.R b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/caller/R/local_calls.R
new file mode 100644
index 000000000..1c92ca457
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/caller/R/local_calls.R
@@ -0,0 +1,51 @@
+# Callers of functions in OTHER local packages, always written with an explicit qualifier.
+# Every callee is defined exactly once in the package the qualifier names; the same-name
+# definitions in THIS package are decoys the qualifier must never bind to.
+
+# Wrapper self-loop: the wrapper carries the name of the function it forwards to, so the
+# scope chain binds the qualified call to the wrapper itself.
+tidy <- function(d) {
+  locallib::tidy(d)
+}
+
+# Same-file decoy: `decoy_fn` is also defined below, in this very file.
+decoy_fn <- function(d) d
+
+local_user <- function(d) {
+  locallib::decoy_fn(d)
+}
+
+# Package whose directory name (renamed_impl) differs from its DESCRIPTION `Package:` (renamed).
+compute_it <- function(d) d
+
+renamed_user <- function(d) {
+  renamed::compute_it(d)
+}
+
+# `:::` reaches an unexported function of the named package.
+internal_user <- function(d) {
+  locallib:::hidden(d)
+}
+
+# Quoted, backticked and spaced qualifiers all name locallib.
+quoted_user <- function(d) {
+  "locallib"::quoted_fn(d)
+}
+
+backticked_user <- function(d) {
+  `locallib`::backticked_fn(d)
+}
+
+spaced_user <- function(d) {
+  locallib ::: spaced_fn(d)
+}
+
+# NAMESPACE importFrom(altlib, shared) decoy: the qualifier names locallib.
+importfrom_decoy_user <- function(d) {
+  locallib::shared(d)
+}
+
+# locallib re-exports `reexp_fn` from provlib and defines nothing of that name itself.
+reexport_user <- function(d) {
+  locallib::reexp_fn(d)
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/caller/scripts/run.R b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/caller/scripts/run.R
new file mode 100644
index 000000000..e2b694f5a
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/caller/scripts/run.R
@@ -0,0 +1,5 @@
+# Outside any package R/ directory. `library(altlib)` attaches altlib, but the call is
+# explicitly qualified with locallib.
+library(altlib)
+
+script_result <- locallib::libshared(1)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/duplib/DESCRIPTION b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/duplib/DESCRIPTION
new file mode 100644
index 000000000..71d252e92
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/duplib/DESCRIPTION
@@ -0,0 +1,3 @@
+Package: duplib
+Title: Qualified Call Fixture Duplicate Definitions
+Version: 0.1.0
diff --git a/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/duplib/NAMESPACE b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/duplib/NAMESPACE
new file mode 100644
index 000000000..f2394cf55
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/duplib/NAMESPACE
@@ -0,0 +1,2 @@
+export(twice)
+export(across)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/duplib/R/a.R b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/duplib/R/a.R
new file mode 100644
index 000000000..41e7005dc
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/duplib/R/a.R
@@ -0,0 +1,5 @@
+# Redefinition in the same file: the later definition wins in R.
+twice <- function(d) d
+twice <- function(d) d + 1
+
+across <- function(d) d
diff --git a/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/duplib/R/b.R b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/duplib/R/b.R
new file mode 100644
index 000000000..69e3e4add
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/duplib/R/b.R
@@ -0,0 +1,2 @@
+# A second definition of `across` in another file of the same package.
+across <- function(d) d * 2
diff --git a/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/locallib/DESCRIPTION b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/locallib/DESCRIPTION
new file mode 100644
index 000000000..80e614e6e
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/locallib/DESCRIPTION
@@ -0,0 +1,3 @@
+Package: locallib
+Title: Qualified Call Fixture Local Provider
+Version: 0.1.0
diff --git a/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/locallib/NAMESPACE b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/locallib/NAMESPACE
new file mode 100644
index 000000000..0ed19cfdc
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/locallib/NAMESPACE
@@ -0,0 +1,9 @@
+export(tidy)
+export(decoy_fn)
+export(quoted_fn)
+export(backticked_fn)
+export(shared)
+export(libshared)
+# Re-export: imported from provlib, never defined here.
+importFrom(provlib, reexp_fn)
+export(reexp_fn)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/locallib/R/functions.R b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/locallib/R/functions.R
new file mode 100644
index 000000000..5646550ed
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/locallib/R/functions.R
@@ -0,0 +1,6 @@
+tidy <- function(d) d
+decoy_fn <- function(d) d
+quoted_fn <- function(d) d
+backticked_fn <- function(d) d
+shared <- function(d) d
+libshared <- function(d) d
diff --git a/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/locallib/R/internal.R b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/locallib/R/internal.R
new file mode 100644
index 000000000..64f260a86
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/locallib/R/internal.R
@@ -0,0 +1,3 @@
+# Not exported: reachable only through `:::`.
+hidden <- function(d) d
+spaced_fn <- function(d) d
diff --git a/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/provlib/DESCRIPTION b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/provlib/DESCRIPTION
new file mode 100644
index 000000000..97c901d44
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/provlib/DESCRIPTION
@@ -0,0 +1,3 @@
+Package: provlib
+Title: Qualified Call Fixture Origin Provider
+Version: 0.1.0
diff --git a/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/provlib/NAMESPACE b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/provlib/NAMESPACE
new file mode 100644
index 000000000..f5f88aa78
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/provlib/NAMESPACE
@@ -0,0 +1,2 @@
+export(reexp_fn)
+export(mutate)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/provlib/R/prov.R b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/provlib/R/prov.R
new file mode 100644
index 000000000..df5d2a33e
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/provlib/R/prov.R
@@ -0,0 +1,3 @@
+reexp_fn <- function(d) d
+# Same name as dplyr::mutate, which callers write with an explicit external qualifier.
+mutate <- function(d) d
diff --git a/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/renamed_impl/DESCRIPTION b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/renamed_impl/DESCRIPTION
new file mode 100644
index 000000000..63280d4d7
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/renamed_impl/DESCRIPTION
@@ -0,0 +1,3 @@
+Package: renamed
+Title: Qualified Call Fixture Renamed Directory
+Version: 0.1.0
diff --git a/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/renamed_impl/NAMESPACE b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/renamed_impl/NAMESPACE
new file mode 100644
index 000000000..ef36bc936
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/renamed_impl/NAMESPACE
@@ -0,0 +1 @@
+export(compute_it)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/renamed_impl/R/compute.R b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/renamed_impl/R/compute.R
new file mode 100644
index 000000000..268baf606
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-qualified-calls/renamed_impl/R/compute.R
@@ -0,0 +1 @@
+compute_it <- function(d) d
diff --git a/gitnexus/test/fixtures/lang-resolution/r-root-package/DESCRIPTION b/gitnexus/test/fixtures/lang-resolution/r-root-package/DESCRIPTION
new file mode 100644
index 000000000..3d28aa284
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-root-package/DESCRIPTION
@@ -0,0 +1,3 @@
+Package: rootpkg
+Title: Root-level Test Package
+Version: 0.1.0
diff --git a/gitnexus/test/fixtures/lang-resolution/r-root-package/NAMESPACE b/gitnexus/test/fixtures/lang-resolution/r-root-package/NAMESPACE
new file mode 100644
index 000000000..7fd4d57cd
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-root-package/NAMESPACE
@@ -0,0 +1,3 @@
+export(RootExported)
+exportPattern("^Pat")
+S3method(print, RootWidget)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-root-package/R/exports.R b/gitnexus/test/fixtures/lang-resolution/r-root-package/R/exports.R
new file mode 100644
index 000000000..d48942d0c
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-root-package/R/exports.R
@@ -0,0 +1,11 @@
+RootExported <- function() {
+  RootHelper()
+}
+
+PatternMatched <- function() {
+  TRUE
+}
+
+print.RootWidget <- function(x, ...) {
+  invisible(x)
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-root-package/R/internal.R b/gitnexus/test/fixtures/lang-resolution/r-root-package/R/internal.R
new file mode 100644
index 000000000..733bb369b
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-root-package/R/internal.R
@@ -0,0 +1,3 @@
+RootHelper <- function() {
+  TRUE
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-roxygen-param-prose/R/model.R b/gitnexus/test/fixtures/lang-resolution/r-roxygen-param-prose/R/model.R
new file mode 100644
index 000000000..4f720392a
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-roxygen-param-prose/R/model.R
@@ -0,0 +1,5 @@
+Data <- R6::R6Class("Data",
+  public = list(
+    fit = function() 1
+  )
+)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-roxygen-param-prose/R/run.R b/gitnexus/test/fixtures/lang-resolution/r-roxygen-param-prose/R/run.R
new file mode 100644
index 000000000..1be963c07
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-roxygen-param-prose/R/run.R
@@ -0,0 +1,12 @@
+#' Fit a model.
+#'
+#' @param df Data frame of observations
+fit_from_prose <- function(df) {
+  df$fit()
+}
+
+#' Fit a model from a freshly built object.
+fit_from_constructor <- function() {
+  d <- Data$new()
+  d$fit()
+}
diff --git a/gitnexus/test/fixtures/lang-resolution/r-s4-anchors/R/base.R b/gitnexus/test/fixtures/lang-resolution/r-s4-anchors/R/base.R
new file mode 100644
index 000000000..7fc4e16e2
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-s4-anchors/R/base.R
@@ -0,0 +1,3 @@
+# Base class defined in its own file: a `contains = "Base"` elsewhere must not
+# mint a second Class named Base.
+setClass("Base", representation("VIRTUAL"))
diff --git a/gitnexus/test/fixtures/lang-resolution/r-s4-anchors/R/defs.R b/gitnexus/test/fixtures/lang-resolution/r-s4-anchors/R/defs.R
new file mode 100644
index 000000000..ad6c0b77a
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-s4-anchors/R/defs.R
@@ -0,0 +1,15 @@
+setClass("Abstract", contains = "VIRTUAL", slots = list(label = "character"))
+
+setRefClass("Ref", fields = list(count = "numeric"), contains = "Base")
+
+setClass("Derived", contains = "Base", slots = list(size = "numeric"))
+
+setGeneric("describe", function(x) standardGeneric("describe"), valueClass = "numeric")
+
+setGeneric(name = "summarise", def = function(x) standardGeneric("summarise"))
+
+setClass(Class = "Named", representation = representation(tag = "character"))
+
+setMethod("show", "Derived", function(object) cat("derived"))
+
+setMethod("describe", signature("Derived"), function(x) 1)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-s4-formals/R/defs.R b/gitnexus/test/fixtures/lang-resolution/r-s4-formals/R/defs.R
new file mode 100644
index 000000000..570eb5b63
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-s4-formals/R/defs.R
@@ -0,0 +1,13 @@
+setClass("Base", representation("VIRTUAL"))
+
+setClass(`Class` = "BacktickClass", contains = "Base")
+
+setClass("Class" = "QuotedClass", contains = "Base")
+
+setRefClass(`Class` = "BacktickRef", fields = list(n = "numeric"))
+
+setGeneric(`name` = "backtickGeneric", def = function(x) standardGeneric("backtickGeneric"), valueClass = "numeric")
+
+setClass("Plain", contains = "Base")
+
+setMethod(`f` = "backtickMethod", signature = "Plain", definition = function(object) 1)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-scope-args/R/classes.R b/gitnexus/test/fixtures/lang-resolution/r-scope-args/R/classes.R
new file mode 100644
index 000000000..8e858d0bb
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-scope-args/R/classes.R
@@ -0,0 +1,17 @@
+setClass("Base", representation("VIRTUAL"))
+
+setClass(
+  # abstract
+  "CommentVirtual", contains = "VIRTUAL")
+
+setClass(
+  # derived
+  "CommentChild", contains = "Base", slots = list(n = "numeric"))
+
+setClass("PlainVirtual", contains = "VIRTUAL")
+
+setClass(contains = "Base", Class = "NamedFirstChild")
+
+setClass(`Class` = "BacktickChild", contains = "Base", slots = list(m = "numeric"))
+
+setClass("Class" = "QuotedChild", contains = "VIRTUAL")
diff --git a/gitnexus/test/fixtures/lang-resolution/r-scope-args/libO/DESCRIPTION b/gitnexus/test/fixtures/lang-resolution/r-scope-args/libO/DESCRIPTION
new file mode 100644
index 000000000..506aeee77
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-scope-args/libO/DESCRIPTION
@@ -0,0 +1,3 @@
+Package: libO
+Title: Decoy library
+Version: 0.1.0
diff --git a/gitnexus/test/fixtures/lang-resolution/r-scope-args/libO/R/o.R b/gitnexus/test/fixtures/lang-resolution/r-scope-args/libO/R/o.R
new file mode 100644
index 000000000..9529a2525
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-scope-args/libO/R/o.R
@@ -0,0 +1 @@
+o_fn <- function(x) x
diff --git a/gitnexus/test/fixtures/lang-resolution/r-scope-args/pkgP/DESCRIPTION b/gitnexus/test/fixtures/lang-resolution/r-scope-args/pkgP/DESCRIPTION
new file mode 100644
index 000000000..c5bed0f54
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-scope-args/pkgP/DESCRIPTION
@@ -0,0 +1,3 @@
+Package: pkgP
+Title: Target package
+Version: 0.1.0
diff --git a/gitnexus/test/fixtures/lang-resolution/r-scope-args/pkgP/R/p.R b/gitnexus/test/fixtures/lang-resolution/r-scope-args/pkgP/R/p.R
new file mode 100644
index 000000000..0de5f9b54
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-scope-args/pkgP/R/p.R
@@ -0,0 +1 @@
+p_fn <- function(x) x
diff --git a/gitnexus/test/fixtures/lang-resolution/r-scope-args/scripts/envR.R b/gitnexus/test/fixtures/lang-resolution/r-scope-args/scripts/envR.R
new file mode 100644
index 000000000..b2c2d32b3
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-scope-args/scripts/envR.R
@@ -0,0 +1 @@
+env_fn <- function(x) x
diff --git a/gitnexus/test/fixtures/lang-resolution/r-scope-args/scripts/lib_backtick_formal.R b/gitnexus/test/fixtures/lang-resolution/r-scope-args/scripts/lib_backtick_formal.R
new file mode 100644
index 000000000..d1a3beafa
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-scope-args/scripts/lib_backtick_formal.R
@@ -0,0 +1 @@
+library(`package` = pkgP)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-scope-args/scripts/lib_comment_first.R b/gitnexus/test/fixtures/lang-resolution/r-scope-args/scripts/lib_comment_first.R
new file mode 100644
index 000000000..fc35144e4
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-scope-args/scripts/lib_comment_first.R
@@ -0,0 +1,4 @@
+library(
+  # the package
+  pkgP
+)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-scope-args/scripts/lib_named_first.R b/gitnexus/test/fixtures/lang-resolution/r-scope-args/scripts/lib_named_first.R
new file mode 100644
index 000000000..30603548a
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-scope-args/scripts/lib_named_first.R
@@ -0,0 +1 @@
+library(lib.loc = libO, pkgP)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-scope-args/scripts/lib_package_formal.R b/gitnexus/test/fixtures/lang-resolution/r-scope-args/scripts/lib_package_formal.R
new file mode 100644
index 000000000..1bb908cc9
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-scope-args/scripts/lib_package_formal.R
@@ -0,0 +1 @@
+library(package = pkgP)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-scope-args/scripts/lib_positive.R b/gitnexus/test/fixtures/lang-resolution/r-scope-args/scripts/lib_positive.R
new file mode 100644
index 000000000..6a7d32514
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-scope-args/scripts/lib_positive.R
@@ -0,0 +1 @@
+library(pkgP, lib.loc = libO)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-scope-args/scripts/q.R b/gitnexus/test/fixtures/lang-resolution/r-scope-args/scripts/q.R
new file mode 100644
index 000000000..d1004d955
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-scope-args/scripts/q.R
@@ -0,0 +1 @@
+q_fn <- function(x) x
diff --git a/gitnexus/test/fixtures/lang-resolution/r-scope-args/scripts/source_comment_first.R b/gitnexus/test/fixtures/lang-resolution/r-scope-args/scripts/source_comment_first.R
new file mode 100644
index 000000000..e767fef94
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-scope-args/scripts/source_comment_first.R
@@ -0,0 +1,4 @@
+source(
+  # the file
+  "q.R"
+)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-scope-args/scripts/source_file_formal.R b/gitnexus/test/fixtures/lang-resolution/r-scope-args/scripts/source_file_formal.R
new file mode 100644
index 000000000..9a9fb0cc9
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-scope-args/scripts/source_file_formal.R
@@ -0,0 +1 @@
+source(file = "q.R")
diff --git a/gitnexus/test/fixtures/lang-resolution/r-scope-args/scripts/source_named_first.R b/gitnexus/test/fixtures/lang-resolution/r-scope-args/scripts/source_named_first.R
new file mode 100644
index 000000000..7120e309f
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-scope-args/scripts/source_named_first.R
@@ -0,0 +1 @@
+source(local = envR, "q.R")
diff --git a/gitnexus/test/fixtures/lang-resolution/r-scope-args/scripts/source_positive.R b/gitnexus/test/fixtures/lang-resolution/r-scope-args/scripts/source_positive.R
new file mode 100644
index 000000000..ab94e4d5f
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-scope-args/scripts/source_positive.R
@@ -0,0 +1 @@
+source("q.R", local = envR)
diff --git a/gitnexus/test/fixtures/lang-resolution/r-scope-args/scripts/source_quoted_formal.R b/gitnexus/test/fixtures/lang-resolution/r-scope-args/scripts/source_quoted_formal.R
new file mode 100644
index 000000000..cc7a07d67
--- /dev/null
+++ b/gitnexus/test/fixtures/lang-resolution/r-scope-args/scripts/source_quoted_formal.R
@@ -0,0 +1 @@
+source("file" = "q.R")
diff --git a/gitnexus/test/fixtures/sample-code/simple.r b/gitnexus/test/fixtures/sample-code/simple.r
new file mode 100644
index 000000000..f2e0cdd93
--- /dev/null
+++ b/gitnexus/test/fixtures/sample-code/simple.r
@@ -0,0 +1,39 @@
+library(R6)
+source("helpers.R")
+
+#' Add two numbers.
+#' @param a numeric first operand
+#' @param b numeric second operand
+#' @export
+add <- function(a, b) {
+  a + b
+}
+
+private_helper <- function() {
+  0
+}
+
+setClass("Point", representation(x = "numeric", y = "numeric"))
+
+setGeneric("distance", function(obj, other) standardGeneric("distance"))
+
+setMethod("distance", "Point", function(obj, other) {
+  abs(obj@x - other@x) + abs(obj@y - other@y)
+})
+
+Counter <- R6::R6Class("Counter",
+  public = list(
+    count = 0,
+    increment = function() {
+      self$count <- self$count + 1
+      invisible(self)
+    }
+  )
+)
+
+run <- function() {
+  counter <- Counter$new()
+  counter$increment()
+  c(1, 2, 3) |> add(4) |> private_helper()
+  stats::median(c(1, 2, 3))
+}
diff --git a/gitnexus/test/helpers/grammar-introspection.ts b/gitnexus/test/helpers/grammar-introspection.ts
index d61af9b5d..9f74a80c7 100644
--- a/gitnexus/test/helpers/grammar-introspection.ts
+++ b/gitnexus/test/helpers/grammar-introspection.ts
@@ -59,6 +59,10 @@ const GRAMMAR_PACKAGES: Partial<Record<SupportedLanguages, { pkg: string; subpat
   [SupportedLanguages.Go]: { pkg: 'tree-sitter-go', subpaths: ['src/node-types.json'] },
   [SupportedLanguages.Ruby]: { pkg: 'tree-sitter-ruby', subpaths: ['src/node-types.json'] },
   [SupportedLanguages.Rust]: { pkg: 'tree-sitter-rust', subpaths: ['src/node-types.json'] },
+  [SupportedLanguages.R]: {
+    pkg: '@eagleoutice/tree-sitter-r',
+    subpaths: ['src/node-types.json'],
+  },
   // tree-sitter-php's runtime export is `php_only` (see parser-loader), so the
   // gate must validate against that variant's node set, not the embedded-HTML
   // `php` grammar.
diff --git a/gitnexus/test/helpers/literal-collectors.ts b/gitnexus/test/helpers/literal-collectors.ts
index 6172b739b..ffbee567d 100644
--- a/gitnexus/test/helpers/literal-collectors.ts
+++ b/gitnexus/test/helpers/literal-collectors.ts
@@ -83,6 +83,7 @@ const DIR_LANG: Record<string, SupportedLanguages> = {
   go: SupportedLanguages.Go,
   ruby: SupportedLanguages.Ruby,
   rust: SupportedLanguages.Rust,
+  r: SupportedLanguages.R,
   php: SupportedLanguages.PHP,
   kotlin: SupportedLanguages.Kotlin,
   swift: SupportedLanguages.Swift,
@@ -103,6 +104,7 @@ const BASENAME_LANGS: Record<string, SupportedLanguages[]> = {
   python: [SupportedLanguages.Python],
   ruby: [SupportedLanguages.Ruby],
   rust: [SupportedLanguages.Rust],
+  r: [SupportedLanguages.R],
   swift: [SupportedLanguages.Swift],
   typescript: [SupportedLanguages.TypeScript],
   javascript: [SupportedLanguages.JavaScript],
diff --git a/gitnexus/test/helpers/r-argument-scaling.ts b/gitnexus/test/helpers/r-argument-scaling.ts
new file mode 100644
index 000000000..f856dd931
--- /dev/null
+++ b/gitnexus/test/helpers/r-argument-scaling.ts
@@ -0,0 +1,96 @@
+/**
+ * Shared cost guard for the R argument-selection queries (the scope query and
+ * R_QUERIES). Both once had a quadratic formulation (an argument-prefix pattern
+ * repeated before the naming argument) that took seconds on one call with thousands
+ * of arguments.
+ *
+ * Absolute wall-clock limits are machine-dependent, so the guard compares the same
+ * work at two input sizes: linear work grows ~4x when the argument count is
+ * quadrupled, a quadratic query ~16x. Timings use the fastest of several runs and a
+ * floor on the small run, so scheduler noise on a loaded runner cannot inflate the
+ * ratio. Correctness of the output is asserted by the callers at both sizes, so an
+ * early return or an empty parse cannot pass as "fast".
+ */
+
+export const SMALL_N = 2000;
+export const LARGE_N = 8000;
+/** Linear is ~4; quadratic is ~16 or worse. */
+export const MAX_RATIO = 10;
+/** The small run is never treated as faster than this (below it, noise dominates). */
+const FLOOR_MS = 15;
+const REPEATS = 3;
+
+export interface ArgumentShape {
+  readonly name: string;
+  readonly build: (n: number) => string;
+}
+
+const named = (n: number) => Array.from({ length: n }, (_, k) => `a${k} = ${k}`).join(', ');
+const comments = (n: number) => Array.from({ length: n }, (_, k) => `# c${k}`).join('\n');
+const unnamedStrings = (n: number) => Array.from({ length: n }, (_, k) => `"s${k}"`).join(', ');
+const namedStrings = (n: number) =>
+  Array.from({ length: n }, (_, k) => `a${k} = "s${k}"`).join(', ');
+
+export const SHAPES = {
+  listNamedArguments: {
+    name: 'one call with many named arguments',
+    build: (n) => `x <- list(${named(n)})`,
+  },
+  setClassNamedBefore: {
+    name: 'setClass with many named arguments before the name',
+    build: (n) => `setClass(${named(n)}, "A")`,
+  },
+  libraryNamedBefore: {
+    name: 'library with many named arguments before the name',
+    build: (n) => `library(${named(n)}, pkg)`,
+  },
+  setClassCommentsBefore: {
+    name: 'setClass with many comments before the name',
+    build: (n) => `setClass(\n${comments(n)}\n"A")`,
+  },
+  libraryCommentsBefore: {
+    name: 'library with many comments before the name',
+    build: (n) => `library(\n${comments(n)}\npkg)`,
+  },
+  setClassUnnamedStrings: {
+    name: 'setClass with many unnamed arguments',
+    build: (n) => `setClass(${unnamedStrings(n)})`,
+  },
+  libraryUnnamedStrings: {
+    name: 'library with many unnamed arguments',
+    build: (n) => `library(${unnamedStrings(n)})`,
+  },
+  setClassNamedStrings: {
+    name: 'setClass with many named string arguments',
+    build: (n) => `setClass("A", ${namedStrings(n)})`,
+  },
+} as const satisfies Record<string, ArgumentShape>;
+
+/**
+ * Runs the work produced by `prepare(source)` at SMALL_N and LARGE_N and returns the
+ * results and the time ratio. `prepare` does the untimed set-up (e.g. parsing) and
+ * returns the thunk that is timed.
+ */
+export function measureScaling<T>(
+  prepare: (source: string) => () => T,
+  build: (n: number) => string,
+): { small: T; large: T; ratio: number } {
+  const run = (n: number) => {
+    const thunk = prepare(build(n));
+    let best = Infinity;
+    let result!: T;
+    for (let i = 0; i < REPEATS; i++) {
+      const start = performance.now();
+      result = thunk();
+      best = Math.min(best, performance.now() - start);
+    }
+    return { result, ms: best };
+  };
+  const small = run(SMALL_N);
+  const large = run(LARGE_N);
+  return {
+    small: small.result,
+    large: large.result,
+    ratio: large.ms / Math.max(small.ms, FLOOR_MS),
+  };
+}
diff --git a/gitnexus/test/integration/parsing.test.ts b/gitnexus/test/integration/parsing.test.ts
index f7295b759..2835148fe 100644
--- a/gitnexus/test/integration/parsing.test.ts
+++ b/gitnexus/test/integration/parsing.test.ts
@@ -883,6 +883,7 @@ describe('parsing', () => {
       'simple.cpp',
       'simple.cs',
       'simple.zig',
+      'simple.r',
     ];
 
     for (const fixture of fixtures) {
diff --git a/gitnexus/test/integration/query-compilation.test.ts b/gitnexus/test/integration/query-compilation.test.ts
index 6652a59bf..71d06a1bd 100644
--- a/gitnexus/test/integration/query-compilation.test.ts
+++ b/gitnexus/test/integration/query-compilation.test.ts
@@ -34,6 +34,7 @@ describe('Query compilation smoke tests', () => {
     [SupportedLanguages.Kotlin]: 'Test.kt',
     [SupportedLanguages.Swift]: 'test.swift',
     [SupportedLanguages.Dart]: 'test.dart',
+    [SupportedLanguages.R]: 'test.R',
   };
 
   // Known query compilation failures — remove from this set as PRs fix them
diff --git a/gitnexus/test/integration/r-post-parse-gating.test.ts b/gitnexus/test/integration/r-post-parse-gating.test.ts
new file mode 100644
index 000000000..a4c868c77
--- /dev/null
+++ b/gitnexus/test/integration/r-post-parse-gating.test.ts
@@ -0,0 +1,87 @@
+/**
+ * Language gating of R's post-parse work.
+ *
+ * R's package-config walk (`DESCRIPTION`/`NAMESPACE` discovery) and its whole-graph owner attach are
+ * language-specific work. Shared pipeline code must not run them for a repo that has no R files:
+ * a non-R repo pays nothing (no directory walk, no manifest read).
+ *
+ * Observation point: `node:fs/promises` `readFile`. `loadRPackageConfig` imports the module's default
+ * export, so a spy on that object sees the loader wherever it lives (before or after it moves into
+ * `languages/r/`). A depth-3 `DESCRIPTION` decoy makes the walk observable: reading it is impossible
+ * without the breadth-first search reaching it.
+ */
+import { describe, it, expect, afterAll, afterEach, vi } from 'vitest';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import fsp from 'node:fs/promises';
+import { runPipelineFromRepo, writeFixtureRepo } from './resolvers/helpers.js';
+import { cleanupTempDirSync } from '../helpers/test-db.js';
+import { rProvider } from '../../src/core/ingestion/languages/r.js';
+
+const MANIFEST = /[\\/](DESCRIPTION|NAMESPACE)$/;
+
+const roots: string[] = [];
+const makeRepo = (files: Record<string, string>): string => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'gn-r-post-parse-gating-'));
+  roots.push(root);
+  writeFixtureRepo(root, files);
+  return root;
+};
+
+const DECOYS = {
+  DESCRIPTION: 'Package: decoy\nVersion: 0.0.1\n',
+  NAMESPACE: 'export(f)\n',
+  'pkg/sub/deep/DESCRIPTION': 'Package: deepdecoy\nVersion: 0.0.1\n',
+  'pkg/sub/deep/NAMESPACE': 'export(g)\n',
+};
+
+const manifestReads = (spy: { mock: { calls: unknown[][] } }): string[] =>
+  spy.mock.calls
+    .map((args) => String(args[0]))
+    .filter((p) => MANIFEST.test(p))
+    .map((p) => p.replace(/\\/g, '/'));
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+afterAll(() => {
+  for (const root of roots) cleanupTempDirSync(root);
+});
+
+describe('R post-parse gating', () => {
+  // R's package-config walk runs inside `LanguageProvider.postParse`, which the parse phase calls only
+  // for languages with parsed files, so a repo with no R files never reads a manifest.
+  it('a non-R repo with DESCRIPTION/NAMESPACE decoys never reads a manifest', async () => {
+    const root = makeRepo({ 'src/main.py': 'def main():\n    return 1\n', ...DECOYS });
+    const readFile = vi.spyOn(fsp, 'readFile');
+
+    await runPipelineFromRepo(root, () => {});
+
+    expect(manifestReads(readFile)).toEqual([]);
+  }, 60000);
+
+  it('rProvider.postParse is never invoked for a non-R repo and once for an R repo', async () => {
+    const postParse = vi.spyOn(rProvider, 'postParse');
+
+    await runPipelineFromRepo(
+      makeRepo({ 'src/main.py': 'def main():\n    return 1\n', ...DECOYS }),
+      () => {},
+    );
+    expect(postParse).toHaveBeenCalledTimes(0);
+
+    await runPipelineFromRepo(makeRepo({ 'R/a.R': 'f <- function() 1\n', ...DECOYS }), () => {});
+    expect(postParse).toHaveBeenCalledTimes(1);
+  }, 120000);
+
+  it('control: an R repo with the same layout reads the root DESCRIPTION (the spy sees the loader)', async () => {
+    const root = makeRepo({ 'R/a.R': 'f <- function() 1\n', ...DECOYS });
+    const readFile = vi.spyOn(fsp, 'readFile');
+
+    await runPipelineFromRepo(root, () => {});
+
+    const reads = manifestReads(readFile);
+    expect(reads.some((p) => p === path.join(root, 'DESCRIPTION').replace(/\\/g, '/'))).toBe(true);
+  }, 60000);
+});
diff --git a/gitnexus/test/integration/r-worker-owner-absence.test.ts b/gitnexus/test/integration/r-worker-owner-absence.test.ts
new file mode 100644
index 000000000..f9510d207
--- /dev/null
+++ b/gitnexus/test/integration/r-worker-owner-absence.test.ts
@@ -0,0 +1,102 @@
+/**
+ * Standing invariant: the R worker never emits an owner id.
+ *
+ * R classes are calls (`R6::R6Class`, `setRefClass`, `setMethod`), not syntactic containers, so
+ * `findEnclosingClassNodeOrFileOwner` finds no container node for any R definition and the worker
+ * never stamps `ownerId` on an R node or symbol. The owner arrives later: the worker leaves an
+ * `ownerNameHint` string that the R post-parse pass resolves once every Class is registered.
+ *
+ * That "always absent" premise is what lets the worker-side `!enclosingClassId` guard be dropped when
+ * the hint moves into a `definitionPropertiesExtractor` (that context cannot express the guard), and
+ * what lets the all-language node `ownerId` spread go. The attach-side already-owned early return is
+ * the local backstop if the premise ever fails; this test keeps the premise honest.
+ *
+ * Runs the compiled worker over every `.R` file of the six r-* fixtures, before any post-parse.
+ * Requires `dist/`; skipped locally when it is missing, hard-fails on CI (as the other worker-backed
+ * suites do).
+ */
+import { describe, it, expect } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+import { FIXTURES } from './resolvers/helpers.js';
+import { distWorkerExists, parseFilesWithWorkers } from '../helpers/worker-parse.js';
+import type { ParseWorkerResult } from '../../src/core/ingestion/workers/parse-worker.js';
+
+const hasDistWorker = distWorkerExists();
+if (!hasDistWorker && process.env.CI) {
+  throw new Error(
+    'dist/parse-worker.js missing on CI — the R worker owner-absence test would silently skip. ' +
+      'Ensure the build runs before this suite.',
+  );
+}
+
+// fixture -> number of R Method/Property nodes carrying an ownerNameHint (== the post-parse ownerId
+// count before the attach moved behind the provider hook, because every hint in these fixtures resolves). 37 in total.
+const EXPECTED_HINTS: Record<string, number> = {
+  'r-packages': 22,
+  'r-root-package': 0,
+  'r-namespace-imports': 2,
+  'r-call-attribution': 10,
+  'r-native-pipes': 3,
+  'r-dotted-s3-collision': 0,
+};
+
+const collectRFiles = (
+  dir: string,
+  root: string,
+  out: { path: string; content: string }[] = [],
+) => {
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) collectRFiles(full, root, out);
+    else if (/\.[Rr]$/.test(entry.name)) {
+      out.push({
+        path: path.relative(root, full).split(path.sep).join('/'),
+        content: fs.readFileSync(full, 'utf-8'),
+      });
+    }
+  }
+  return out;
+};
+
+describe.skipIf(!hasDistWorker)('R worker never emits an owner id (before post-parse)', () => {
+  it.each(Object.entries(EXPECTED_HINTS))(
+    '%s: no R node or symbol carries ownerId; %i members carry ownerNameHint',
+    async (fixture, expectedHints) => {
+      const root = path.join(FIXTURES, fixture);
+      const files = collectRFiles(root, root);
+      expect(files.length).toBeGreaterThan(0);
+
+      const raw: ParseWorkerResult[] = [];
+      const { graph } = await parseFilesWithWorkers(files, { outRawResults: raw });
+
+      let ownedNodes = 0;
+      let hintedMembers = 0;
+      graph.forEachNode((n) => {
+        if (n.properties.language !== 'r') return;
+        if (n.properties.ownerId !== undefined) ownedNodes++;
+        if (
+          (n.label === 'Method' || n.label === 'Property') &&
+          typeof n.properties.ownerNameHint === 'string'
+        ) {
+          hintedMembers++;
+        }
+      });
+
+      let symbols = 0;
+      let ownedSymbols = 0;
+      for (const result of raw) {
+        for (const symbol of result.symbols) {
+          symbols++;
+          if (symbol.ownerId !== undefined) ownedSymbols++;
+        }
+      }
+
+      expect(symbols).toBeGreaterThan(0);
+      expect(ownedNodes).toBe(0);
+      expect(ownedSymbols).toBe(0);
+      expect(hintedMembers).toBe(expectedHints);
+    },
+    60000,
+  );
+});
diff --git a/gitnexus/test/integration/resolvers/callable-value-flow.test.ts b/gitnexus/test/integration/resolvers/callable-value-flow.test.ts
index 6e2942945..b7b7ed7b0 100644
--- a/gitnexus/test/integration/resolvers/callable-value-flow.test.ts
+++ b/gitnexus/test/integration/resolvers/callable-value-flow.test.ts
@@ -39,6 +39,9 @@ const CALLABLE_FLOW_PROVIDER_COVERAGE = {
   // Objective-C message sends are resolved by its ScopeResolver. The provider
   // does not emit callable-value-flow captures in this MVP.
   [SupportedLanguages.ObjectiveC]: 'not-applicable',
+  // R calls are resolved by its ScopeResolver. The provider does not emit
+  // callable-value-flow captures (no synthesizeCallableFlowCaptures use).
+  [SupportedLanguages.R]: 'not-applicable',
 } as const satisfies Record<SupportedLanguages, CallableFlowCoverage>;
 
 const PROVIDER_FLOW_CASES = [
diff --git a/gitnexus/test/integration/resolvers/r-dotted-cross-file.test.ts b/gitnexus/test/integration/resolvers/r-dotted-cross-file.test.ts
new file mode 100644
index 000000000..8849ef078
--- /dev/null
+++ b/gitnexus/test/integration/resolvers/r-dotted-cross-file.test.ts
@@ -0,0 +1,58 @@
+/**
+ * R: a call that spells a dotted function name (`helper.util(x)`, `print.widget(x)`)
+ * in another file, with no import naming it.
+ *
+ * `rIsCallableVisibleFromCaller` refuses every candidate whose qualified name contains
+ * a `.`, so that a bare `foo(x)` cannot reach `print.foo`. The free-call fallback's
+ * simple-name index keys a def by the text after its last `.`, so a call spelled
+ * `helper.util` never finds `helper.util` there, and the hook has nothing to refuse for
+ * it. The call binds in the later qualified-name pass (reason `scope-resolution: call`,
+ * confidence 0.35) instead. This file pins that: the hook's blanket rejection does not
+ * drop a dotted call (with the hook disabled every edge below is unchanged).
+ *
+ * Layout: `prov/R/defs.R` defines `helper.util`, `print.widget` and `plain_fn`; callers
+ * are in the same package (`prov/R/use.R`), another package (`other/R/use.R`) that does
+ * not import `prov`, a script that `library(prov)`s, and a script with no import at all.
+ */
+import { describe, it, expect, beforeAll } from 'vitest';
+import path from 'path';
+import { FIXTURES, getRelationships, runPipelineFromRepo, type PipelineResult } from './helpers.js';
+
+describe('R dotted function names called across files', () => {
+  let result: PipelineResult;
+
+  beforeAll(async () => {
+    result = await runPipelineFromRepo(path.join(FIXTURES, 'r-dotted-cross-file'), () => {});
+  }, 60000);
+
+  /** `target:targetFile:reason:confidence` of every CALLS edge from `source`. */
+  const edges = (source: string): string[] =>
+    getRelationships(result, 'CALLS')
+      .filter((e) => e.source === source)
+      .map((e) => `${e.target}:${e.targetFilePath}:${e.rel.reason}:${e.rel.confidence}`)
+      .sort();
+
+  const DEFS = 'prov/R/defs.R';
+  const QUALIFIED = 'scope-resolution: call:0.35';
+
+  it('binds a dotted call in the same package through the qualified-name pass', () => {
+    expect(edges('same_pkg_helper')).toEqual([`helper.util:${DEFS}:${QUALIFIED}`]);
+    expect(edges('same_pkg_print')).toEqual([`print.widget:${DEFS}:${QUALIFIED}`]);
+  });
+
+  it('binds a dotted call from a package that does not import the provider', () => {
+    expect(edges('other_helper')).toEqual([`helper.util:${DEFS}:${QUALIFIED}`]);
+    expect(edges('other_print')).toEqual([`print.widget:${DEFS}:${QUALIFIED}`]);
+  });
+
+  it('binds a dotted call from a script with library(prov) and from one with no import', () => {
+    expect(edges('script_helper')).toEqual([`helper.util:${DEFS}:${QUALIFIED}`]);
+    expect(edges('script_print')).toEqual([`print.widget:${DEFS}:${QUALIFIED}`]);
+    expect(edges('bare_helper')).toEqual([`helper.util:${DEFS}:${QUALIFIED}`]);
+  });
+
+  it('control: an undotted cross-file call still goes through the global-name fallback (0.5)', () => {
+    expect(edges('same_pkg_plain')).toEqual([`plain_fn:${DEFS}:global-name-fallback:0.5`]);
+    expect(edges('other_plain')).toEqual([`plain_fn:${DEFS}:global-name-fallback:0.5`]);
+  });
+});
diff --git a/gitnexus/test/integration/resolvers/r-dotted-s3-collision.test.ts b/gitnexus/test/integration/resolvers/r-dotted-s3-collision.test.ts
new file mode 100644
index 000000000..53ebac51d
--- /dev/null
+++ b/gitnexus/test/integration/resolvers/r-dotted-s3-collision.test.ts
@@ -0,0 +1,111 @@
+/**
+ * R: dotted (S3 method) names must not collide with same-tailed bare names
+ * in the shared simple-name indexes.
+ *
+ * The shared indexes key every def by the text after the last `.` of its
+ * qualifiedName, so `print.foo` is indexed under `foo` next to a bare `foo`.
+ * Two defects followed: a `library(prov)` wildcard bound `foo` to `print.foo`
+ * when the S3 method was declared first (a wrong 0.85 edge), and a bare
+ * cross-file call `foo(v)` saw two candidates and got no edge at all.
+ *
+ * Fixture layout: `prov/R/prov.R` declares `print.foo` BEFORE `foo`, `bar`
+ * BEFORE `print.bar`, `summary.baz` after `baz`, a control `qux` with no S3
+ * method and a backticked `odd name`; `cons/` and `scripts/run.R` reach them
+ * through `library(prov)`; `prov/R/other.R` calls them from the same package.
+ */
+import { describe, it, expect, beforeAll } from 'vitest';
+import path from 'path';
+import { FIXTURES, getRelationships, runPipelineFromRepo, type PipelineResult } from './helpers.js';
+
+describe('R dotted (S3) names vs same-tailed bare names', () => {
+  let result: PipelineResult;
+
+  beforeAll(async () => {
+    result = await runPipelineFromRepo(path.join(FIXTURES, 'r-dotted-s3-collision'), () => {});
+  }, 60000);
+
+  /** `target:targetFile:reason:confidence` of every CALLS edge from `source` in `fileSuffix`. */
+  const edges = (source: string, fileSuffix: string): string[] =>
+    getRelationships(result, 'CALLS')
+      .filter((e) => e.source === source && e.sourceFilePath.endsWith(fileSuffix))
+      .map((e) => `${e.target}:${e.targetFilePath}:${e.rel.reason}:${e.rel.confidence}`)
+      .sort();
+
+  const PROV = 'prov/R/prov.R';
+
+  describe('library(prov) wildcard import', () => {
+    it('binds foo to the bare def, never to print.foo declared before it', () => {
+      const e = edges('use_foo', 'cons/R/cons.R');
+      expect(e.filter((x) => x.startsWith('print.foo:'))).toEqual([]);
+      expect(e).toEqual([`foo:${PROV}:global-name-fallback:0.5`]);
+    });
+
+    it('also keeps a script caller (no package NAMESPACE) off print.foo', () => {
+      expect(edges('script_foo', 'scripts/run.R')).toEqual([
+        `foo:${PROV}:global-name-fallback:0.5`,
+      ]);
+    });
+
+    it('reversed declaration order (bare bar before print.bar) resolves to the bare def', () => {
+      expect(edges('use_bar', 'cons/R/cons.R')).toEqual([`bar:${PROV}:global-name-fallback:0.5`]);
+      expect(edges('script_bar', 'scripts/run.R')).toEqual([
+        `bar:${PROV}:global-name-fallback:0.5`,
+      ]);
+    });
+
+    it('bare name with an S3 method declared after it (baz / summary.baz) resolves to the bare def', () => {
+      expect(edges('use_baz', 'cons/R/cons.R')).toEqual([`baz:${PROV}:global-name-fallback:0.5`]);
+    });
+
+    it('control: a name with no same-tailed S3 method is still import-resolved at 0.85', () => {
+      expect(edges('use_qux', 'cons/R/cons.R')).toEqual([`qux:${PROV}:import-resolved:0.85`]);
+      expect(edges('script_qux', 'scripts/run.R')).toEqual([`qux:${PROV}:import-resolved:0.85`]);
+    });
+  });
+
+  describe('same-package cross-file bare calls', () => {
+    const OTHER = 'prov/R/other.R';
+
+    it('foo(v) gets a fallback edge to the bare def (was: no edge, two tail candidates)', () => {
+      expect(edges('same_pkg_foo', OTHER)).toEqual([`foo:${PROV}:global-name-fallback:0.5`]);
+    });
+
+    it('bar(v) and baz(v) resolve to the bare defs', () => {
+      expect(edges('same_pkg_bar', OTHER)).toEqual([`bar:${PROV}:global-name-fallback:0.5`]);
+      expect(edges('same_pkg_baz', OTHER)).toEqual([`baz:${PROV}:global-name-fallback:0.5`]);
+    });
+
+    it('control: qux(v) keeps its fallback edge', () => {
+      expect(edges('same_pkg_qux', OTHER)).toEqual([`qux:${PROV}:global-name-fallback:0.5`]);
+    });
+  });
+
+  describe('dotted call sites', () => {
+    it('print.foo(x) in the same package resolves to the S3 def via qualified lookup (0.35)', () => {
+      expect(edges('dotted_call', 'prov/R/other.R')).toEqual([
+        `print.foo:${PROV}:scope-resolution: call:0.35`,
+      ]);
+    });
+
+    it('print.foo(x) through library(prov) resolves to the S3 def (0.35)', () => {
+      expect(edges('use_dotted', 'cons/R/cons.R')).toEqual([
+        `print.foo:${PROV}:scope-resolution: call:0.35`,
+      ]);
+    });
+  });
+
+  describe('backticked names (characterisation, unchanged by this fix)', () => {
+    it('a backticked def keeps its backticks in the name and still resolves like any bare name', () => {
+      // The qualifiedName keeps the backticks, so the wildcard binds the literal name and a
+      // same-package call falls back to a unique-name guess. There is no dotted tail involved;
+      // pinned so a future change to backtick handling is a deliberate decision.
+      expect({
+        cons: edges('use_odd', 'cons/R/cons.R'),
+        samePkg: edges('same_pkg_odd', 'prov/R/other.R'),
+      }).toEqual({
+        cons: [`\`odd name\`:${PROV}:import-resolved:0.85`],
+        samePkg: [`\`odd name\`:${PROV}:global-name-fallback:0.5`],
+      });
+    });
+  });
+});
diff --git a/gitnexus/test/integration/resolvers/r-qualified-calls.test.ts b/gitnexus/test/integration/resolvers/r-qualified-calls.test.ts
new file mode 100644
index 000000000..c71eb1df2
--- /dev/null
+++ b/gitnexus/test/integration/resolvers/r-qualified-calls.test.ts
@@ -0,0 +1,272 @@
+/**
+ * R `pkg::fn()` / `pkg:::fn()` qualified calls.
+ *
+ * Fixtures: `r-qualified-calls/` (package discovery completes: certainly-external
+ * qualifiers exist), `r-qualified-calls-truncated/` (discovery stops at depth 3 and a
+ * package nested deeper is invisible, so its locality is UNKNOWN) and
+ * `r-qualified-calls-deep-fixtures/` (a `tests/testthat/fixtures` directory below the depth
+ * limit holds no package, so discovery still counts as complete), `r-no-description/` (a
+ * repo with no DESCRIPTION: discovery completes with zero packages, so every qualifier is
+ * external) and `r-no-description-truncated/` (zero packages found, but a skipped subtree
+ * hides one, so locality is UNKNOWN).
+ *
+ * The qualifier names the package:
+ *   - exactly one definition of the name in a local package  -> precise binding (0.85);
+ *   - two or more definitions in that package (same-file redefinition or across files)
+ *     -> the site is dropped, no edge (every valid target is inside the named package);
+ *   - certainly external package (discovery complete, not local) -> dropped, no edge;
+ *   - local package with ZERO definitions (re-export), or UNKNOWN locality -> the site is
+ *     kept: today's behaviour, unchanged;
+ *   - the global-name-fallback veto allows a candidate inside the named package.
+ *
+ * Six tests assert the qualifier-aware result rather than a name-only guess (each is marked
+ * "qualifier flip"): five in the integration suite `r.test.ts` and one in the unit suite
+ * `scope-resolution/r/r-namespace-imports.test.ts`. The `pkgB::CleanData` tests in `r.test.ts`
+ * ("resolves cross-package pkgB::CleanData call" and "binds the pkgB::CleanData call by
+ * import instead of the name guess") stay green: one definition, bound by import already.
+ */
+import { describe, it, expect, beforeAll } from 'vitest';
+import path from 'path';
+import { FIXTURES, getRelationships, type PipelineResult, runPipelineFromRepo } from './helpers.js';
+
+const summaries = (result: PipelineResult, sourceName: string, file: string): string[] =>
+  getRelationships(result, 'CALLS')
+    .filter((e) => e.source === sourceName && e.sourceFilePath === file)
+    .map((e) => `${e.target}:${e.targetFilePath}:${e.rel.reason}:${e.rel.confidence}`)
+    .sort();
+
+/** One qualified-call caller and the edge set the qualifier must produce. */
+interface Case {
+  readonly title: string;
+  readonly caller: string;
+  readonly file: string;
+  readonly after: readonly string[];
+}
+
+const L = 'caller/R/local_calls.R';
+const LOCAL = 'locallib/R/functions.R';
+
+describe('R qualified calls: discovery completes (r-qualified-calls)', () => {
+  let result: PipelineResult;
+
+  beforeAll(async () => {
+    result = await runPipelineFromRepo(path.join(FIXTURES, 'r-qualified-calls'), () => {});
+  }, 60000);
+
+  const cases: readonly Case[] = [
+    {
+      title: 'wrapper self-loop: tidy() forwarding to locallib::tidy() binds to itself',
+      caller: 'tidy',
+      file: L,
+      after: [`tidy:${LOCAL}:import-resolved:0.85`],
+    },
+    {
+      title: 'same-file decoy: locallib::decoy_fn() binds to the decoy defined in the caller file',
+      caller: 'local_user',
+      file: L,
+      after: [`decoy_fn:${LOCAL}:import-resolved:0.85`],
+    },
+    {
+      title: 'package directory name differs from DESCRIPTION Package: (renamed_impl -> renamed)',
+      caller: 'renamed_user',
+      file: L,
+      after: ['compute_it:renamed_impl/R/compute.R:import-resolved:0.85'],
+    },
+    {
+      title: 'pkg:::name reaches an unexported definition of the named local package',
+      caller: 'internal_user',
+      file: L,
+      after: ['hidden:locallib/R/internal.R:import-resolved:0.85'],
+    },
+    {
+      title: 'quoted qualifier "locallib"::quoted_fn()',
+      caller: 'quoted_user',
+      file: L,
+      after: [`quoted_fn:${LOCAL}:import-resolved:0.85`],
+    },
+    {
+      title: 'backticked qualifier `locallib`::backticked_fn()',
+      caller: 'backticked_user',
+      file: L,
+      after: [`backticked_fn:${LOCAL}:import-resolved:0.85`],
+    },
+    {
+      title: 'spaced qualifier locallib ::: spaced_fn()',
+      caller: 'spaced_user',
+      file: L,
+      after: ['spaced_fn:locallib/R/internal.R:import-resolved:0.85'],
+    },
+    {
+      title: 'importFrom(altlib, shared) decoy: the qualifier names locallib',
+      caller: 'importfrom_decoy_user',
+      file: L,
+      after: [`shared:${LOCAL}:import-resolved:0.85`],
+    },
+    {
+      title: 'library(altlib) decoy in a script: the qualifier names locallib',
+      caller: 'run.R',
+      file: 'caller/scripts/run.R',
+      after: [`libshared:${LOCAL}:import-resolved:0.85`],
+    },
+    {
+      title: 'duplicate definitions, same-file redefinition in duplib (decoy in the caller file)',
+      caller: 'dup_same_file_user',
+      file: 'caller/R/duplicate_calls.R',
+      after: [],
+    },
+    {
+      title: 'duplicate definitions across two files of duplib (decoy in the caller file)',
+      caller: 'dup_cross_file_user',
+      file: 'caller/R/duplicate_calls.R',
+      after: [],
+    },
+    {
+      title: 'certainly external dplyr::filter() with a same-file decoy',
+      caller: 'external_same_file_user',
+      file: 'caller/R/external_calls.R',
+      after: [],
+    },
+    {
+      title: 'certainly external dplyr::mutate() colliding with a definition in another package',
+      caller: 'external_other_pkg_user',
+      file: 'caller/R/external_calls.R',
+      after: [],
+    },
+    {
+      title: 'certainly external dplyr:::internal_helper() with a same-file decoy',
+      caller: 'external_internal_user',
+      file: 'caller/R/external_calls.R',
+      after: [],
+    },
+  ];
+
+  for (const c of cases) {
+    describe(c.title, () => {
+      it(`${c.caller}: the qualifier decides the edge`, () => {
+        expect(summaries(result, c.caller, c.file)).toEqual([...c.after]);
+      });
+    });
+  }
+
+  describe('local package with zero definitions of the name (re-export): site kept', () => {
+    // locallib re-exports reexp_fn from provlib. The design keeps the site, and the global-name-fallback veto
+    // must keep allowing a candidate outside the named package when that package defines
+    // nothing of that name (same allowance the importFrom veto already has). Permanent.
+    it('keeps the 0.5 fallback edge to the origin package', () => {
+      expect(summaries(result, 'reexport_user', L)).toEqual([
+        'reexp_fn:provlib/R/prov.R:global-name-fallback:0.5',
+      ]);
+    });
+  });
+
+  describe('callers outside the case table', () => {
+    it('emits no CALLS edge out of the caller package from any other source', () => {
+      const callers = new Set(
+        getRelationships(result, 'CALLS')
+          .filter((e) => e.sourceFilePath.startsWith('caller/'))
+          .map((e) => e.source),
+      );
+      // Dropped callers (external, duplicate-definition) have no edge, so only a subset check holds.
+      const known = new Set([...cases.map((c) => c.caller), 'reexport_user']);
+      expect([...callers].filter((s) => !known.has(s))).toEqual([]);
+    });
+  });
+});
+
+describe('R qualified calls: discovery truncated (r-qualified-calls-truncated)', () => {
+  let result: PipelineResult;
+
+  beforeAll(async () => {
+    result = await runPipelineFromRepo(
+      path.join(FIXTURES, 'r-qualified-calls-truncated'),
+      () => {},
+    );
+  }, 60000);
+
+  const F = 'caller/R/calls.R';
+
+  // Permanent: locality is UNKNOWN, so the sites are kept and today's edges must not change.
+  it('keeps the same-file edge of a qualifier naming a package invisible to discovery', () => {
+    // invisiblepkg lives in deep/a/b/c/impl (depth 5, directory name != Package:). Nothing shows
+    // it is local, and nothing shows it is external: today's scope-chain edge stays.
+    expect(summaries(result, 'unknown_user', F)).toEqual([`unk_fn:${F}:local-call:0.85`]);
+  });
+
+  it('does not treat a qualifier as certainly external while discovery is truncated', () => {
+    expect(summaries(result, 'truncated_external_user', F)).toEqual([
+      `filter:${F}:local-call:0.85`,
+    ]);
+  });
+
+  describe('package without DESCRIPTION whose files sit under <pkg>/R/', () => {
+    const PATH_FN = 'deep/a/b/c/pathpkg/R/p.R';
+
+    // Local through the path segment (no DESCRIPTION), exactly one definition -> precise.
+    it('path_local_user: bound to the pathpkg definition, not the same-file decoy', () => {
+      expect(summaries(result, 'path_local_user', F)).toEqual([
+        `path_fn:${PATH_FN}:import-resolved:0.85`,
+      ]);
+    });
+  });
+});
+
+describe('R qualified calls: skipped directory without a package (r-qualified-calls-deep-fixtures)', () => {
+  let result: PipelineResult;
+
+  beforeAll(async () => {
+    result = await runPipelineFromRepo(
+      path.join(FIXTURES, 'r-qualified-calls-deep-fixtures'),
+      () => {},
+    );
+  }, 60000);
+
+  const F = 'caller/R/calls.R';
+
+  // Headline case: the depth-3 skip of tests/testthat/fixtures must not make `dplyr` unknown.
+  it('drops dplyr::filter() instead of binding it to the same-file decoy filter()', () => {
+    expect(summaries(result, 'external_user', F)).toEqual([]);
+  });
+
+  it('still binds a qualifier naming the discovered package precisely', () => {
+    expect(summaries(result, 'own_user', F)).toEqual([
+      'own_fn:caller/R/util.R:import-resolved:0.85',
+    ]);
+  });
+});
+
+describe('R qualified calls: no DESCRIPTION anywhere (r-no-description)', () => {
+  let result: PipelineResult;
+
+  beforeAll(async () => {
+    result = await runPipelineFromRepo(path.join(FIXTURES, 'r-no-description'), () => {});
+  }, 60000);
+
+  // Discovery completed and found zero packages, so no qualifier can name a local package.
+  it('drops dplyr::filter() instead of binding it to a same-named function elsewhere', () => {
+    expect(summaries(result, 'run_ext', 'R/b.R')).toEqual([]);
+  });
+
+  it('drops dplyr::mutate() called from a script instead of binding it to R/a.R', () => {
+    expect(summaries(result, 'run_same', 'scripts/run.R')).toEqual([]);
+  });
+
+  it('drops dplyr::select() instead of binding it to the same-file decoy', () => {
+    expect(summaries(result, 'run_decoy', 'scripts/run.R')).toEqual([]);
+  });
+});
+
+describe('R qualified calls: no package found and discovery truncated (r-no-description-truncated)', () => {
+  let result: PipelineResult;
+
+  beforeAll(async () => {
+    result = await runPipelineFromRepo(path.join(FIXTURES, 'r-no-description-truncated'), () => {});
+  }, 60000);
+
+  // Permanent guard: zero packages found, but a skipped subtree hides one, so the
+  // qualifier is not provably external and today's name guess must stay.
+  it('keeps the name-guess edge while discovery is truncated', () => {
+    expect(summaries(result, 'run_ext', 'R/b.R')).toEqual([
+      'filter:R/a.R:global-name-fallback:0.5',
+    ]);
+  });
+});
diff --git a/gitnexus/test/integration/resolvers/r-roxygen-param.test.ts b/gitnexus/test/integration/resolvers/r-roxygen-param.test.ts
new file mode 100644
index 000000000..a3a843025
--- /dev/null
+++ b/gitnexus/test/integration/resolvers/r-roxygen-param.test.ts
@@ -0,0 +1,27 @@
+/**
+ * R: a roxygen `@param` description is prose, not a type. The type
+ * environment is the only place a roxygen type is held, and no graph edge
+ * consumes it, so this pins the end-to-end outcome: a function documented
+ * `@param df Data frame ...` is not linked to the unrelated R6 class `Data`.
+ */
+import { describe, it, expect, beforeAll } from 'vitest';
+import path from 'path';
+import { FIXTURES, getRelationships, runPipelineFromRepo, type PipelineResult } from './helpers.js';
+
+describe('R roxygen @param prose does not type a receiver', () => {
+  let result: PipelineResult;
+
+  beforeAll(async () => {
+    result = await runPipelineFromRepo(path.join(FIXTURES, 'r-roxygen-param-prose'), () => {});
+  }, 60000);
+
+  it('links a receiver typed by a constructor call to the class method (positive control)', () => {
+    const calls = getRelationships(result, 'CALLS');
+    expect(calls.some((e) => e.source === 'fit_from_constructor' && e.target === 'fit')).toBe(true);
+  });
+
+  it('does not link a receiver documented only by a prose description to the class method', () => {
+    const calls = getRelationships(result, 'CALLS');
+    expect(calls.filter((e) => e.source === 'fit_from_prose')).toEqual([]);
+  });
+});
diff --git a/gitnexus/test/integration/resolvers/r-s4-anchors.test.ts b/gitnexus/test/integration/resolvers/r-s4-anchors.test.ts
new file mode 100644
index 000000000..39e08dec7
--- /dev/null
+++ b/gitnexus/test/integration/resolvers/r-s4-anchors.test.ts
@@ -0,0 +1,80 @@
+/**
+ * R: S4/RefClass definitions are named by the call's first argument only. A string
+ * in any other argument (`contains = "Base"`, `valueClass = "numeric"`, the class
+ * slot of `setMethod("show", "Derived", ...)`) is not a definition, so it must not
+ * mint a graph node. End-to-end companion to the `R_QUERIES` unit test.
+ */
+import { describe, it, expect, beforeAll } from 'vitest';
+import path from 'path';
+import { FIXTURES, getRelationships, getNodesByLabel, runPipelineFromRepo } from './helpers.js';
+import type { PipelineResult } from './helpers.js';
+
+function nodesByLabel(result: PipelineResult, label: string): { id: string; name: string }[] {
+  const out: { id: string; name: string }[] = [];
+  result.graph.forEachNode((n) => {
+    if (n.label === label) out.push({ id: n.id, name: n.properties.name as string });
+  });
+  return out;
+}
+
+describe('R S4/RefClass definitions are named by their first argument only', () => {
+  let result: PipelineResult;
+
+  beforeAll(async () => {
+    result = await runPipelineFromRepo(path.join(FIXTURES, 'r-s4-anchors'), () => {});
+  }, 60000);
+
+  it('defines every setClass / setRefClass class exactly once (positive control)', () => {
+    expect(getNodesByLabel(result, 'Class').filter((n) => n !== 'VIRTUAL')).toEqual([
+      'Abstract',
+      'Base',
+      'Derived',
+      'Named',
+      'Ref',
+    ]);
+  });
+
+  it('mints no file-scoped Class from contains = "VIRTUAL"', () => {
+    const virtual = nodesByLabel(result, 'Class').filter((n) => n.name === 'VIRTUAL');
+    expect(virtual.map((n) => n.id)).toEqual(['Class:VIRTUAL']);
+  });
+
+  it('still emits EXTENDS Abstract -> VIRTUAL to the single placeholder node', () => {
+    const edge = getRelationships(result, 'EXTENDS').find(
+      (e) => e.source === 'Abstract' && e.target === 'VIRTUAL',
+    );
+    expect(edge?.rel.targetId).toBe('Class:VIRTUAL');
+  });
+
+  it('does not duplicate a base class named only by contains = "Base"', () => {
+    expect(nodesByLabel(result, 'Class').filter((n) => n.name === 'Base')).toHaveLength(1);
+  });
+
+  it('keeps the EXTENDS edges to the base class defined in the other file', () => {
+    const extends_ = getRelationships(result, 'EXTENDS');
+    expect(extends_.some((e) => e.source === 'Ref' && e.target === 'Base')).toBe(true);
+    expect(extends_.some((e) => e.source === 'Derived' && e.target === 'Base')).toBe(true);
+  });
+
+  it('defines the generics once, with no Function from valueClass = "numeric"', () => {
+    const functions = getNodesByLabel(result, 'Function');
+    expect(functions.filter((n) => n === 'describe')).toHaveLength(1);
+    expect(functions.filter((n) => n === 'summarise')).toHaveLength(1);
+    expect(functions).not.toContain('numeric');
+  });
+
+  it('defines the setMethod method once, owned by the class named in the signature', () => {
+    const methods = getNodesByLabel(result, 'Method');
+    expect(methods.filter((n) => n === 'show')).toHaveLength(1);
+    expect(methods.filter((n) => n === 'describe')).toHaveLength(1);
+    expect(methods).not.toContain('Derived');
+    const hasMethod = getRelationships(result, 'HAS_METHOD').filter((e) => e.source === 'Derived');
+    // `signature("Derived")` (a call, not a string) names no owner today; that is
+    // unchanged by the anchor, so only the string-signature `show` is owned.
+    expect(hasMethod.map((e) => e.target)).toEqual(['show']);
+  });
+
+  it('keeps slot, field and representation properties', () => {
+    expect(getNodesByLabel(result, 'Property')).toEqual(['count', 'label', 'size', 'tag']);
+  });
+});
diff --git a/gitnexus/test/integration/resolvers/r-s4-formals.test.ts b/gitnexus/test/integration/resolvers/r-s4-formals.test.ts
new file mode 100644
index 000000000..4621d6440
--- /dev/null
+++ b/gitnexus/test/integration/resolvers/r-s4-formals.test.ts
@@ -0,0 +1,42 @@
+/**
+ * R: a formal spelled with backticks or quotes (`Class` = "A", "Class" = "A")
+ * names the definition exactly like the bare spelling. Runs through the real
+ * pipeline; the plain forms in the same file are the positive controls.
+ */
+import { describe, it, expect, beforeAll } from 'vitest';
+import path from 'path';
+import { FIXTURES, getRelationships, getNodesByLabel, runPipelineFromRepo } from './helpers.js';
+import type { PipelineResult } from './helpers.js';
+
+describe('R S4 definitions named by a backticked or quoted formal', () => {
+  let result: PipelineResult;
+
+  beforeAll(async () => {
+    result = await runPipelineFromRepo(path.join(FIXTURES, 'r-s4-formals'), () => {});
+  }, 60000);
+
+  it('defines each class once, from the string that follows the formal', () => {
+    expect(getNodesByLabel(result, 'Class').filter((n) => n !== 'VIRTUAL')).toEqual(
+      ['Base', 'BacktickClass', 'BacktickRef', 'Plain', 'QuotedClass'].sort(),
+    );
+  });
+
+  it('keeps the EXTENDS edge of a plain class and of each formal spelling', () => {
+    const extends_ = getRelationships(result, 'EXTENDS');
+    for (const source of ['Plain', 'BacktickClass', 'QuotedClass']) {
+      expect(extends_.some((e) => e.source === source && e.target === 'Base')).toBe(true);
+    }
+  });
+
+  it('defines the generic from name = with no Function from valueClass', () => {
+    const functions = getNodesByLabel(result, 'Function');
+    expect(functions).toContain('backtickGeneric');
+    expect(functions).not.toContain('numeric');
+  });
+
+  it('defines the method from f = with no Method from the signature', () => {
+    const methods = getNodesByLabel(result, 'Method');
+    expect(methods).toContain('backtickMethod');
+    expect(methods).not.toContain('Plain');
+  });
+});
diff --git a/gitnexus/test/integration/resolvers/r-scope-args.test.ts b/gitnexus/test/integration/resolvers/r-scope-args.test.ts
new file mode 100644
index 000000000..b7e785044
--- /dev/null
+++ b/gitnexus/test/integration/resolvers/r-scope-args.test.ts
@@ -0,0 +1,110 @@
+/**
+ * R: the scope query picks the argument that names an import or an S4 class.
+ * `library(lib.loc = libO, pkgP)` imports `pkgP` (not `libO`), a comment before
+ * the first argument does not hide it, and `package =` / `file =` / `Class =` still
+ * name theirs. Runs through the real pipeline (worker pool and scope resolution),
+ * each negative paired with a positive control for the same call.
+ */
+import { describe, it, expect, beforeAll } from 'vitest';
+import path from 'path';
+import { FIXTURES, getRelationships, runPipelineFromRepo } from './helpers.js';
+import type { PipelineResult } from './helpers.js';
+
+describe('R scope query: naming argument of imports and S4 classes', () => {
+  let result: PipelineResult;
+
+  beforeAll(async () => {
+    result = await runPipelineFromRepo(path.join(FIXTURES, 'r-scope-args'), () => {});
+  }, 60000);
+
+  /** Sorted unique IMPORTS target files of `sourceFile` (fixture-root-relative). */
+  const importTargets = (sourceFile: string): string[] =>
+    [
+      ...new Set(
+        getRelationships(result, 'IMPORTS')
+          .filter((e) => e.sourceFilePath === sourceFile)
+          .map((e) => e.targetFilePath),
+      ),
+    ].sort();
+
+  describe('library()', () => {
+    it('imports the package named by the first argument (positive control)', () => {
+      expect(importTargets('scripts/lib_positive.R')).toEqual(['pkgP/R/p.R']);
+    });
+
+    it('imports the package named by package =', () => {
+      expect(importTargets('scripts/lib_package_formal.R')).toEqual(['pkgP/R/p.R']);
+    });
+
+    it('does not import a named-first argument such as lib.loc =', () => {
+      expect(importTargets('scripts/lib_named_first.R')).toEqual(['pkgP/R/p.R']);
+    });
+
+    it('imports the package when a comment precedes the first argument', () => {
+      expect(importTargets('scripts/lib_comment_first.R')).toEqual(['pkgP/R/p.R']);
+    });
+  });
+
+  describe('backticked and quoted formals', () => {
+    it('imports the package named by a backticked package =', () => {
+      expect(importTargets('scripts/lib_backtick_formal.R')).toEqual(['pkgP/R/p.R']);
+    });
+
+    it('imports the file named by a quoted file =', () => {
+      expect(importTargets('scripts/source_quoted_formal.R')).toEqual(['scripts/q.R']);
+    });
+
+    it('keeps the Class node and its EXTENDS edges for a backticked or quoted Class =', () => {
+      const extends_ = getRelationships(result, 'EXTENDS');
+      expect(extends_.some((e) => e.source === 'BacktickChild' && e.target === 'Base')).toBe(true);
+      expect(extends_.some((e) => e.source === 'QuotedChild' && e.target === 'VIRTUAL')).toBe(true);
+    });
+  });
+
+  describe('source()', () => {
+    it('imports the file named by the first argument (positive control)', () => {
+      expect(importTargets('scripts/source_positive.R')).toEqual(['scripts/q.R']);
+    });
+
+    it('imports the file named by file =', () => {
+      expect(importTargets('scripts/source_file_formal.R')).toEqual(['scripts/q.R']);
+    });
+
+    it('imports the first unnamed argument after a named one such as local =', () => {
+      expect(importTargets('scripts/source_named_first.R')).toEqual(['scripts/q.R']);
+    });
+
+    it('imports the file when a comment precedes the first argument', () => {
+      expect(importTargets('scripts/source_comment_first.R')).toEqual(['scripts/q.R']);
+    });
+  });
+
+  describe('setClass() heritage', () => {
+    const extendsEdge = (source: string, target: string) =>
+      getRelationships(result, 'EXTENDS').some((e) => e.source === source && e.target === target);
+
+    it('links a class to VIRTUAL (positive control)', () => {
+      expect(extendsEdge('PlainVirtual', 'VIRTUAL')).toBe(true);
+    });
+
+    it('links a class to VIRTUAL when a comment precedes the class name', () => {
+      expect(extendsEdge('CommentVirtual', 'VIRTUAL')).toBe(true);
+    });
+
+    it('links a class to its base when a comment precedes the class name', () => {
+      expect(extendsEdge('CommentChild', 'Base')).toBe(true);
+    });
+
+    it('links a class declared with Class = after a named contains =', () => {
+      expect(extendsEdge('NamedFirstChild', 'Base')).toBe(true);
+    });
+
+    it('declares the base class once (contains = names no class)', () => {
+      const bases: string[] = [];
+      result.graph.forEachNode((n) => {
+        if (n.label === 'Class' && n.properties.name === 'Base') bases.push(n.id);
+      });
+      expect(bases).toEqual(['Class:R/classes.R:Base']);
+    });
+  });
+});
diff --git a/gitnexus/test/integration/resolvers/r.test.ts b/gitnexus/test/integration/resolvers/r.test.ts
new file mode 100644
index 000000000..76c21d58b
--- /dev/null
+++ b/gitnexus/test/integration/resolvers/r.test.ts
@@ -0,0 +1,1447 @@
+/**
+ * R: function definitions (<- and = assignment), S4/R5/R6 classes,
+ *    library/require imports, source() includes, pkg::func namespaced calls,
+ *    roxygen2 doc parsing, cross-package resolution, heritage
+ */
+import { describe, it, expect, beforeAll } from 'vitest';
+import path from 'path';
+import {
+  FIXTURES,
+  getRelationships,
+  getNodesByLabel,
+  getNodesByLabelFull,
+  runPipelineFromRepo,
+  type PipelineResult,
+} from './helpers.js';
+
+describe('R function definitions and calls', () => {
+  let result: PipelineResult;
+
+  beforeAll(async () => {
+    result = await runPipelineFromRepo(path.join(FIXTURES, 'r-packages'), () => {});
+  }, 60000);
+
+  // --- Function detection ---
+
+  it('detects functions defined with <- assignment', () => {
+    const functions = getNodesByLabel(result, 'Function');
+    expect(functions).toContain('AddOutlierStatuses');
+    expect(functions).toContain('CleanData');
+  });
+
+  it('detects functions defined with = assignment', () => {
+    const functions = getNodesByLabel(result, 'Function');
+    expect(functions).toContain('HelperFunc');
+  });
+
+  it('detects functions defined with <<- super-assignment', () => {
+    const functions = getNodesByLabel(result, 'Function');
+    expect(functions).toContain('SuperAssignFunc');
+  });
+
+  it('detects functions with dot-separated names', () => {
+    const functions = getNodesByLabel(result, 'Function');
+    expect(functions).toContain('my.helper.func');
+  });
+
+  // --- Class detection ---
+
+  it('detects S4 class defined with setClass', () => {
+    const classes = getNodesByLabel(result, 'Class');
+    expect(classes).toContain('DataModel');
+  });
+
+  it('detects R5 class defined with setRefClass', () => {
+    const classes = getNodesByLabel(result, 'Class');
+    expect(classes).toContain('DataProcessor');
+  });
+
+  it('detects R6 class defined with R6::R6Class', () => {
+    const classes = getNodesByLabel(result, 'Class');
+    expect(classes).toContain('ResultSet');
+  });
+
+  it('detects R6 class defined with bare R6Class() call', () => {
+    const classes = getNodesByLabel(result, 'Class');
+    expect(classes).toContain('BareR6');
+  });
+
+  // --- Import resolution ---
+
+  it('resolves source() to IMPORTS edge', () => {
+    const imports = getRelationships(result, 'IMPORTS');
+    const sourceEdge = imports.find(
+      (e) => e.sourceFilePath.includes('run_analysis.R') && e.targetFilePath.includes('utils.R'),
+    );
+    expect(sourceEdge).toBeDefined();
+  });
+
+  it('resolves library() to IMPORTS edges for all package files', () => {
+    const imports = getRelationships(result, 'IMPORTS');
+    const libTargets = imports
+      .filter((e) => e.sourceFilePath === 'scripts/run_analysis.R')
+      .map((e) => e.targetFilePath)
+      .filter((t) => t.startsWith('pkgB/'))
+      .sort();
+    // library("pkgB") fans out to exactly the files of pkgB (no pkgA/pkgC leakage, no extras).
+    expect(libTargets).toEqual([
+      'pkgB/R/clean_data.R',
+      'pkgB/R/export_namespace_variants.R',
+      'pkgB/R/export_scope.R',
+      'pkgB/R/s4_export_test.R',
+    ]);
+  });
+
+  it('resolves require() to IMPORTS edges for package files', () => {
+    const imports = getRelationships(result, 'IMPORTS');
+    const requireTargets = imports
+      .filter((e) => e.sourceFilePath === 'scripts/run_analysis.R')
+      .map((e) => e.targetFilePath)
+      .filter((t) => t.startsWith('pkgA/R/'))
+      .sort();
+    // require("pkgA") (and source("pkgA/R/utils.R")) cover exactly the files of pkgA.
+    expect(requireTargets).toEqual([
+      'pkgA/R/add_outliers.R',
+      'pkgA/R/dot_names.R',
+      'pkgA/R/export_scope.R',
+      'pkgA/R/models.R',
+      'pkgA/R/r6_advanced.R',
+      'pkgA/R/r6_bare.R',
+      'pkgA/R/s3.R',
+      'pkgA/R/s4_and_r6.R',
+      'pkgA/R/s4_multi_parent.R',
+      'pkgA/R/super_assign.R',
+      'pkgA/R/utils.R',
+    ]);
+  });
+
+  // --- Cross-package resolution ---
+
+  it('resolves cross-package pkgB::CleanData call', () => {
+    const calls = getRelationships(result, 'CALLS');
+    const crossPkg = calls.find(
+      (e) => e.target === 'CleanData' && e.targetFilePath.includes('clean_data.R'),
+    );
+    expect(crossPkg).toBeDefined();
+  });
+
+  // --- Call resolution ---
+
+  it('resolves source()-imported function calls', () => {
+    const calls = getRelationships(result, 'CALLS');
+    const helperCall = calls.find(
+      (e) => e.sourceFilePath.includes('run_analysis.R') && e.target === 'HelperFunc',
+    );
+    expect(helperCall).toBeDefined();
+  });
+
+  // --- R6 method detection ---
+
+  it('detects R6 methods inside public = list(...)', () => {
+    const methods = getNodesByLabel(result, 'Method');
+    expect(methods).toContain('initialize');
+    expect(methods).toContain('count');
+  });
+
+  it('detects R5 methods inside setRefClass(... methods = list(...))', () => {
+    const methods = getNodesByLabel(result, 'Method');
+    expect(methods).toContain('process');
+  });
+
+  it('emits HAS_METHOD edges from R6 class to its methods', () => {
+    const hasMethod = getRelationships(result, 'HAS_METHOD');
+    const r6Methods = hasMethod.filter((e) => e.source === 'ResultSet');
+    expect(r6Methods.map((e) => e.target).sort()).toEqual(['count', 'initialize']);
+  });
+
+  it('emits HAS_METHOD edge from R5 class to its methods', () => {
+    const hasMethod = getRelationships(result, 'HAS_METHOD');
+    const r5Methods = hasMethod.filter((e) => e.source === 'DataProcessor');
+    expect(r5Methods.some((e) => e.target === 'process')).toBe(true);
+  });
+
+  // --- R6 private methods and fields ---
+
+  it('detects R6 private methods inside private = list(...)', () => {
+    const methods = getNodesByLabel(result, 'Method');
+    expect(methods).toContain('compute');
+  });
+
+  it('emits HAS_METHOD edge from R6 class to private method', () => {
+    const hasMethod = getRelationships(result, 'HAS_METHOD');
+    const privateMethod = hasMethod.find(
+      (e) => e.source === 'AdvancedR6' && e.target === 'compute',
+    );
+    expect(privateMethod).toBeDefined();
+  });
+
+  it('detects R6 private fields with correct visibility', () => {
+    const properties = getNodesByLabelFull(result, 'Property');
+    const secretKey = properties.find(
+      (p) => p.name === 'secret_key' && p.properties.filePath.includes('r6_advanced.R'),
+    );
+    expect(secretKey).toBeDefined();
+    expect(secretKey!.properties.visibility).toBe('private');
+  });
+
+  // --- R6 active bindings ---
+
+  it('detects R6 active bindings as methods', () => {
+    const methods = getNodesByLabel(result, 'Method');
+    expect(methods).toContain('display_name');
+  });
+
+  it('emits HAS_METHOD edge from R6 class to active binding', () => {
+    const hasMethod = getRelationships(result, 'HAS_METHOD');
+    const activeBinding = hasMethod.find(
+      (e) => e.source === 'AdvancedR6' && e.target === 'display_name',
+    );
+    expect(activeBinding).toBeDefined();
+  });
+
+  it('detects methods inside bare R6Class() call', () => {
+    const hasMethod = getRelationships(result, 'HAS_METHOD');
+    const bareMethod = hasMethod.find((e) => e.source === 'BareR6' && e.target === 'get_value');
+    expect(bareMethod).toBeDefined();
+  });
+
+  // --- R6 field type inference ---
+
+  it('infers R6 field types from default values', () => {
+    const properties = getNodesByLabelFull(result, 'Property');
+
+    const nameField = properties.find(
+      (p) => p.name === 'name' && p.properties.filePath.includes('r6_advanced.R'),
+    );
+    expect(nameField).toBeDefined();
+    expect(nameField!.properties.declaredType).toBe('character');
+
+    const countField = properties.find(
+      (p) => p.name === 'active_count' && p.properties.filePath.includes('r6_advanced.R'),
+    );
+    expect(countField).toBeDefined();
+    expect(countField!.properties.declaredType).toBe('integer');
+
+    const flagField = properties.find(
+      (p) => p.name === 'internal_flag' && p.properties.filePath.includes('r6_advanced.R'),
+    );
+    expect(flagField).toBeDefined();
+    expect(flagField!.properties.declaredType).toBe('logical');
+  });
+
+  it('resolves rs$count() call to ResultSet.count method', () => {
+    const calls = getRelationships(result, 'CALLS');
+    const countCall = calls.find(
+      (e) =>
+        e.sourceFilePath.includes('run_analysis.R') &&
+        e.target === 'count' &&
+        e.targetFilePath.includes('models.R'),
+    );
+    expect(countCall).toBeDefined();
+  });
+
+  // --- S4 setGeneric / setMethod detection ---
+
+  it('detects S4 setGeneric as a function definition', () => {
+    const functions = getNodesByLabel(result, 'Function');
+    expect(functions).toContain('validate');
+  });
+
+  it('detects S4 setMethod as a method definition', () => {
+    const methods = getNodesByLabel(result, 'Method');
+    expect(methods).toContain('validate');
+  });
+
+  it('emits HAS_METHOD edge from S4 class to setMethod implementation', () => {
+    const hasMethod = getRelationships(result, 'HAS_METHOD');
+    const s4Methods = hasMethod.filter((e) => e.source === 'DataModel');
+    expect(s4Methods.some((e) => e.target === 'validate')).toBe(true);
+  });
+
+  // --- R6 inherit= heritage ---
+
+  it('emits EXTENDS edge from R6 Child class via inherit= (namespace call)', () => {
+    const extends_ = getRelationships(result, 'EXTENDS');
+    const childEdge = extends_.find((e) => e.source === 'Child' && e.target === 'Parent');
+    expect(childEdge).toBeDefined();
+  });
+
+  it('detects S4 classes from multi-parent setClass with contains=c()', () => {
+    const classes = getNodesByLabel(result, 'Class');
+    expect(classes).toContain('MultiChild');
+    expect(classes).toContain('BaseA');
+    expect(classes).toContain('BaseB');
+  });
+
+  it('emits EXTENDS edges from S4 multi-parent setClass with contains=c()', () => {
+    const extends_ = getRelationships(result, 'EXTENDS');
+    const toBaseA = extends_.find((e) => e.source === 'MultiChild' && e.target === 'BaseA');
+    const toBaseB = extends_.find((e) => e.source === 'MultiChild' && e.target === 'BaseB');
+    expect(toBaseA).toBeDefined();
+    expect(toBaseB).toBeDefined();
+  });
+
+  it('emits EXTENDS edge from S4 class with single-parent contains=', () => {
+    const extends_ = getRelationships(result, 'EXTENDS');
+    const edge = extends_.find((e) => e.source === 'DataModel' && e.target === 'VIRTUAL');
+    expect(edge).toBeDefined();
+    // The target is the single placeholder minted for the `"VIRTUAL"` sentinel, not
+    // a file-scoped Class from the `contains = "VIRTUAL"` string.
+    expect(edge?.rel.targetId).toBe('Class:VIRTUAL');
+    const virtualIds: string[] = [];
+    result.graph.forEachNode((n) => {
+      if (n.label === 'Class' && n.properties.name === 'VIRTUAL') virtualIds.push(n.id);
+    });
+    expect(virtualIds).toEqual(['Class:VIRTUAL']);
+  });
+
+  it('emits EXTENDS edge from R6 class defined with bare R6Class() via inherit=', () => {
+    const extends_ = getRelationships(result, 'EXTENDS');
+    const bareEdge = extends_.find((e) => e.source === 'BareR6' && e.target === 'Parent');
+    expect(bareEdge).toBeDefined();
+  });
+
+  it('applies NAMESPACE exports per package instead of as a repo-wide name set', () => {
+    const functions = getNodesByLabelFull(result, 'Function').filter(
+      (n) => n.name === 'PackageScoped',
+    );
+    const pkgAFunction = functions.find((n) =>
+      n.properties.filePath.includes('pkgA/R/export_scope.R'),
+    );
+    const pkgBFunction = functions.find((n) =>
+      n.properties.filePath.includes('pkgB/R/export_scope.R'),
+    );
+
+    expect(pkgAFunction).toBeDefined();
+    expect(pkgBFunction).toBeDefined();
+    expect(pkgAFunction?.properties.isExported).toBe(true);
+    expect(pkgBFunction?.properties.isExported).toBe(false);
+  });
+
+  it('applies exportPattern and S3method directives from NAMESPACE', () => {
+    const functions = getNodesByLabelFull(result, 'Function');
+    const patternScoped = functions.find(
+      (n) =>
+        n.name === 'PatternScoped' &&
+        n.properties.filePath.includes('pkgB/R/export_namespace_variants.R'),
+    );
+    const s3Method = functions.find(
+      (n) =>
+        n.name === 'print.FancyWidget' &&
+        n.properties.filePath.includes('pkgB/R/export_namespace_variants.R'),
+    );
+
+    expect(patternScoped?.properties.isExported).toBe(true);
+    expect(s3Method?.properties.isExported).toBe(true);
+  });
+
+  it('applies exportClasses() and exportMethods() directives from NAMESPACE', () => {
+    const classes = getNodesByLabelFull(result, 'Class');
+    const exportedClass = classes.find(
+      (n) =>
+        n.name === 'ExportedS4Class' && n.properties.filePath.includes('pkgB/R/s4_export_test.R'),
+    );
+    expect(exportedClass).toBeDefined();
+    expect(exportedClass!.properties.isExported).toBe(true);
+
+    const functions = getNodesByLabelFull(result, 'Function');
+    const exportedMethod = functions.find(
+      (n) =>
+        n.name === 'exportedMethod' && n.properties.filePath.includes('pkgB/R/s4_export_test.R'),
+    );
+    expect(exportedMethod).toBeDefined();
+    expect(exportedMethod!.properties.isExported).toBe(true);
+  });
+
+  it('defaults all functions to exported when no NAMESPACE file exists', () => {
+    const functions = getNodesByLabelFull(result, 'Function');
+    const roxygenFunc = functions.find(
+      (n) =>
+        n.name === 'RoxygenExported' && n.properties.filePath.includes('pkgC/R/default_export.R'),
+    );
+    const noTagFunc = functions.find(
+      (n) => n.name === 'NoExportTag' && n.properties.filePath.includes('pkgC/R/default_export.R'),
+    );
+
+    expect(roxygenFunc).toBeDefined();
+    expect(noTagFunc).toBeDefined();
+    // Without NAMESPACE, rExportChecker defaults to true for all functions
+    expect(roxygenFunc!.properties.isExported).toBe(true);
+    expect(noTagFunc!.properties.isExported).toBe(true);
+  });
+
+  it('populates field metadata on R Property nodes', () => {
+    const properties = getNodesByLabelFull(result, 'Property');
+
+    const slotName = properties.find(
+      (p) => p.name === 'name' && p.properties.filePath.includes('pkgA/R/models.R'),
+    );
+    expect(slotName).toBeDefined();
+    expect(slotName!.properties.visibility).toBe('public');
+    expect(slotName!.properties.declaredType).toBe('character');
+
+    const dataField = properties.find(
+      (p) => p.name === 'data' && p.properties.filePath.includes('pkgA/R/models.R'),
+    );
+    expect(dataField).toBeDefined();
+    expect(dataField!.properties.visibility).toBe('public');
+    expect(dataField!.properties.declaredType).toBe('data.frame');
+
+    const itemsField = properties.find(
+      (p) => p.name === 'items' && p.properties.filePath.includes('pkgA/R/models.R'),
+    );
+    expect(itemsField).toBeDefined();
+    expect(itemsField!.properties.visibility).toBe('public');
+  });
+});
+
+/**
+ * Files the R provider must not index. The `r-non-indexed` fixture holds a
+ * `.Rprofile`, `.Renviron`, `.Rmd` and `.qmd`, each defining a function, next to a plain
+ * `real.R` positive control (docs/languages/r-provider.md, "Limits").
+ */
+describe('R files that are not indexed', () => {
+  let result: PipelineResult;
+
+  beforeAll(async () => {
+    result = await runPipelineFromRepo(path.join(FIXTURES, 'r-non-indexed'), () => {});
+  }, 60000);
+
+  it('indexes the plain .R control file (so the negatives below are not vacuous)', () => {
+    expect(getNodesByLabel(result, 'Function')).toEqual(['indexed_control']);
+  });
+
+  // The scanner may still record a bare File node for these; what must not exist is any
+  // parsed symbol (Function, Variable, ...) from them.
+  it.each(['.Rprofile', '.Renviron', 'analysis.Rmd', 'report.qmd'])(
+    'creates no symbol node for %s',
+    (name) => {
+      const hits: string[] = [];
+      result.graph.forEachNode((n) => {
+        if (n.label !== 'File' && n.properties.filePath?.endsWith(name)) {
+          hits.push(`${n.label}:${n.properties.name}`);
+        }
+      });
+      expect(hits).toEqual([]);
+    },
+  );
+
+  it('defines no function from the non-indexed files', () => {
+    const functions = getNodesByLabel(result, 'Function');
+    expect(functions).not.toContain('rprofile_fn');
+    expect(functions).not.toContain('rmd_fn');
+    expect(functions).not.toContain('qmd_fn');
+  });
+});
+
+/**
+ * R caller attribution (each call is credited to the callable that lexically contains it).
+ *
+ * Every call site's CALLS source must be the callable that lexically contains it
+ * (named function, nested named function, R6/R5 method) or, when no named
+ * callable encloses it, the File node; a call inside a class body but outside
+ * any method (an R6 field default, an S4 `setClass(validity = function..)`
+ * body) is sourced from the enclosing Class node by design.
+ *
+ * Each attribution case has a plain characterisation twin (the target
+ * edge exists from ANY source).
+ * One assertion per `it`. Process / Community / STEP_IN_PROCESS / MEMBER_OF /
+ * CALLS totals are NOT asserted: they shift whenever attribution changes.
+ */
+describe('R caller attribution', () => {
+  let result: PipelineResult;
+
+  beforeAll(async () => {
+    result = await runPipelineFromRepo(path.join(FIXTURES, 'r-call-attribution'), () => {});
+  }, 60000);
+
+  /** Sorted unique CALLS targets of the source named `sourceName` in the file ending `fileSuffix`. */
+  const callsFrom = (sourceName: string, fileSuffix: string): string[] =>
+    [
+      ...new Set(
+        getRelationships(result, 'CALLS')
+          .filter((e) => e.source === sourceName && e.sourceFilePath.endsWith(fileSuffix))
+          .map((e) => e.target),
+      ),
+    ].sort();
+
+  /** Sorted `Label:name` of every CALLS source in the file ending `fileSuffix` that targets `target`. */
+  const sourceKeys = (fileSuffix: string, target: string): string[] =>
+    getRelationships(result, 'CALLS')
+      .filter((e) => e.sourceFilePath.endsWith(fileSuffix) && e.target === target)
+      .map((e) => `${e.sourceLabel}:${e.source}`)
+      .sort();
+
+  /** Targets from `expected` that NO source in the file calls (twin: the edge exists from any source). */
+  const missingTargets = (fileSuffix: string, expected: string[]): string[] => {
+    const present = new Set(
+      getRelationships(result, 'CALLS')
+        .filter((e) => e.sourceFilePath.endsWith(fileSuffix))
+        .map((e) => e.target),
+    );
+    return expected.filter((t) => !present.has(t));
+  };
+
+  const countNodes = (label: string): number => {
+    let n = 0;
+    result.graph.forEachNode((node) => {
+      if (node.label === label) n++;
+    });
+    return n;
+  };
+  const countRels = (type: string): number => {
+    let n = 0;
+    for (const rel of result.graph.iterRelationships()) if (rel.type === type) n++;
+    return n;
+  };
+
+  // ─── named_forms.R ────────────────────────────────────────────────────────
+  describe('named_forms.R', () => {
+    const F = 'R/named_forms.R';
+    const own: Array<[string, string]> = [
+      ['arrow_fn', 'leaf_b'],
+      ['equals_fn', 'leaf_c'],
+      ['super_fn', 'leaf_d'],
+      ['lambda_fn', 'leaf_e'],
+      ['dotted.name.fn', 'leaf_f'],
+      ['`backtick name fn`', 'leaf_g'],
+      ['pair_one', 'leaf_h'],
+      ['pair_two', 'leaf_i'],
+      ['cond_fn', 'leaf_j'],
+      ['default_arg_fn', 'leaf_k'],
+    ];
+
+    it('the decoy first function still has its own edge', () => {
+      expect(callsFrom('decoy_named', F)).toContain('leaf_a');
+    });
+
+    it('the decoy first function has ONLY its own edge', () => {
+      expect(callsFrom('decoy_named', F)).toEqual(['leaf_a']);
+    });
+
+    for (const [fn, leaf] of own) {
+      it(`${fn} is the sole source of ${leaf}`, () => {
+        expect(callsFrom(fn, F)).toEqual([leaf]);
+      });
+    }
+
+    it('twin: every named-form target has an edge from some source', () => {
+      expect(
+        missingTargets(F, ['leaf_a', ...own.map(([, leaf]) => leaf), 'leaf_l', 'leaf_x']),
+      ).toEqual([]);
+    });
+
+    it('the obj$member_fn body call is sourced from the File node', () => {
+      expect(sourceKeys(F, 'leaf_l')).toEqual(['File:named_forms.R']);
+    });
+
+    it('the module-level `res <- leaf_x(1)` call is sourced from the File node', () => {
+      expect(sourceKeys(F, 'leaf_x')).toEqual(['File:named_forms.R']);
+    });
+  });
+
+  // ─── nesting.R ────────────────────────────────────────────────────────────
+  describe('nesting.R', () => {
+    const F = 'R/nesting.R';
+
+    it('the decoy first function has exactly its own edge', () => {
+      expect(callsFrom('decoy_nesting', F)).toEqual(['leaf_m']);
+    });
+
+    it('outer calls exactly inner and its lambda / FUN= / tryCatch leaves', () => {
+      expect(callsFrom('outer', F)).toEqual(['inner', 'leaf_o', 'leaf_p', 'leaf_q', 'leaf_r']);
+    });
+
+    it('inner calls exactly its own leaf', () => {
+      expect(callsFrom('inner', F)).toEqual(['leaf_n']);
+    });
+
+    it('there is no inner -> inner self-loop', () => {
+      expect(callsFrom('inner', F).includes('inner')).toBe(false);
+    });
+
+    for (const [what, leaf] of [
+      ['the lapply lambda', 'leaf_o'],
+      ['the FUN = function argument', 'leaf_p'],
+      ['the tryCatch expression', 'leaf_q'],
+      ['the tryCatch error = function handler', 'leaf_r'],
+    ]) {
+      it(`${what} call to ${leaf} is sourced from outer`, () => {
+        expect(sourceKeys(F, leaf)).toEqual(['Function:outer']);
+      });
+    }
+
+    it('level1 calls exactly level2 and leaf_u', () => {
+      expect(callsFrom('level1', F)).toEqual(['leaf_u', 'level2']);
+    });
+
+    it('level2 calls exactly level3 and leaf_t', () => {
+      expect(callsFrom('level2', F)).toEqual(['leaf_t', 'level3']);
+    });
+
+    it('level3 calls exactly leaf_s', () => {
+      expect(callsFrom('level3', F)).toEqual(['leaf_s']);
+    });
+
+    it('twin: every nested-function target has an edge from some source', () => {
+      expect(
+        missingTargets(F, [
+          'inner',
+          'leaf_n',
+          'leaf_o',
+          'leaf_p',
+          'leaf_q',
+          'leaf_r',
+          'level2',
+          'level3',
+          'leaf_s',
+          'leaf_t',
+          'leaf_u',
+        ]),
+      ).toEqual([]);
+    });
+  });
+
+  // ─── r6_methods.R ─────────────────────────────────────────────────────────
+  describe('r6_methods.R', () => {
+    const F = 'R/r6_methods.R';
+    const perMethod: Array<[string, string[]]> = [
+      ['first', ['leaf_y']],
+      ['run', ['helper', 'leaf_aa']],
+      ['relay', ['peer']],
+      ['peer', ['leaf_ab']],
+      ['hidden', ['leaf_ac']],
+      ['shown', ['leaf_ad']],
+      ['helper', ['leaf_z']],
+      ['bump', ['leaf_ae']],
+      ['reset', ['leaf_af']],
+    ];
+
+    it('the decoy first function has exactly its own edge', () => {
+      expect(callsFrom('decoy_r6', F)).toEqual(['leaf_v']);
+    });
+
+    for (const [method, targets] of perMethod) {
+      it(`${method} calls exactly ${targets.join(', ')}`, () => {
+        expect(callsFrom(method, F)).toEqual(targets);
+      });
+    }
+
+    it('twin: every R6 / R5 target has an edge from some source', () => {
+      expect(
+        missingTargets(F, [
+          'leaf_y',
+          'helper',
+          'leaf_aa',
+          'peer',
+          'leaf_ab',
+          'leaf_ac',
+          'leaf_ad',
+          'leaf_z',
+          'leaf_ae',
+          'leaf_af',
+          'leaf_w',
+        ]),
+      ).toEqual([]);
+    });
+
+    it('self$peer() resolves to the peer method from some Method in the class', () => {
+      expect(sourceKeys(F, 'peer').map((k) => k.split(':')[0])).toEqual(['Method']);
+    });
+
+    it('self$peer() is sourced from the method containing it, not the first method', () => {
+      expect(sourceKeys(F, 'peer')).toEqual(['Method:relay']);
+    });
+
+    it('the public field default `cache = leaf_w()` is sourced from the Class node', () => {
+      expect(sourceKeys(F, 'leaf_w')).toEqual(['Class:Widget']);
+    });
+  });
+
+  // ─── s4.R ─────────────────────────────────────────────────────────────────
+  describe('s4.R', () => {
+    const F = 'R/s4.R';
+
+    it('the decoy first function has ONLY its own edge (S4 negative)', () => {
+      expect(callsFrom('decoy_s4', F)).toEqual(['leaf_ag']);
+    });
+
+    it('the setMethod body call is not sourced from a named function', () => {
+      // Negative only: the File-source outcome is a documented limitation, not locked.
+      expect(sourceKeys(F, 'leaf_ah').filter((k) => !k.startsWith('File:'))).toEqual([]);
+    });
+
+    it('twin: the setMethod body call has an edge from some source', () => {
+      expect(missingTargets(F, ['leaf_ag', 'leaf_ah'])).toEqual([]);
+    });
+
+    it('the setClass(validity = function..) body call is sourced from the Class node', () => {
+      expect(sourceKeys(F, 'leaf_ai')).toEqual(['Class:P']);
+    });
+  });
+
+  // ─── scripts/top_level.R ──────────────────────────────────────────────────
+  describe('scripts/top_level.R (no functions)', () => {
+    const F = 'scripts/top_level.R';
+
+    it('sources its first top-level call from the File node', () => {
+      expect(sourceKeys(F, 'leaf_aj')).toEqual(['File:top_level.R']);
+    });
+
+    it('sources its second top-level call from the File node', () => {
+      expect(sourceKeys(F, 'leaf_ak')).toEqual(['File:top_level.R']);
+    });
+  });
+
+  // ─── Invariance (named types; literal counts measured before the change) ───────────
+  describe('graph structure is unchanged by attribution', () => {
+    for (const [label, count] of [
+      ['Function', 58],
+      ['Method', 9],
+      ['Class', 4],
+      ['Property', 1],
+      ['File', 6],
+    ] as const) {
+      it(`has ${count} ${label} nodes`, () => {
+        expect(countNodes(label)).toBe(count);
+      });
+    }
+
+    for (const [type, count] of [
+      ['DEFINES', 72],
+      ['CONTAINS', 6],
+      ['HAS_METHOD', 9],
+      ['HAS_PROPERTY', 1],
+      ['IMPORTS', 0],
+      ['EXTENDS', 0],
+    ] as const) {
+      it(`has ${count} ${type} relationships`, () => {
+        expect(countRels(type)).toBe(count);
+      });
+    }
+  });
+});
+
+/**
+ * R native pipe (`|>`) chains: characterisation of the current behaviour. There is no
+ * pipe-specific production support; the stages resolve as ordinary calls.
+ * The fixture is synthetic (`r-native-pipes/`, three packages); one function per
+ * scenario so each assertion is an exact `source -> targets` set.
+ * magrittr `%>%` is deliberately NOT covered (no support claimed either way).
+ * The `pkg::fn` stages are bound by their qualifier, not guessed by name (the cases marked
+ * "qualifier flip" differ from a name-only guess).
+ */
+describe('R native pipe chains', () => {
+  let result: PipelineResult;
+
+  beforeAll(async () => {
+    result = await runPipelineFromRepo(path.join(FIXTURES, 'r-native-pipes'), () => {});
+  }, 60000);
+
+  const callEdges = (sourceName: string, fileSuffix: string) =>
+    getRelationships(result, 'CALLS').filter(
+      (e) => e.source === sourceName && e.sourceFilePath.endsWith(fileSuffix),
+    );
+
+  /** Sorted unique CALLS targets of the source named `sourceName` in the file ending `fileSuffix`. */
+  const callsFrom = (sourceName: string, fileSuffix: string): string[] =>
+    [...new Set(callEdges(sourceName, fileSuffix).map((e) => e.target))].sort();
+
+  /** Sorted `Label:name` of every CALLS source in the file ending `fileSuffix` that targets `target`. */
+  const sourceKeys = (fileSuffix: string, target: string): string[] =>
+    getRelationships(result, 'CALLS')
+      .filter((e) => e.sourceFilePath.endsWith(fileSuffix) && e.target === target)
+      .map((e) => `${e.sourceLabel}:${e.source}`)
+      .sort();
+
+  const A = 'pkgmain/R/a.R';
+  const B = 'pkgmain/R/b.R';
+
+  // ─── module-level chain ─────────────────────────────────────────────────
+  describe('module-level chain', () => {
+    it('sources every stage of a top-level chain from the File node', () => {
+      expect(callsFrom('a.R', A)).toEqual(['stage_one', 'stage_two']);
+    });
+
+    it('labels the top-level chain source as File for stage_one', () => {
+      expect(sourceKeys(A, 'stage_one').filter((k) => k.startsWith('File:'))).toEqual(['File:a.R']);
+    });
+
+    it('labels the top-level chain source as File for stage_two', () => {
+      expect(sourceKeys(A, 'stage_two').filter((k) => k.startsWith('File:'))).toEqual(['File:a.R']);
+    });
+
+    it('resolves the top-level stages as local calls at 0.85', () => {
+      expect(
+        callEdges('a.R', A)
+          .map((e) => `${e.target}:${e.rel.reason}:${e.rel.confidence}`)
+          .sort(),
+      ).toEqual(['stage_one:local-call:0.85', 'stage_two:local-call:0.85']);
+    });
+  });
+
+  // ─── multi-line chain ───────────────────────────────────────────────────
+  describe('multi-line chain with a builtin stage', () => {
+    it('resolves every user-defined stage of a five-stage chain', () => {
+      expect(callsFrom('multiline_user', A)).toEqual(['stage_one', 'stage_three', 'stage_two']);
+    });
+
+    it('emits no edge for the builtin-named paste stage', () => {
+      expect(callsFrom('multiline_user', A).includes('paste')).toBe(false);
+    });
+
+    it('emits no CALLS edge to a paste target anywhere', () => {
+      expect(getRelationships(result, 'CALLS').filter((e) => e.target === 'paste')).toEqual([]);
+    });
+  });
+
+  // ─── placeholder ────────────────────────────────────────────────────────
+  describe('placeholder argument', () => {
+    it('resolves only the stage that takes the placeholder', () => {
+      expect(callsFrom('placeholder_user', A)).toEqual(['stage_three']);
+    });
+
+    it('emits no CALLS edge to the placeholder `_`', () => {
+      expect(getRelationships(result, 'CALLS').filter((e) => e.target === '_')).toEqual([]);
+    });
+  });
+
+  // ─── lambda stage ───────────────────────────────────────────────────────
+  describe('lambda stage', () => {
+    it('sources the lambda body call from the enclosing function', () => {
+      expect(callsFrom('lambda_user', A)).toEqual(['uniq_helper']);
+    });
+
+    it('resolves the lambda body call as a 0.85 local call', () => {
+      expect(callEdges('lambda_user', A).map((e) => `${e.rel.reason}:${e.rel.confidence}`)).toEqual(
+        ['local-call:0.85'],
+      );
+    });
+  });
+
+  // ─── attribution across functions ───────────────────────────────────────
+  describe('two pipe functions in one package', () => {
+    it('gives the decoy first function only its own pipe edge', () => {
+      expect(callsFrom('decoy_first', 'pkgmain/R/decoy_first.R')).toEqual(['uniq_helper']);
+    });
+
+    it('does not source later pipes from the decoy first function', () => {
+      expect(
+        sourceKeys('pkgmain/R/decoy_first.R', 'stage_one').concat(
+          sourceKeys('pkgmain/R/decoy_first.R', 'stage_three'),
+        ),
+      ).toEqual([]);
+    });
+
+    it('keeps a plain call and a lambda-stage call in separate sources', () => {
+      expect(sourceKeys(A, 'uniq_helper')).toEqual(['Function:lambda_user', 'Function:plain_user']);
+    });
+  });
+
+  // ─── R6 method chain ────────────────────────────────────────────────────
+  describe('R6 method chain', () => {
+    it('sources the chain from the Method and calls exactly the stage and self$post', () => {
+      expect(callsFrom('run', A)).toEqual(['post', 'stage_one']);
+    });
+
+    it('targets a Method for the self$post stage', () => {
+      expect(callEdges('run', A).find((e) => e.target === 'post')?.targetLabel).toBe('Method');
+    });
+
+    it('targets a Function for the stage_one stage', () => {
+      expect(callEdges('run', A).find((e) => e.target === 'stage_one')?.targetLabel).toBe(
+        'Function',
+      );
+    });
+
+    it('labels the chain source as Method:run', () => {
+      expect(sourceKeys(A, 'post')).toEqual(['Method:run']);
+    });
+  });
+
+  // ─── member stages ──────────────────────────────────────────────────────
+  describe('member stage on a typed object', () => {
+    it('resolves obj$score() and the following stage', () => {
+      expect(callsFrom('typed_user', B)).toEqual(['score', 'stage_one']);
+    });
+
+    it('targets a Method for the typed member stage', () => {
+      expect(callEdges('typed_user', B).find((e) => e.target === 'score')?.targetLabel).toBe(
+        'Method',
+      );
+    });
+  });
+
+  describe('member stage on an untyped object', () => {
+    it('emits no edge for the untyped member stage and resolves the next stage', () => {
+      expect(callsFrom('member_user', A)).toEqual(['stage_one']);
+    });
+  });
+
+  // ─── namespaced stages ──────────────────────────────────────────────────
+  describe('namespaced stage with a unique name in another package', () => {
+    it('resolves pkgother::ext_fn() and the following stage', () => {
+      expect(callsFrom('ns_user', A)).toEqual(['ext_fn', 'stage_one']);
+    });
+
+    it('resolves the namespaced stage into the other package', () => {
+      expect(callEdges('ns_user', A).find((e) => e.target === 'ext_fn')?.targetFilePath).toBe(
+        'pkgother/R/e.R',
+      );
+    });
+
+    it('resolves it precisely from the qualifier: pkgother defines ext_fn once (qualifier flip; was global-name-fallback:0.5)', () => {
+      expect(
+        callEdges('ns_user', A)
+          .filter((e) => e.target === 'ext_fn')
+          .map((e) => `${e.rel.reason}:${e.rel.confidence}`),
+      ).toEqual(['import-resolved:0.85']);
+    });
+  });
+
+  describe('namespaced stage whose name is also defined in the calling file', () => {
+    it('binds the qualified stage to the named package, not the local definition (qualifier flip)', () => {
+      // `pkgother::amb_stage()` is qualified: the edge goes to pkgother's definition, not to the
+      // same-named definition in the calling file (was a false 0.85 local-call self-file edge).
+      expect(
+        callEdges('ns_amb_user', A).map((e) => `${e.target}:${e.targetFilePath}:${e.rel.reason}`),
+      ).toEqual(['amb_stage:pkgother/R/e.R:import-resolved']);
+    });
+  });
+
+  describe('namespaced stages whose name is defined in two other packages', () => {
+    it('binds each stage to the package its qualifier names (qualifier flip)', () => {
+      // `pkgother::amb_only() |> pkgthird::amb_only()`: ambiguous by name alone, but each
+      // qualifier names exactly one definition (pkgthird has no DESCRIPTION: it is local through
+      // its `pkgthird/R/` path). Was: no edge.
+      expect(callsFrom('ns_amb2_user', B)).toEqual(['amb_only']);
+      expect(
+        callEdges('ns_amb2_user', B)
+          .map((e) => e.targetFilePath)
+          .sort(),
+      ).toEqual(['pkgother/R/e.R', 'pkgthird/R/t.R']);
+    });
+  });
+
+  // ─── backticked stage ───────────────────────────────────────────────────
+  describe('backticked stage with no definition', () => {
+    it('emits no edge for it and still resolves the following stage', () => {
+      expect(callsFrom('bt_user', B)).toEqual(['stage_two']);
+    });
+  });
+
+  // ─── Nested function sharing a name with a later top-level function ─
+  describe('nested function sharing a name with a top-level function', () => {
+    const N = 'pkgmain/R/nested.R';
+    const targetStartLine = (fn: string): number | undefined => {
+      const edge = callEdges(fn, N).find((e) => e.target === 'nest_fn');
+      return edge ? result.graph.getNode(edge.rel.targetId)?.properties.startLine : undefined;
+    };
+
+    it('resolves a pipe stage to the same-named nested function from the enclosing function', () => {
+      expect(callsFrom('nested_outer', N)).toEqual(['nest_fn', 'stage_two']);
+    });
+
+    it('resolves the same name from another function to the top-level definition', () => {
+      expect(callsFrom('nested_caller', N)).toEqual(['nest_fn']);
+    });
+
+    it('binds the enclosing function to the nested definition, not the top-level one', () => {
+      expect(targetStartLine('nested_outer') ?? Infinity).toBeLessThan(
+        targetStartLine('nested_caller') ?? -Infinity,
+      );
+    });
+  });
+});
+
+describe('R NAMESPACE importFrom() bindings to local packages', () => {
+  let result: PipelineResult;
+
+  beforeAll(async () => {
+    result = await runPipelineFromRepo(path.join(FIXTURES, 'r-namespace-imports'), () => {});
+  }, 60000);
+
+  const callEdges = (sourceName: string, fileSuffix: string) =>
+    getRelationships(result, 'CALLS').filter(
+      (e) => e.source === sourceName && e.sourceFilePath.endsWith(fileSuffix),
+    );
+
+  /** Sorted unique CALLS targets of the source named `sourceName` in the file ending `fileSuffix`. */
+  const callsFrom = (sourceName: string, fileSuffix: string): string[] =>
+    [...new Set(callEdges(sourceName, fileSuffix).map((e) => e.target))].sort();
+
+  /** `target:targetFile:reason:confidence` of every edge from `sourceName`, sorted. */
+  const edgeSummaries = (sourceName: string, fileSuffix: string): string[] =>
+    callEdges(sourceName, fileSuffix)
+      .map((e) => `${e.target}:${e.targetFilePath}:${e.rel.reason}:${e.rel.confidence}`)
+      .sort();
+
+  /** Sorted unique IMPORTS target files of the file `sourceFile` (fixture-root-relative). */
+  const importTargets = (sourceFile: string): string[] =>
+    [
+      ...new Set(
+        getRelationships(result, 'IMPORTS')
+          .filter((e) => e.sourceFilePath === sourceFile)
+          .map((e) => e.targetFilePath),
+      ),
+    ].sort();
+
+  const USE = 'analytics/R/use.R';
+
+  // Every `R/` file of the caller package, with the import set the synthesised
+  // named imports must produce for it (defining provider files only).
+  const CALLER_FILES = [
+    'analytics/R/decoy_first.R',
+    'analytics/R/dotted_use.R',
+    'analytics/R/qualified_use.R',
+    'analytics/R/nested_use.R',
+    'analytics/R/own.R',
+    'analytics/R/r6_use.R',
+    'analytics/R/reexport_use.R',
+    'analytics/R/second.R',
+    'analytics/R/use.R',
+    'analytics/R/veto_use.R',
+  ];
+  const BOUND_TARGET_FILES = [
+    'legacyscore/R/l.R', // dup_fn: the later importFrom() (legacyscore) wins
+    'scorelib/R/nested.R',
+    'scorelib/R/plain.R',
+    'scorelib/R/r6.R',
+    'scorelib/R/s.R',
+  ];
+
+  describe('bare calls to names imported from a local package', () => {
+    it('resolves every imported name from the one calling function, and nothing else', () => {
+      expect(callsFrom('run_all', USE)).toEqual([
+        'dup_fn',
+        'hidden_helper',
+        'normalise_scores',
+        'quoted_fn',
+        'rank_scores',
+        'tidy_scores',
+      ]);
+    });
+
+    it('binds a single-line importFrom() name to the provider even though another package defines it', () => {
+      // Baseline (before this change): no edge — `tidy_scores` is defined in scorelib AND
+      // legacyscore, so the name-only guess is ambiguous and drops it.
+      expect(
+        callEdges('run_all', USE)
+          .filter((e) => e.target === 'tidy_scores')
+          .map((e) => `${e.targetFilePath}:${e.rel.reason}:${e.rel.confidence}`),
+      ).toEqual(['scorelib/R/s.R:import-resolved:0.85']);
+    });
+
+    it('binds names from a multi-line importFrom() and a quoted importFrom() by import, not by name guess', () => {
+      // Baseline: 0.5 `global-name-fallback` edges only (the multi-line/quoted forms were unparsed).
+      expect(
+        ['normalise_scores', 'rank_scores', 'quoted_fn'].map((name) =>
+          callEdges('run_all', USE)
+            .filter((e) => e.target === name)
+            .map((e) => `${name}:${e.targetFilePath}:${e.rel.reason}`),
+        ),
+      ).toEqual([
+        ['normalise_scores:scorelib/R/s.R:import-resolved'],
+        ['rank_scores:scorelib/R/s.R:import-resolved'],
+        ['quoted_fn:scorelib/R/s.R:import-resolved'],
+      ]);
+    });
+
+    it('applies the imports to every R file of the caller package, not only the caller of the name', () => {
+      expect(edgeSummaries('second_user', 'analytics/R/second.R')).toEqual([
+        'tidy_scores:scorelib/R/s.R:import-resolved:0.85',
+      ]);
+    });
+
+    it('lets the later importFrom() win when two local packages are imported for one name', () => {
+      // scorelib is imported first, legacyscore last: R replaces the earlier binding.
+      expect(
+        callEdges('run_all', USE)
+          .filter((e) => e.target === 'dup_fn')
+          .map((e) => `${e.targetFilePath}:${e.rel.reason}`),
+      ).toEqual(['legacyscore/R/l.R:import-resolved']);
+    });
+
+    it('does not bind an imported name that the calling package also defines (own namespace masks)', () => {
+      // `own_dup` is defined in analytics/R/own.R AND scorelib: ambiguous, so no edge. An edge to
+      // scorelib's `own_dup` would mean the synthesised import outranked R's own-namespace rule.
+      expect(callsFrom('run_all', USE)).not.toContain('own_dup');
+    });
+
+    it('does not bind a name the provider defines but does not export, and keeps the fallback edge', () => {
+      expect(
+        callEdges('run_all', USE)
+          .filter((e) => e.target === 'hidden_helper')
+          .map((e) => `${e.targetFilePath}:${e.rel.reason}:${e.rel.confidence}`),
+      ).toEqual(['scorelib/R/internal.R:global-name-fallback:0.5']);
+    });
+
+    it('emits no edge for an exported name that no package defines', () => {
+      expect(callsFrom('run_all', USE)).not.toContain('no_such_fn');
+    });
+
+    it('emits no edge for a call outside the package R/ directory (NAMESPACE does not apply)', () => {
+      // `tidy_scores` is ambiguous by name (scorelib + legacyscore); tests/ gets no import.
+      expect(callsFrom('test_that_user', 'analytics/tests/testthat/test-x.R')).toEqual([]);
+    });
+  });
+
+  describe('IMPORTS edges', () => {
+    it('gives every caller R file IMPORTS edges to exactly the provider files that define an imported name', () => {
+      expect(CALLER_FILES.map((f) => [f, importTargets(f)])).toEqual(
+        CALLER_FILES.map((f) => [f, BOUND_TARGET_FILES]),
+      );
+    });
+
+    it('does not link the provider file of a shadowed, unexported or dotted-only name', () => {
+      const all = CALLER_FILES.flatMap((f) => importTargets(f));
+      expect(all.filter((t) => /own_dup|dup\.R|internal|dotted/.test(t))).toEqual([]);
+    });
+
+    it('never links an external package import to a same-named file in another language', () => {
+      const targets = getRelationships(result, 'IMPORTS').map((e) => e.targetFilePath);
+      expect(targets.filter((t) => t.startsWith('vendor/'))).toEqual([]);
+    });
+
+    it('adds no IMPORTS edge for files outside the package R/ directory', () => {
+      const sources = getRelationships(result, 'IMPORTS').map((e) => e.sourceFilePath);
+      expect(
+        sources.filter((s) => s.startsWith('analytics/scripts/') || s.includes('/tests/')),
+      ).toEqual([]);
+    });
+  });
+
+  describe('dotted names', () => {
+    it('leaves a dotted importedName unbound (baseline call edge unchanged)', () => {
+      // `normalise.scores` can never bind by import (finalize keys defs by the text after the
+      // last `.`); the call keeps the baseline low-confidence edge, not an import-resolved one.
+      expect(edgeSummaries('dotted_name_user', 'analytics/R/dotted_use.R')).toEqual([
+        'normalise.scores:scorelib/R/dotted.R:scope-resolution: call:0.35',
+      ]);
+    });
+
+    it('never binds tidy to print.tidy when print.tidy is defined first', () => {
+      // finalize would index `print.tidy` under `tidy`; the guard refuses the import instead, so
+      // there is no 0.85 edge to the wrong def. Now the fallback no longer sees `print.tidy`
+      // as a tail-`tidy` candidate (a bare call cannot invoke it), so the call resolves to the
+      // bare def at 0.5 (was: ambiguous, no edge).
+      expect(edgeSummaries('print_before_bare_user', 'analytics/R/dotted_use.R')).toEqual([
+        'tidy:scorelib/R/dotted.R:global-name-fallback:0.5',
+      ]);
+    });
+
+    it('also refuses the mirror layout (bare def first): the guard is order-blind', () => {
+      // Same 0.5 fallback edge to the bare def (was: no edge).
+      expect(edgeSummaries('bare_before_print_user', 'analytics/R/dotted_use.R')).toEqual([
+        'tally:scorelib/R/dotted.R:global-name-fallback:0.5',
+      ]);
+    });
+
+    it('does not fire for an underscore name (plain_fn binds by import)', () => {
+      expect(edgeSummaries('underscore_user', 'analytics/R/dotted_use.R')).toEqual([
+        'plain_fn:scorelib/R/plain.R:import-resolved:0.85',
+      ]);
+    });
+  });
+
+  describe('R6 members and nested definitions in the provider', () => {
+    it('binds the top-level def, not the same-named R6 method defined earlier in the same file', () => {
+      // Fails without `namedImportsBindTopLevelOnly` (the wide index would store the method).
+      expect(
+        callEdges('r6_flag_user', 'analytics/R/r6_use.R').map(
+          (e) => `${e.targetLabel}:${e.target}:${e.rel.reason}`,
+        ),
+      ).toEqual(['Function:score_it:import-resolved']);
+    });
+
+    it('does not bind an import to an R6 method when no top-level def carries the name', () => {
+      // A bare `describe_run()` cannot invoke an R6 method (`Reporter.describe_run`, reached only
+      // as `obj$describe_run()`), so the fallback offers no candidate either (was: a
+      // 0.5 guess to the method).
+      expect(edgeSummaries('r6_method_only_user', 'analytics/R/r6_use.R')).toEqual([]);
+    });
+
+    it('documents a known limitation: a nested function defined before the top-level one still wins the binding', () => {
+      // The named branch can only choose FILES; finalize's first-callable rule then picks the
+      // nested def. Fixing it needs an `isExported` capture (query change): out of scope here.
+      const edges = callEdges('nested_user', 'analytics/R/nested_use.R');
+      expect(edges.map((e) => `${e.target}:${e.targetFilePath}:${e.rel.reason}`)).toEqual([
+        'nest_fn:scorelib/R/nested.R:import-resolved',
+      ]);
+      const nestFnLines = getNodesByLabelFull(result, 'Function')
+        .filter((n) => n.name === 'nest_fn' && n.properties.filePath === 'scorelib/R/nested.R')
+        .map((n) => n.properties.startLine as number);
+      const boundLine = result.graph.getNode(edges[0].rel.targetId)?.properties.startLine;
+      expect(boundLine).toBe(Math.min(...nestFnLines));
+    });
+  });
+
+  describe('re-export through a local provider', () => {
+    it('keeps the baseline fallback edge to the defining package (no import binding)', () => {
+      // scorelib re-exports `reexp_fn` from corelib and defines no top-level def of the name.
+      expect(edgeSummaries('reexport_user', 'analytics/R/reexport_use.R')).toEqual([
+        'reexp_fn:corelib/R/c.R:global-name-fallback:0.5',
+      ]);
+    });
+  });
+
+  describe('global-name guesses contradicted by the NAMESPACE importFrom() (veto)', () => {
+    const VETO = 'analytics/R/veto_use.R';
+
+    it('refuses the guess to a decoy in another local package when the name is imported from an external package', () => {
+      // importFrom(dplyr, mutate) + a same-named `mutate` in legacyscore: the unique-name guess
+      // (a FALSE 0.5 edge before the veto) is impossible in R, so no edge is published.
+      expect(edgeSummaries('mutate_user', VETO)).toEqual([]);
+    });
+
+    it('keeps the 0.5 fallback edge to the own-package definition of an externally imported name', () => {
+      // importFrom(dplyr, filter) and `filter` defined in analytics/R/own.R: the candidate is the
+      // caller's own package, which masks the import. Precise own-package binding is not implemented.
+      expect(edgeSummaries('filter_user', VETO)).toEqual([
+        'filter:analytics/R/own.R:global-name-fallback:0.5',
+      ]);
+    });
+
+    it('refuses the guess when the last importFrom() of the name names an external package', () => {
+      // importFrom(scorelib, dup_ext) then importFrom(dplyr, dup_ext): the last entry wins, nothing
+      // is bound, and the guess to scorelib's exported `dup_ext` is contradicted (no IMPORTS edge
+      // either).
+      expect(edgeSummaries('dup_ext_user', VETO)).toEqual([]);
+      expect(importTargets(VETO)).not.toContain('scorelib/R/dup.R');
+    });
+
+    it('keeps the 0.5 fallback edge to a candidate outside every package R/ directory', () => {
+      // `scripts_only_fn` lives in analytics/scripts/helper.R, which no NAMESPACE governs.
+      expect(edgeSummaries('scripts_only_user', VETO)).toEqual([
+        'scripts_only_fn:analytics/scripts/helper.R:global-name-fallback:0.5',
+      ]);
+    });
+
+    it('does not apply to a caller outside the package R/ directory (tests/testthat keeps the guess)', () => {
+      expect(edgeSummaries('test_mutate_user', 'analytics/tests/testthat/test-veto.R')).toEqual([
+        'mutate:legacyscore/R/l.R:global-name-fallback:0.5',
+      ]);
+    });
+
+    it('keeps the re-export fallback edge to the origin package (allowance for a local provider that re-exports)', () => {
+      expect(edgeSummaries('reexport_user', 'analytics/R/reexport_use.R')).toEqual([
+        'reexp_fn:corelib/R/c.R:global-name-fallback:0.5',
+      ]);
+    });
+
+    it('records every refusal as fallback-refused and no other kind of veto outcome', () => {
+      const refused = (result.resolutionOutcomes ?? []).filter(
+        (o) => o.kind === 'fallback-refused',
+      );
+      // Qualifier flip: the qualified `legacyscore::mutate()` is no longer refused (it binds to
+      // legacyscore); only the bare `mutate_user()` refusal remains. Was ['dup_ext', 'mutate', 'mutate'].
+      expect(refused.map((o) => o.name).sort()).toEqual(['dup_ext', 'mutate']);
+    });
+  });
+
+  describe('explicitly qualified call to another local package', () => {
+    it('binds the call to the named package, not to the importFrom() provider (qualifier flip)', () => {
+      // `legacyscore::tidy_scores()` names legacyscore; the synthesised import would bind the
+      // name to scorelib (a false 0.85 edge before the qualifier was honoured).
+      expect(edgeSummaries('qualified_user', 'analytics/R/qualified_use.R')).toEqual([
+        'tidy_scores:legacyscore/R/l.R:import-resolved:0.85',
+      ]);
+    });
+
+    it('keeps a correct qualified edge although the NAMESPACE imports the name from dplyr (qualifier flip)', () => {
+      // `legacyscore::mutate()` names the package that really defines `mutate`. The qualifier
+      // outranks `importFrom(dplyr, mutate)`: the edge is precise (was vetoed: no edge).
+      expect(edgeSummaries('qualified_mutate_user', 'analytics/R/qualified_use.R')).toEqual([
+        'mutate:legacyscore/R/l.R:import-resolved:0.85',
+      ]);
+    });
+  });
+});
+
+describe('R importFrom(pkgB, CleanData) in the shared r-packages fixture', () => {
+  let result: PipelineResult;
+
+  beforeAll(async () => {
+    result = await runPipelineFromRepo(path.join(FIXTURES, 'r-packages'), () => {});
+  }, 60000);
+
+  it('binds the pkgB::CleanData call by import instead of the name guess', () => {
+    // Baseline: 0.5 `global-name-fallback`. pkgA/NAMESPACE now yields a real import binding.
+    expect(
+      getRelationships(result, 'CALLS')
+        .filter((e) => e.source === 'AddOutlierStatuses' && e.target === 'CleanData')
+        .map((e) => `${e.targetFilePath}:${e.rel.reason}:${e.rel.confidence}`),
+    ).toEqual(['pkgB/R/clean_data.R:import-resolved:0.85']);
+  });
+
+  it('links pkgA R files to the pkgB file that defines the imported name', () => {
+    const importers = getRelationships(result, 'IMPORTS')
+      .filter((e) => e.targetFilePath === 'pkgB/R/clean_data.R')
+      .map((e) => e.sourceFilePath)
+      .filter((f) => f.startsWith('pkgA/'))
+      .sort();
+    // pkgA/NAMESPACE importFrom(pkgB, CleanData) links every pkgA R file (package-wide
+    // namespace import) to the defining file, once each.
+    expect(importers).toEqual([
+      'pkgA/R/add_outliers.R',
+      'pkgA/R/dot_names.R',
+      'pkgA/R/export_scope.R',
+      'pkgA/R/models.R',
+      'pkgA/R/r6_advanced.R',
+      'pkgA/R/r6_bare.R',
+      'pkgA/R/s3.R',
+      'pkgA/R/s4_and_r6.R',
+      'pkgA/R/s4_multi_parent.R',
+      'pkgA/R/super_assign.R',
+      'pkgA/R/utils.R',
+    ]);
+  });
+});
+
+// A package whose DESCRIPTION/NAMESPACE sit at the repository root
+// (pkgDir === '') must get the same NAMESPACE export refinement as a nested one.
+describe('R root-level package NAMESPACE export refinement', () => {
+  let result: PipelineResult;
+
+  beforeAll(async () => {
+    result = await runPipelineFromRepo(path.join(FIXTURES, 'r-root-package'), () => {});
+  }, 60000);
+
+  const findFn = (name: string) =>
+    getNodesByLabelFull(result, 'Function').find((n) => n.name === name);
+
+  it('keeps an explicit export() public', () => {
+    expect(findFn('RootExported')?.properties.isExported).toBe(true);
+  });
+
+  it('keeps a symbol matching exportPattern() public', () => {
+    expect(findFn('PatternMatched')?.properties.isExported).toBe(true);
+  });
+
+  it('keeps an S3method() registration public', () => {
+    expect(findFn('print.RootWidget')?.properties.isExported).toBe(true);
+  });
+
+  it('marks a symbol absent from NAMESPACE as not exported', () => {
+    const helper = findFn('RootHelper');
+    expect(helper).toBeDefined();
+    expect(helper?.properties.isExported).toBe(false);
+  });
+});
+
+// NAMESPACE refinement is derived from the discovered package directory: only `<pkg>/R/`
+// symbols are package members, and a nested package owns its own files.
+describe('R NAMESPACE export refinement follows the package directory (r-package-layout)', () => {
+  let result: PipelineResult;
+
+  beforeAll(async () => {
+    result = await runPipelineFromRepo(path.join(FIXTURES, 'r-package-layout'), () => {});
+  }, 60000);
+
+  const exported = (name: string) =>
+    getNodesByLabelFull(result, 'Function').find((n) => n.name === name)?.properties.isExported;
+
+  it('marks unexported R/ symbols of the root package and of a nested package', () => {
+    expect(exported('root_exported')).toBe(true);
+    expect(exported('root_hidden')).toBe(false);
+    expect(exported('nested_exported')).toBe(true);
+    expect(exported('nested_hidden')).toBe(false);
+  });
+
+  it('leaves functions outside R/ (tests, vignettes, inst, scripts) exported', () => {
+    for (const name of [
+      'root_test_helper',
+      'root_vignette_helper',
+      'root_inst_script',
+      'root_script_entry',
+      'nested_test_helper',
+    ]) {
+      expect(exported(name), name).toBe(true);
+    }
+  });
+
+  it('keeps a nested package without a NAMESPACE fully public', () => {
+    expect(exported('inner_fn')).toBe(true);
+  });
+
+  it('resolves library() of the root package to its R/ files', () => {
+    const targets = getRelationships(result, 'IMPORTS')
+      .filter((e) => e.sourceFilePath === 'scripts/use.R')
+      .map((e) => e.targetFilePath);
+    expect(targets).toContain('R/root.R');
+  });
+});
+
+// Characterisation of the deferred-owner attach. R classes are calls, so the worker
+// leaves an `ownerNameHint` that the post-parse pass resolves into `ownerId` + HAS_METHOD/HAS_PROPERTY.
+// The counts and the (source, target, type) triples below were measured before that pass moved and must not change
+// when that pass moves behind `LanguageProvider.postParse`.
+describe('R deferred-owner attach (r-packages)', () => {
+  let result: PipelineResult;
+
+  beforeAll(async () => {
+    result = await runPipelineFromRepo(path.join(FIXTURES, 'r-packages'), () => {});
+  }, 60000);
+
+  const ownedTriples = [
+    'AdvancedR6|active_count|HAS_PROPERTY',
+    'AdvancedR6|compute|HAS_METHOD',
+    'AdvancedR6|display_name|HAS_METHOD',
+    'AdvancedR6|get_name|HAS_METHOD',
+    'AdvancedR6|initialize|HAS_METHOD',
+    'AdvancedR6|internal_flag|HAS_PROPERTY',
+    'AdvancedR6|name|HAS_PROPERTY',
+    'AdvancedR6|secret_key|HAS_PROPERTY',
+    'BareR6|get_value|HAS_METHOD',
+    'BareR6|value|HAS_PROPERTY',
+    'BaseA|a_field|HAS_PROPERTY',
+    'BaseB|b_field|HAS_PROPERTY',
+    'DataModel|name|HAS_PROPERTY',
+    'DataModel|validate|HAS_METHOD',
+    'DataModel|value|HAS_PROPERTY',
+    'DataProcessor|data|HAS_PROPERTY',
+    'DataProcessor|process|HAS_METHOD',
+    'ExportedS4Class|data|HAS_PROPERTY',
+    'Parent|greet|HAS_METHOD',
+    'ResultSet|count|HAS_METHOD',
+    'ResultSet|initialize|HAS_METHOD',
+    'ResultSet|items|HAS_PROPERTY',
+  ];
+
+  it('emits exactly 10 HAS_METHOD and 12 HAS_PROPERTY edges', () => {
+    expect(getRelationships(result, 'HAS_METHOD')).toHaveLength(10);
+    expect(getRelationships(result, 'HAS_PROPERTY')).toHaveLength(12);
+  });
+
+  it('emits the measured (source, target, type) edge set', () => {
+    const triples = [
+      ...getRelationships(result, 'HAS_METHOD'),
+      ...getRelationships(result, 'HAS_PROPERTY'),
+    ]
+      .map((e) => `${e.source}|${e.target}|${e.rel.type}`)
+      .sort();
+    expect(triples).toEqual(ownedTriples);
+  });
+
+  it('gives exactly the 22 attached R Method/Property nodes a string ownerId', () => {
+    const owned: string[] = [];
+    result.graph.forEachNode((n) => {
+      if (
+        n.properties.language === 'r' &&
+        (n.label === 'Method' || n.label === 'Property') &&
+        typeof n.properties.ownerId === 'string'
+      ) {
+        owned.push(n.id);
+      }
+    });
+    expect(owned).toHaveLength(22);
+  });
+
+  it('leaves no R node with an unresolved ownerNameHint', () => {
+    const leftover: string[] = [];
+    result.graph.forEachNode((n) => {
+      if (n.properties.language === 'r' && 'ownerNameHint' in n.properties) leftover.push(n.id);
+    });
+    expect(leftover).toEqual([]);
+  });
+});
diff --git a/gitnexus/test/integration/tree-sitter-languages.test.ts b/gitnexus/test/integration/tree-sitter-languages.test.ts
index 7c3f3eb9e..9f91b6142 100644
--- a/gitnexus/test/integration/tree-sitter-languages.test.ts
+++ b/gitnexus/test/integration/tree-sitter-languages.test.ts
@@ -783,6 +783,52 @@ describe('Tree-sitter multi-language parsing', () => {
     });
   });
 
+  describe('R', () => {
+    it('parses functions, S4 classes, R6 classes, and methods', async () => {
+      await loadLanguage(SupportedLanguages.R);
+      const content = readFixture('simple.r');
+      const provider = getProvider(SupportedLanguages.R);
+      const { matches } = parseAndQuery(parser, content, provider.treeSitterQueries);
+      const named = extractDefinitions(matches).map((d) => `${d.type}:${d.name}`);
+
+      // `name <- function(...)` assignments
+      expect(named).toContain('definition.function:add');
+      expect(named).toContain('definition.function:private_helper');
+      expect(named).toContain('definition.function:run');
+      // S4: setClass -> class, setGeneric -> function, setMethod -> method
+      expect(named).toContain('definition.class:Point');
+      expect(named).toContain('definition.function:distance');
+      expect(named).toContain('definition.method:distance');
+      // R6 via the namespaced `R6::R6Class(...)` spelling, with its members
+      expect(named).toContain('definition.class:Counter');
+      expect(named).toContain('definition.method:increment');
+      expect(named).toContain('definition.property:count');
+    });
+
+    it('captures library()/source() imports and free, member, namespaced, and piped calls', async () => {
+      await loadLanguage(SupportedLanguages.R);
+      const content = readFixture('simple.r');
+      const provider = getProvider(SupportedLanguages.R);
+      const { matches } = parseAndQuery(parser, content, provider.treeSitterQueries);
+
+      const imports: string[] = [];
+      for (const match of matches) {
+        for (const capture of match.captures) {
+          if (capture.name === 'import.source') imports.push(capture.node.text);
+        }
+      }
+      expect(imports).toEqual(['R6', '"helpers.R"']);
+
+      const calls = extractCapturedCallNames(matches);
+      expect(calls).toContain('increment'); // counter$increment()
+      expect(calls).toContain('new'); // Counter$new()
+      expect(calls).toContain('median'); // stats::median()
+      // Both stages of the native pipe `c(...) |> add(4) |> private_helper()`
+      expect(calls).toContain('add');
+      expect(calls).toContain('private_helper');
+    });
+  });
+
   describe('unhappy path', () => {
     it('returns null/undefined for unsupported file extensions', () => {
       expect(getLanguageFromFilename('archive.xyz')).toBeNull();
diff --git a/gitnexus/test/unit/call-arguments-r.test.ts b/gitnexus/test/unit/call-arguments-r.test.ts
new file mode 100644
index 000000000..57a28e89f
--- /dev/null
+++ b/gitnexus/test/unit/call-arguments-r.test.ts
@@ -0,0 +1,84 @@
+import { describe, it, expect } from 'vitest';
+import Parser from 'tree-sitter';
+import R from '@eagleoutice/tree-sitter-r';
+import { countCallArguments } from '../../src/core/ingestion/utils/call-analysis.js';
+import type { SyntaxNode } from '../../src/core/ingestion/utils/ast-helpers.js';
+import { SupportedLanguages } from 'gitnexus-shared';
+import { getProvider } from '../../src/core/ingestion/languages/index.js';
+
+function extractRCall(
+  code: string,
+  calledName: string,
+): { callNode: SyntaxNode; nameNode: SyntaxNode } | undefined {
+  const parser = new Parser();
+  parser.setLanguage(R);
+
+  const provider = getProvider(SupportedLanguages.R);
+  const tree = parser.parse(code);
+  const query = new Parser.Query(parser.getLanguage(), provider.treeSitterQueries);
+
+  for (const match of query.matches(tree.rootNode)) {
+    const captureMap: Record<string, SyntaxNode> = {};
+    for (const capture of match.captures) {
+      captureMap[capture.name] = capture.node;
+    }
+    if (captureMap['call'] && captureMap['call.name']?.text === calledName) {
+      return { callNode: captureMap['call'], nameNode: captureMap['call.name'] };
+    }
+  }
+
+  return undefined;
+}
+
+describe('countCallArguments (R)', () => {
+  it('returns 0 for empty-argument calls in pipe chains', () => {
+    const cleanCall = extractRCall('data |> clean_native() |> transform_native()', 'clean_native');
+    const transformCall = extractRCall(
+      'data |> clean_native() |> transform_native()',
+      'transform_native',
+    );
+
+    expect(cleanCall).toBeDefined();
+    expect(transformCall).toBeDefined();
+    // countCallArguments counts explicit arguments only — pipe LHS is not in the call node
+    expect(countCallArguments(cleanCall!.callNode)).toBe(0);
+    expect(countCallArguments(transformCall!.callNode)).toBe(0);
+  });
+
+  it('returns 0 for empty-argument magrittr pipe calls', () => {
+    const cleanCall = extractRCall(
+      'data %>% clean_magrittr() %>% transform_magrittr()',
+      'clean_magrittr',
+    );
+    const transformCall = extractRCall(
+      'data %>% clean_magrittr() %>% transform_magrittr()',
+      'transform_magrittr',
+    );
+
+    expect(cleanCall).toBeDefined();
+    expect(transformCall).toBeDefined();
+    expect(countCallArguments(cleanCall!.callNode)).toBe(0);
+    expect(countCallArguments(transformCall!.callNode)).toBe(0);
+  });
+
+  it('counts explicit arguments in ordinary R calls', () => {
+    const multiArgCall = extractRCall('transform_magrittr(first, second)', 'transform_magrittr');
+
+    expect(multiArgCall).toBeDefined();
+    // tree-sitter-r produces: argument("first"), comma(","), argument("second")
+    // countCallArguments counts all named non-comment children
+    const count = countCallArguments(multiArgCall!.callNode);
+    expect(count).toBeGreaterThanOrEqual(2);
+  });
+
+  it('counts explicit arguments when magrittr uses the dot placeholder', () => {
+    const placeholderCall = extractRCall(
+      'data %>% transform_magrittr(., extra)',
+      'transform_magrittr',
+    );
+
+    expect(placeholderCall).toBeDefined();
+    const count = countCallArguments(placeholderCall!.callNode);
+    expect(count).toBeGreaterThanOrEqual(2);
+  });
+});
diff --git a/gitnexus/test/unit/incremental-parse-cache.test.ts b/gitnexus/test/unit/incremental-parse-cache.test.ts
index 9680bfde4..316d5c5a9 100644
--- a/gitnexus/test/unit/incremental-parse-cache.test.ts
+++ b/gitnexus/test/unit/incremental-parse-cache.test.ts
@@ -319,8 +319,9 @@ describe('PARSE_CACHE_VERSION', () => {
   // Moved 134 -> 135 for guarded-import and mutable binding review fixes (#3532).
   // Moved 135 -> 136 for parameter annotations and Vue embedded script fixes (#3532).
   // Moved 136 -> 137 for Python module-accessor and call-result assignment captures (#3497).
-  it('pins SCHEMA_BUMP to 137 so concurrent bumps cannot silently collide (#2766, #3015, #3088, #2885, #3128, #2865, #3130, #1432, #3161, #3179, #3219, #3190, #3253, #3273, #3339, #3354, #3371, #2965, #3390, #3398, #3396, #3394, #3399, #3414, #3408, #3402, #3446, #3450, #3499, #3502, #3487, #3505, #3504, #3497)', () => {
-    expect(Number(PARSE_CACHE_VERSION.split('+', 1)[0])).toBe(137);
+  // Moved 137 -> 138 for the R provider fixes (scope-function anchors, `pkg::` qualifier capture, S4/import first-argument selection).
+  it('pins SCHEMA_BUMP to 138 so concurrent bumps cannot silently collide (#2766, #3015, #3088, #2885, #3128, #2865, #3130, #1432, #3161, #3179, #3219, #3190, #3253, #3273, #3339, #3354, #3371, #2965, #3390, #3398, #3396, #3394, #3399, #3414, #3408, #3402, #3446, #3450, #3499, #3502, #3487, #3505, #3504, #3497)', () => {
+    expect(Number(PARSE_CACHE_VERSION.split('+', 1)[0])).toBe(138);
     expect(PARSE_CACHE_BUCKET_COUNT).toBe(128);
     // The PREVIOUS version must fail the reuse gate, not merely differ from the
     // current one — a hardcoded number outside the conflict hunk rebases cleanly
@@ -330,7 +331,7 @@ describe('PARSE_CACHE_VERSION', () => {
       59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
       82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
       104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122,
-      123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136,
+      123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137,
     ]) {
       expect(Number(PARSE_CACHE_VERSION.split('+', 1)[0])).not.toBe(taken);
     }
diff --git a/gitnexus/test/unit/ingestion-utils.test.ts b/gitnexus/test/unit/ingestion-utils.test.ts
index 2a3582773..d25c7aa73 100644
--- a/gitnexus/test/unit/ingestion-utils.test.ts
+++ b/gitnexus/test/unit/ingestion-utils.test.ts
@@ -155,8 +155,26 @@ describe('getLanguageFromFilename', () => {
     });
   });
 
+  describe('R', () => {
+    it.each(['.r', '.R'])('detects %s files', (ext) => {
+      expect(getLanguageFromFilename(`analysis${ext}`)).toBe(SupportedLanguages.R);
+    });
+
+    // docs/languages/r-provider.md: only `.r` / `.R` are handled.
+    it.each([
+      'analysis.Rmd',
+      'report.qmd',
+      '.Rprofile',
+      '.Renviron',
+      'Rprofile.site',
+      'x.Rhistory',
+    ])('returns null for %s', (name) => {
+      expect(getLanguageFromFilename(name)).toBeNull();
+    });
+  });
+
   describe('unsupported', () => {
-    it.each(['.scala', '.r', '.lua', '.txt', '.md', '.json', '.yaml'])(
+    it.each(['.scala', '.lua', '.txt', '.md', '.json', '.yaml'])(
       'returns null for %s files',
       (ext) => {
         expect(getLanguageFromFilename(`file${ext}`)).toBeNull();
diff --git a/gitnexus/test/unit/language-provider-post-parse.test.ts b/gitnexus/test/unit/language-provider-post-parse.test.ts
new file mode 100644
index 000000000..ea5f7ad73
--- /dev/null
+++ b/gitnexus/test/unit/language-provider-post-parse.test.ts
@@ -0,0 +1,167 @@
+import { describe, expect, it, vi } from 'vitest';
+import { SupportedLanguages } from 'gitnexus-shared';
+import { createKnowledgeGraph } from '../../src/core/graph/graph.js';
+import { createSemanticModel } from '../../src/core/ingestion/model/semantic-model.js';
+import {
+  runPostParseHooks,
+  type LanguageProvider,
+  type PostParseContext,
+} from '../../src/core/ingestion/language-provider.js';
+
+type PostParseProvider = Pick<LanguageProvider, 'postParse'>;
+
+const makeCtx = (): PostParseContext => ({
+  graph: createKnowledgeGraph(),
+  model: createSemanticModel(),
+  repoPath: '/repo',
+});
+
+const lookup =
+  (providers: Partial<Record<SupportedLanguages, PostParseProvider>>) =>
+  (language: SupportedLanguages): PostParseProvider | undefined =>
+    providers[language];
+
+describe('runPostParseHooks', () => {
+  it('(1) fires hooks only for present languages', async () => {
+    const r = vi.fn();
+    const python = vi.fn();
+    const java = vi.fn();
+
+    await runPostParseHooks(
+      new Set([SupportedLanguages.R, SupportedLanguages.Python]),
+      lookup({
+        [SupportedLanguages.R]: { postParse: r },
+        [SupportedLanguages.Python]: { postParse: python },
+        [SupportedLanguages.Java]: { postParse: java },
+      }),
+      makeCtx(),
+    );
+
+    expect(r).toHaveBeenCalledTimes(1);
+    expect(python).toHaveBeenCalledTimes(1);
+    expect(java).not.toHaveBeenCalled();
+  });
+
+  it('(2) passes the identical ctx object to every hook', async () => {
+    const ctx = makeCtx();
+    const r = vi.fn();
+    const python = vi.fn();
+
+    await runPostParseHooks(
+      new Set([SupportedLanguages.R, SupportedLanguages.Python]),
+      lookup({
+        [SupportedLanguages.R]: { postParse: r },
+        [SupportedLanguages.Python]: { postParse: python },
+      }),
+      ctx,
+    );
+
+    expect(r.mock.calls[0][0]).toBe(ctx);
+    expect(python.mock.calls[0][0]).toBe(ctx);
+  });
+
+  it('(3) runs in language-id order, independent of Set insertion order', async () => {
+    const order: string[] = [];
+    const providers = {
+      [SupportedLanguages.R]: { postParse: () => void order.push('r') },
+      [SupportedLanguages.Python]: { postParse: () => void order.push('python') },
+      [SupportedLanguages.Java]: { postParse: () => void order.push('java') },
+    };
+
+    await runPostParseHooks(
+      new Set([SupportedLanguages.R, SupportedLanguages.Java, SupportedLanguages.Python]),
+      lookup(providers),
+      makeCtx(),
+    );
+    const forward = [...order];
+    order.length = 0;
+    await runPostParseHooks(
+      new Set([SupportedLanguages.Python, SupportedLanguages.Java, SupportedLanguages.R]),
+      lookup(providers),
+      makeCtx(),
+    );
+
+    expect(forward).toEqual(['java', 'python', 'r']);
+    expect(order).toEqual(forward);
+  });
+
+  it('(4) awaits async hooks sequentially: the next starts only after the previous resolves', async () => {
+    const events: string[] = [];
+    let releaseFirst!: () => void;
+    const firstGate = new Promise<void>((resolve) => {
+      releaseFirst = resolve;
+    });
+
+    const run = runPostParseHooks(
+      new Set([SupportedLanguages.Java, SupportedLanguages.Python]),
+      lookup({
+        [SupportedLanguages.Java]: {
+          postParse: async () => {
+            events.push('java:start');
+            await firstGate;
+            events.push('java:end');
+          },
+        },
+        [SupportedLanguages.Python]: {
+          postParse: async () => {
+            events.push('python:start');
+          },
+        },
+      }),
+      makeCtx(),
+    );
+
+    // Let every microtask that can run, run: the second hook must still be waiting.
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(events).toEqual(['java:start']);
+
+    releaseFirst();
+    await run;
+    expect(events).toEqual(['java:start', 'java:end', 'python:start']);
+  });
+
+  it('(5) skips a provider without postParse and a language with no provider', async () => {
+    const r = vi.fn();
+
+    await runPostParseHooks(
+      new Set([SupportedLanguages.Java, SupportedLanguages.Python, SupportedLanguages.R]),
+      lookup({
+        [SupportedLanguages.Java]: {},
+        [SupportedLanguages.R]: { postParse: r },
+      }),
+      makeCtx(),
+    );
+
+    expect(r).toHaveBeenCalledTimes(1);
+  });
+
+  it('(6) calls nothing for an empty language set', async () => {
+    const providerFor = vi.fn();
+
+    await runPostParseHooks(new Set(), providerFor, makeCtx());
+
+    expect(providerFor).not.toHaveBeenCalled();
+  });
+
+  it('(7) is fail-closed: a rejecting hook rejects the run and later hooks do not run', async () => {
+    const later = vi.fn();
+    const boom = new Error('post-parse failed');
+
+    await expect(
+      runPostParseHooks(
+        new Set([SupportedLanguages.Java, SupportedLanguages.Python]),
+        lookup({
+          [SupportedLanguages.Java]: {
+            postParse: async () => {
+              throw boom;
+            },
+          },
+          [SupportedLanguages.Python]: { postParse: later },
+        }),
+        makeCtx(),
+      ),
+    ).rejects.toBe(boom);
+
+    expect(later).not.toHaveBeenCalled();
+  });
+});
diff --git a/gitnexus/test/unit/parser-loader-abi.test.ts b/gitnexus/test/unit/parser-loader-abi.test.ts
index 484bf6da6..4efd472ab 100644
--- a/gitnexus/test/unit/parser-loader-abi.test.ts
+++ b/gitnexus/test/unit/parser-loader-abi.test.ts
@@ -129,6 +129,11 @@ const SMOKE_CASES: Record<string, SmokeCase> = {
     snippet: 'pub fn main() void {}\n',
     rootType: 'source_file',
   },
+  [SupportedLanguages.R]: {
+    language: SupportedLanguages.R,
+    snippet: 'f <- function(x) x\n',
+    rootType: 'program',
+  },
 };
 
 describe('parser-loader ABI load-smoke (#1922)', () => {
diff --git a/gitnexus/test/unit/prebuild-coverage.test.ts b/gitnexus/test/unit/prebuild-coverage.test.ts
index 007ffc0dc..2c9442f5d 100644
--- a/gitnexus/test/unit/prebuild-coverage.test.ts
+++ b/gitnexus/test/unit/prebuild-coverage.test.ts
@@ -151,14 +151,24 @@ describe('vendored grammar prebuild coverage (toolchain-free on every supported
 
 describe('npm-dependency grammar prebuild coverage', () => {
   const pkg = JSON.parse(readFileSync(path.join(GITNEXUS_ROOT, 'package.json'), 'utf8'));
+  // A grammar is recognised by its package basename so a scoped package
+  // (`@scope/tree-sitter-x`) is included; the `tree-sitter` runtime and
+  // non-grammar packages are not.
   const npmGrammars = Object.keys(pkg.dependencies ?? {})
-    .filter((d) => /^tree-sitter-/.test(d))
+    .filter((d) => /^tree-sitter-/.test(d.split('/').pop() ?? ''))
     .sort();
 
   it('discovers the npm grammar dependencies', () => {
     expect(npmGrammars.length).toBeGreaterThan(0);
   });
 
+  it('enumerates scoped and unscoped grammars but not the runtime or other packages', () => {
+    expect(npmGrammars).toContain('@eagleoutice/tree-sitter-r');
+    expect(npmGrammars).toContain('tree-sitter-go');
+    expect(npmGrammars).not.toContain('tree-sitter');
+    expect(npmGrammars).not.toContain('@ladybugdb/core');
+  });
+
   for (const grammar of npmGrammars) {
     const grammarDir = path.join(NODE_MODULES, grammar);
 
diff --git a/gitnexus/test/unit/prepare-tree-sitter-bundle.test.ts b/gitnexus/test/unit/prepare-tree-sitter-bundle.test.ts
index 620efea40..d2e9c8298 100644
--- a/gitnexus/test/unit/prepare-tree-sitter-bundle.test.ts
+++ b/gitnexus/test/unit/prepare-tree-sitter-bundle.test.ts
@@ -11,12 +11,14 @@ import {
 } from 'node:fs';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
+import { cleanupTempDirSync } from '../helpers/test-db.js';
 
 const require = createRequire(import.meta.url);
 const { prepareTreeSitterBundle } = require('../../scripts/prepare-tree-sitter-bundle.cjs');
 const roots: string[] = [];
 
 const directVersions: Record<string, string> = {
+  '@eagleoutice/tree-sitter-r': '1.1.2',
   'tree-sitter': '0.25.1',
   'tree-sitter-c-sharp': '0.23.5',
   'tree-sitter-cpp': '0.23.4',
@@ -30,6 +32,7 @@ const directVersions: Record<string, string> = {
   'tree-sitter-typescript': '0.23.2',
 };
 const peers: Record<string, string> = {
+  '@eagleoutice/tree-sitter-r': '^0.21.0',
   'tree-sitter-cpp': '^0.21.1',
   'tree-sitter-java': '^0.21.1',
   'tree-sitter-php': '^0.22.4',
@@ -110,7 +113,7 @@ function pnpmFixture() {
 }
 
 afterEach(() => {
-  for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
+  for (const root of roots.splice(0)) cleanupTempDirSync(root);
 });
 
 describe('native parser bundle preparation', () => {
@@ -119,12 +122,16 @@ describe('native parser bundle preparation', () => {
     const native = path.join(root, 'node_modules/tree-sitter-cpp/parser.node');
     writeFileSync(native, Buffer.from([0, 1, 128, 255]));
     const original = readFileSync(native);
-    expect(prepareTreeSitterBundle(root)).toHaveLength(8);
+    expect(prepareTreeSitterBundle(root)).toHaveLength(9);
     expect(
       read(path.join(root, 'node_modules/tree-sitter-cpp/package.json')).peerDependencies[
         'tree-sitter'
       ],
     ).toBe('0.25.1');
+    expect(
+      read(path.join(root, 'node_modules/@eagleoutice/tree-sitter-r/package.json'))
+        .peerDependencies['tree-sitter'],
+    ).toBe('0.25.1');
     expect(
       read(
         path.join(
@@ -138,7 +145,7 @@ describe('native parser bundle preparation', () => {
         'tree-sitter'
       ],
     ).toBe('^0.25.0');
-    expect(prepareTreeSitterBundle(root)).toHaveLength(8);
+    expect(prepareTreeSitterBundle(root)).toHaveLength(9);
     expect(readFileSync(native)).toEqual(original);
     expect(read(path.join(root, 'package.json')).dependencies).toEqual(directVersions);
   });
@@ -149,9 +156,9 @@ describe('native parser bundle preparation', () => {
     const pkg = read(file);
     pkg.peerDependencies['tree-sitter'] = '^0.21.1 || 0.25.1';
     write(file, pkg);
-    expect(prepareTreeSitterBundle(root)).toHaveLength(8);
+    expect(prepareTreeSitterBundle(root)).toHaveLength(9);
     expect(read(file).peerDependencies['tree-sitter']).toBe('0.25.1');
-    expect(prepareTreeSitterBundle(root)).toHaveLength(8);
+    expect(prepareTreeSitterBundle(root)).toHaveLength(9);
   });
 
   it('prepares pnpm symlinks, transitive siblings, and aliased cycles exactly once', () => {
@@ -159,7 +166,7 @@ describe('native parser bundle preparation', () => {
     const aliases = path.join(c, 'node_modules');
     mkdirSync(aliases);
     symlinkSync(c, path.join(aliases, 'tree-sitter-c'), 'junction');
-    expect(prepareTreeSitterBundle(root)).toHaveLength(8);
+    expect(prepareTreeSitterBundle(root)).toHaveLength(9);
     for (const dir of [c, javascript, path.join(root, 'node_modules/tree-sitter-cpp')]) {
       expect(read(path.join(dir, 'package.json')).peerDependencies['tree-sitter']).toBe('0.25.1');
     }
@@ -168,7 +175,7 @@ describe('native parser bundle preparation', () => {
         'tree-sitter'
       ],
     ).toBe('^0.25.0');
-    expect(prepareTreeSitterBundle(root)).toHaveLength(8);
+    expect(prepareTreeSitterBundle(root)).toHaveLength(9);
   });
 
   it('rejects drift behind pnpm symlinks before writing any package', () => {
@@ -224,6 +231,28 @@ describe('native parser bundle preparation', () => {
     expect(() => prepareTreeSitterBundle(root)).toThrow('must be bundled');
   });
 
+  it('applies the bundling rule to the scoped R grammar', () => {
+    const root = fixture();
+    const file = path.join(root, 'package.json');
+    const pkg = read(file);
+    pkg.bundleDependencies = pkg.bundleDependencies.filter(
+      (name: string) => name !== '@eagleoutice/tree-sitter-r',
+    );
+    write(file, pkg);
+    expect(() => prepareTreeSitterBundle(root)).toThrow(
+      '@eagleoutice/tree-sitter-r must be bundled',
+    );
+  });
+
+  it('rejects a scoped R grammar whose peer metadata changed', () => {
+    const root = fixture();
+    const file = path.join(root, 'node_modules/@eagleoutice/tree-sitter-r/package.json');
+    const pkg = read(file);
+    pkg.peerDependencies['tree-sitter'] = '^0.26.0';
+    write(file, pkg);
+    expect(() => prepareTreeSitterBundle(root)).toThrow('Unexpected tree-sitter peer metadata');
+  });
+
   it('rejects a runtime upgrade until its compatibility has been revalidated', () => {
     const root = fixture();
     const file = path.join(root, 'package.json');
diff --git a/gitnexus/test/unit/r-definition-anchors.test.ts b/gitnexus/test/unit/r-definition-anchors.test.ts
new file mode 100644
index 000000000..2c61499ce
--- /dev/null
+++ b/gitnexus/test/unit/r-definition-anchors.test.ts
@@ -0,0 +1,361 @@
+/**
+ * R_QUERIES captures every string argument of the S4 definition calls; the R
+ * provider keeps only the one that names the definition
+ * (`isRNonNamingArgumentCapture`, the provider's `shouldSkipDefinitionCapture`). Without that choice,
+ * `setClass("A", contains = "VIRTUAL")` minted a Class `VIRTUAL`,
+ * `setGeneric("f", valueClass = "numeric")` a Function `numeric`, and
+ * `setMethod("show", "Foo", fn)` a Method `Foo`.
+ *
+ * These tests run the query and then the same selection the parse worker applies.
+ * Each negative case is paired with the positive control that proves the same call
+ * still yields its real definition, so a query that stops matching cannot pass.
+ */
+import { describe, expect, it } from 'vitest';
+import Parser from 'tree-sitter';
+import R from '@eagleoutice/tree-sitter-r';
+import { R_QUERIES } from '../../src/core/ingestion/tree-sitter-queries.js';
+import { isRNonNamingArgumentCapture } from '../../src/core/ingestion/languages/r/naming-argument.js';
+import { parseSourceSafe } from '../../src/core/tree-sitter/safe-parse.js';
+import { MAX_RATIO, SHAPES, measureScaling } from '../helpers/r-argument-scaling.js';
+
+const language = R as Parameters<Parser['setLanguage']>[0];
+const parser = new Parser();
+parser.setLanguage(language);
+const query = new Parser.Query(language, R_QUERIES);
+
+type Capture = { name: string; node: Parser.SyntaxNode };
+
+/**
+ * Parse like production does: `parseSourceSafe` avoids the native binding's crash on
+ * strings above 32 767 characters on Windows (the scaling group parses 100 K+ strings).
+ */
+const parseR = (source: string): Parser.Tree =>
+  parseSourceSafe(parser, source, undefined, { bufferSize: 1 << 24 });
+
+/** Matches the parse worker keeps: the provider's selection applied to the query's matches. */
+function keptMatches(source: string | Parser.Tree): Capture[][] {
+  const tree = typeof source === 'string' ? parseR(source) : source;
+  const kept: Capture[][] = [];
+  for (const match of query.matches(tree.rootNode)) {
+    const captureMap: Record<string, Parser.SyntaxNode> = {};
+    for (const c of match.captures) captureMap[c.name] = c.node;
+    if (isRNonNamingArgumentCapture(captureMap)) continue;
+    kept.push(match.captures);
+  }
+  return kept;
+}
+
+/** `definition.<kind>:<name>` for every definition match, in source order. */
+function definitions(source: string): string[] {
+  const out: string[] = [];
+  for (const captures of keptMatches(source)) {
+    const def = captures.find((c) => c.name.startsWith('definition.'));
+    const name = captures.find((c) => c.name === 'name');
+    if (def && name) out.push(`${def.name}:${name.node.text}`);
+  }
+  return out;
+}
+
+describe('R_QUERIES: setClass / setRefClass name only their first argument', () => {
+  it('names the class from the first positional string (positive control)', () => {
+    expect(definitions('setClass("A")')).toEqual(['definition.class:A']);
+    expect(definitions('setRefClass("R")')).toEqual(['definition.class:R']);
+  });
+
+  it('does not mint a Class from contains = "VIRTUAL"', () => {
+    expect(definitions('setClass("A", contains = "VIRTUAL")')).toEqual(['definition.class:A']);
+  });
+
+  it('does not mint a Class from a single-parent contains = "Base"', () => {
+    expect(definitions('setRefClass("R", contains = "Base")')).toEqual(['definition.class:R']);
+    expect(definitions('setClass("A", contains = "Base", slots = list(x = "numeric"))')).toEqual([
+      'definition.class:A',
+      'definition.property:x',
+    ]);
+  });
+
+  it('does not mint a Class from a string positional inside representation()', () => {
+    expect(definitions('setClass("A", representation("VIRTUAL", x = "numeric"))')).toEqual([
+      'definition.class:A',
+    ]);
+  });
+
+  it('does not mint a Class from other string-valued arguments', () => {
+    expect(definitions('setClass("A", package = "pkg", sealed = "yes")')).toEqual([
+      'definition.class:A',
+    ]);
+  });
+
+  it('names the class from a first argument spelled Class =', () => {
+    expect(definitions('setClass(Class = "A", contains = "VIRTUAL")')).toEqual([
+      'definition.class:A',
+    ]);
+  });
+
+  it('names the class from Class = even when it is not the first argument', () => {
+    expect(definitions('setClass(contains = "VIRTUAL", Class = "A")')).toEqual([
+      'definition.class:A',
+    ]);
+  });
+
+  it('keeps slots / fields / representation properties', () => {
+    expect(definitions('setClass("A", slots = list(x = "numeric", y = "character"))')).toEqual([
+      'definition.class:A',
+      'definition.property:x',
+      'definition.property:y',
+    ]);
+    expect(definitions('setRefClass("R", fields = list(n = "numeric"))')).toEqual([
+      'definition.class:R',
+      'definition.property:n',
+    ]);
+    expect(definitions('setClass("A", representation = representation(z = "numeric"))')).toEqual([
+      'definition.class:A',
+      'definition.property:z',
+    ]);
+  });
+});
+
+describe('R_QUERIES: setGeneric names only its first argument', () => {
+  it('names the generic from the first positional string (positive control)', () => {
+    expect(definitions('setGeneric("f", function(x) standardGeneric("f"))')).toEqual([
+      'definition.function:f',
+    ]);
+  });
+
+  it('does not mint a Function from valueClass = "numeric"', () => {
+    expect(
+      definitions('setGeneric("f", function(x) standardGeneric("f"), valueClass = "numeric")'),
+    ).toEqual(['definition.function:f']);
+  });
+
+  it('names the generic from name = "f"', () => {
+    expect(
+      definitions('setGeneric(name = "f", def = function(x) standardGeneric("f"), package = "p")'),
+    ).toEqual(['definition.function:f']);
+  });
+});
+
+describe('R_QUERIES: setMethod names only its first argument', () => {
+  it('names the method from the first positional string (positive control)', () => {
+    expect(definitions('setMethod("area", signature("Circle"), function(obj) 1)')).toEqual([
+      'definition.method:area',
+    ]);
+  });
+
+  it('does not mint a Method from the class-name string in the signature slot', () => {
+    expect(definitions('setMethod("show", "Foo", function(object) cat("x"))')).toEqual([
+      'definition.method:show',
+    ]);
+  });
+
+  it('names the method from f = "show"', () => {
+    expect(
+      definitions('setMethod(f = "show", signature = "Foo", definition = function(object) 1)'),
+    ).toEqual(['definition.method:show']);
+  });
+});
+
+describe('R_QUERIES: comments between the parenthesis and an argument do not defeat the anchor', () => {
+  it('names a class when a comment precedes the first argument', () => {
+    expect(definitions('setClass(\n  # the class\n  "A", contains = "VIRTUAL")')).toEqual([
+      'definition.class:A',
+    ]);
+    expect(definitions('setRefClass(\n  # one\n  # two\n  "R", contains = "Base")')).toEqual([
+      'definition.class:R',
+    ]);
+  });
+
+  it('names a generic when a comment precedes the first argument', () => {
+    expect(
+      definitions(
+        'setGeneric(\n  # the generic\n  "f", function(x) standardGeneric("f"), valueClass = "numeric")',
+      ),
+    ).toEqual(['definition.function:f']);
+  });
+
+  it('names a method when a comment precedes the first argument', () => {
+    expect(definitions('setMethod(\n  # the method\n  "show", "Foo", function(object) 1)')).toEqual(
+      ['definition.method:show'],
+    );
+  });
+
+  it('still ignores a later string argument when a comment sits between the arguments', () => {
+    expect(definitions('setClass("A", # note\n  "B")')).toEqual(['definition.class:A']);
+    expect(definitions('setMethod("show", # note\n  "Foo", function(object) 1)')).toEqual([
+      'definition.method:show',
+    ]);
+  });
+});
+
+describe('R_QUERIES: the first unnamed argument is the name when named arguments precede it', () => {
+  it('names a method from the first unnamed argument after signature =', () => {
+    expect(definitions('setMethod(signature = "Foo", "show", function(object) 1)')).toEqual([
+      'definition.method:show',
+    ]);
+  });
+
+  it('names a class from the first unnamed argument after a named representation', () => {
+    expect(
+      definitions(
+        'setClass(representation = representation(x = "numeric"), "A", contains = "V")',
+      ).sort(),
+    ).toEqual(['definition.class:A', 'definition.property:x']);
+  });
+
+  it('names a generic from the first unnamed argument after a named argument', () => {
+    expect(
+      definitions('setGeneric(valueClass = "numeric", "f", function(x) standardGeneric("f"))'),
+    ).toEqual(['definition.function:f']);
+  });
+
+  it('does not name a second unnamed argument', () => {
+    expect(definitions('setClass("A", "B")')).toEqual(['definition.class:A']);
+    // The first unnamed argument is the representation() call, so "B" is not the name.
+    expect(definitions('setClass(representation(x = "numeric"), "B")')).toEqual([]);
+  });
+
+  it('does not take the class slot as a name when the formal is given by name', () => {
+    expect(definitions('setMethod(f = "show", "Foo", function(object) 1)')).toEqual([
+      'definition.method:show',
+    ]);
+    expect(definitions('setClass(Class = "A", "B")')).toEqual(['definition.class:A']);
+    expect(definitions('setGeneric(name = "f", "g")')).toEqual(['definition.function:f']);
+  });
+});
+
+describe('R naming argument: a backticked or quoted formal names the definition', () => {
+  it('names a class from `Class` =, "Class" = and \'Class\' =', () => {
+    expect(definitions('setClass(`Class` = "A", contains = "B")')).toEqual(['definition.class:A']);
+    expect(definitions('setClass("Class" = "A", contains = "B")')).toEqual(['definition.class:A']);
+    expect(definitions("setRefClass('Class' = 'R', contains = 'B')")).toEqual([
+      'definition.class:R',
+    ]);
+  });
+
+  it('names a generic from `name` = and a method from `f` =', () => {
+    expect(
+      definitions(
+        'setGeneric(`name` = "f", def = function(x) standardGeneric("f"), valueClass = "n")',
+      ),
+    ).toEqual(['definition.function:f']);
+    expect(definitions('setMethod(`f` = "show", signature = "Foo", definition = 1)')).toEqual([
+      'definition.method:show',
+    ]);
+  });
+
+  it('does not take a later unnamed string once the formal is given in backticks', () => {
+    expect(definitions('setClass(`Class` = "A", "B")')).toEqual(['definition.class:A']);
+  });
+
+  it('still ignores a backticked name that is not the formal', () => {
+    expect(definitions('setClass("A", `contains` = "B")')).toEqual(['definition.class:A']);
+  });
+});
+
+describe('R naming argument: a later Class = retracts an earlier unnamed argument', () => {
+  it('setClass(a = "Q", "B", Class = "A") defines A only', () => {
+    expect(definitions('setClass(a = "Q", "B", Class = "A")')).toEqual(['definition.class:A']);
+  });
+
+  it('retracts for every formal that names a definition', () => {
+    expect(definitions('setRefClass("B", Class = "A")')).toEqual(['definition.class:A']);
+    expect(definitions('setGeneric("g", name = "f", valueClass = "n")')).toEqual([
+      'definition.function:f',
+    ]);
+    expect(definitions('setMethod("g", f = "show", signature = "Foo")')).toEqual([
+      'definition.method:show',
+    ]);
+  });
+
+  it('retracts through comments, backticks and quotes', () => {
+    expect(definitions('setClass("B", # c\n `Class` = "A")')).toEqual(['definition.class:A']);
+    expect(definitions('setClass("B", "Class" = "A")')).toEqual(['definition.class:A']);
+  });
+
+  it('keeps the first unnamed argument when no named argument spells the formal', () => {
+    expect(definitions('setClass(a = "Q", "B", contains = "A")')).toEqual(['definition.class:B']);
+    expect(definitions('setClass("B", "A")')).toEqual(['definition.class:B']);
+  });
+});
+
+/**
+ * docs/languages/r-provider.md, "Limits": argument matching does not model partial
+ * argument names, and members are read only from the named forms. These pin the documented
+ * gaps so a change in either direction is deliberate.
+ */
+describe('R_QUERIES: documented argument-matching limits', () => {
+  it.each([
+    ['setClass', 'setClass(Cla = "D")'],
+    ['setRefClass', 'setRefClass(Cla = "A")'],
+  ])('does not recognise a partial argument name in %s', (_label, source) => {
+    expect(definitions(source)).toEqual([]);
+  });
+
+  it('positive control: the full formal name is recognised', () => {
+    expect(definitions('setClass(Class = "D")')).toEqual(['definition.class:D']);
+  });
+
+  it('creates no member from the positional second argument of setRefClass()', () => {
+    expect(definitions('setRefClass("A", list(x = "numeric"))')).toEqual(['definition.class:A']);
+  });
+
+  it('creates no member from the positional second argument of R6Class()', () => {
+    expect(definitions('X <- R6Class("X", list(m = function() 1, f = 2))')).toEqual([
+      'definition.class:X',
+    ]);
+  });
+
+  it('positive control: the named forms do create members', () => {
+    expect(definitions('setRefClass("A", fields = list(x = "numeric"))')).toEqual([
+      'definition.class:A',
+      'definition.property:x',
+    ]);
+    expect(definitions('X <- R6Class("X", public = list(m = function() 1))')).toEqual([
+      'definition.class:X',
+      'definition.method:m',
+    ]);
+  });
+});
+
+/**
+ * Selecting the naming argument must stay linear in the argument count: an earlier
+ * query-level formulation (a repeated sibling group before the argument) was
+ * quadratic and took seconds on a single call with thousands of arguments. The same
+ * work is run at two sizes and the time ratio is bounded (see
+ * `helpers/r-argument-scaling.ts`); the kept matches are asserted at both sizes.
+ */
+describe('R_QUERIES: cost is linear in the argument count', () => {
+  /** Parsing is set-up (untimed); the timed work is the query plus the provider's selection. */
+  const run = (source: string) => {
+    const tree = parseR(source);
+    return () => {
+      const kept = keptMatches(tree);
+      const defs: string[] = [];
+      for (const captures of kept) {
+        const def = captures.find((c) => c.name.startsWith('definition.'));
+        const name = captures.find((c) => c.name === 'name');
+        if (def && name) defs.push(`${def.name}:${name.node.text}`);
+      }
+      return { count: kept.length, defs };
+    };
+  };
+
+  const cases = [
+    { shape: SHAPES.listNamedArguments, expected: { count: 1, defs: [] } },
+    { shape: SHAPES.setClassNamedBefore, expected: { count: 2, defs: ['definition.class:A'] } },
+    { shape: SHAPES.setClassCommentsBefore, expected: { count: 2, defs: ['definition.class:A'] } },
+    { shape: SHAPES.setClassUnnamedStrings, expected: { count: 2, defs: ['definition.class:s0'] } },
+    { shape: SHAPES.setClassNamedStrings, expected: { count: 2, defs: ['definition.class:A'] } },
+  ] as const;
+
+  it.each(cases)(
+    '$shape.name',
+    ({ shape, expected }) => {
+      const { small, large, ratio } = measureScaling(run, shape.build);
+      expect(small).toEqual(expected);
+      expect(large).toEqual(expected);
+      expect(ratio).toBeLessThan(MAX_RATIO);
+    },
+    120_000,
+  );
+});
diff --git a/gitnexus/test/unit/r-export-pattern-safety.test.ts b/gitnexus/test/unit/r-export-pattern-safety.test.ts
new file mode 100644
index 000000000..ee4fa31d8
--- /dev/null
+++ b/gitnexus/test/unit/r-export-pattern-safety.test.ts
@@ -0,0 +1,888 @@
+import { describe, it, expect } from 'vitest';
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { compileRExportPattern } from '../../src/core/ingestion/languages/r/export-pattern.js';
+import {
+  compileLinearRegex,
+  compileLinearRegexDetailed,
+  MAX_STATES,
+  MAX_TOTAL_WORK,
+} from '../../src/core/ingestion/languages/r/linear-regex.js';
+
+// Names every characterisation row is evaluated against.
+const NAMES: readonly string[] = [
+  'tidy_scores',
+  '.hidden',
+  'foo_bar',
+  'bar_baz',
+  'foo',
+  'bar',
+  'a',
+  'aa',
+  'aaa',
+  'aaaa',
+  'abc',
+  'ac',
+  'Abc',
+  'A1_b',
+  'print.foo',
+  'getX',
+  'setY',
+  'x',
+  '',
+  '_x',
+  '1a',
+  'foo.',
+  'a.c',
+  'a{,2}',
+  'a{',
+  'a|b',
+  '[',
+  'a]',
+  ']',
+  'foo$',
+  'my_internal',
+  'x.y',
+  'aaab',
+  'ab',
+];
+
+// [exportPattern source, names from NAMES it matches]. Recorded from the original
+// backtracking-RegExp implementation, so this table pins behaviour that must not change.
+const CHARACTERISATION: ReadonlyArray<readonly [string, readonly string[] | null]> = [
+  [
+    '^[[:alpha:]]+',
+    [
+      'tidy_scores',
+      'foo_bar',
+      'bar_baz',
+      'foo',
+      'bar',
+      'a',
+      'aa',
+      'aaa',
+      'aaaa',
+      'abc',
+      'ac',
+      'Abc',
+      'A1_b',
+      'print.foo',
+      'getX',
+      'setY',
+      'x',
+      'foo.',
+      'a.c',
+      'a{,2}',
+      'a{',
+      'a|b',
+      'a]',
+      'foo$',
+      'my_internal',
+      'x.y',
+      'aaab',
+      'ab',
+    ],
+  ],
+  [
+    '^[^\\.]',
+    [
+      'tidy_scores',
+      'foo_bar',
+      'bar_baz',
+      'foo',
+      'bar',
+      'a',
+      'aa',
+      'aaa',
+      'aaaa',
+      'abc',
+      'ac',
+      'Abc',
+      'A1_b',
+      'print.foo',
+      'getX',
+      'setY',
+      'x',
+      '_x',
+      '1a',
+      'foo.',
+      'a.c',
+      'a{,2}',
+      'a{',
+      'a|b',
+      '[',
+      'a]',
+      ']',
+      'foo$',
+      'my_internal',
+      'x.y',
+      'aaab',
+      'ab',
+    ],
+  ],
+  ['^(foo|bar)_', ['foo_bar', 'bar_baz']],
+  [
+    '.',
+    [
+      'tidy_scores',
+      '.hidden',
+      'foo_bar',
+      'bar_baz',
+      'foo',
+      'bar',
+      'a',
+      'aa',
+      'aaa',
+      'aaaa',
+      'abc',
+      'ac',
+      'Abc',
+      'A1_b',
+      'print.foo',
+      'getX',
+      'setY',
+      'x',
+      '_x',
+      '1a',
+      'foo.',
+      'a.c',
+      'a{,2}',
+      'a{',
+      'a|b',
+      '[',
+      'a]',
+      ']',
+      'foo$',
+      'my_internal',
+      'x.y',
+      'aaab',
+      'ab',
+    ],
+  ],
+  [
+    '^',
+    [
+      'tidy_scores',
+      '.hidden',
+      'foo_bar',
+      'bar_baz',
+      'foo',
+      'bar',
+      'a',
+      'aa',
+      'aaa',
+      'aaaa',
+      'abc',
+      'ac',
+      'Abc',
+      'A1_b',
+      'print.foo',
+      'getX',
+      'setY',
+      'x',
+      '',
+      '_x',
+      '1a',
+      'foo.',
+      'a.c',
+      'a{,2}',
+      'a{',
+      'a|b',
+      '[',
+      'a]',
+      ']',
+      'foo$',
+      'my_internal',
+      'x.y',
+      'aaab',
+      'ab',
+    ],
+  ],
+  [
+    '$',
+    [
+      'tidy_scores',
+      '.hidden',
+      'foo_bar',
+      'bar_baz',
+      'foo',
+      'bar',
+      'a',
+      'aa',
+      'aaa',
+      'aaaa',
+      'abc',
+      'ac',
+      'Abc',
+      'A1_b',
+      'print.foo',
+      'getX',
+      'setY',
+      'x',
+      '',
+      '_x',
+      '1a',
+      'foo.',
+      'a.c',
+      'a{,2}',
+      'a{',
+      'a|b',
+      '[',
+      'a]',
+      ']',
+      'foo$',
+      'my_internal',
+      'x.y',
+      'aaab',
+      'ab',
+    ],
+  ],
+  [
+    '',
+    [
+      'tidy_scores',
+      '.hidden',
+      'foo_bar',
+      'bar_baz',
+      'foo',
+      'bar',
+      'a',
+      'aa',
+      'aaa',
+      'aaaa',
+      'abc',
+      'ac',
+      'Abc',
+      'A1_b',
+      'print.foo',
+      'getX',
+      'setY',
+      'x',
+      '',
+      '_x',
+      '1a',
+      'foo.',
+      'a.c',
+      'a{,2}',
+      'a{',
+      'a|b',
+      '[',
+      'a]',
+      ']',
+      'foo$',
+      'my_internal',
+      'x.y',
+      'aaab',
+      'ab',
+    ],
+  ],
+  ['foo', ['foo_bar', 'foo', 'print.foo', 'foo.', 'foo$']],
+  ['^foo', ['foo_bar', 'foo', 'foo.', 'foo$']],
+  ['foo$', ['foo', 'print.foo']],
+  ['^foo$', ['foo']],
+  [
+    'a|b',
+    [
+      'foo_bar',
+      'bar_baz',
+      'bar',
+      'a',
+      'aa',
+      'aaa',
+      'aaaa',
+      'abc',
+      'ac',
+      'Abc',
+      'A1_b',
+      '1a',
+      'a.c',
+      'a{,2}',
+      'a{',
+      'a|b',
+      'a]',
+      'my_internal',
+      'aaab',
+      'ab',
+    ],
+  ],
+  ['^(a|b)c', ['ac']],
+  [
+    '[abc]',
+    [
+      'tidy_scores',
+      'foo_bar',
+      'bar_baz',
+      'bar',
+      'a',
+      'aa',
+      'aaa',
+      'aaaa',
+      'abc',
+      'ac',
+      'Abc',
+      'A1_b',
+      '1a',
+      'a.c',
+      'a{,2}',
+      'a{',
+      'a|b',
+      'a]',
+      'my_internal',
+      'aaab',
+      'ab',
+    ],
+  ],
+  [
+    '[^abc]',
+    [
+      'tidy_scores',
+      '.hidden',
+      'foo_bar',
+      'bar_baz',
+      'foo',
+      'bar',
+      'Abc',
+      'A1_b',
+      'print.foo',
+      'getX',
+      'setY',
+      'x',
+      '_x',
+      '1a',
+      'foo.',
+      'a.c',
+      'a{,2}',
+      'a{',
+      'a|b',
+      '[',
+      'a]',
+      ']',
+      'foo$',
+      'my_internal',
+      'x.y',
+    ],
+  ],
+  ['^[a-z]+$', ['foo', 'bar', 'a', 'aa', 'aaa', 'aaaa', 'abc', 'ac', 'x', 'aaab', 'ab']],
+  ['^[[:upper:]][[:alnum:]_]*$', ['Abc', 'A1_b']],
+  [
+    '^[[:alpha:].]+$',
+    [
+      '.hidden',
+      'foo',
+      'bar',
+      'a',
+      'aa',
+      'aaa',
+      'aaaa',
+      'abc',
+      'ac',
+      'Abc',
+      'print.foo',
+      'getX',
+      'setY',
+      'x',
+      'foo.',
+      'a.c',
+      'x.y',
+      'aaab',
+      'ab',
+    ],
+  ],
+  ['\\.', ['.hidden', 'print.foo', 'foo.', 'a.c', 'x.y']],
+  ['^\\.', ['.hidden']],
+  ['^[.]', ['.hidden']],
+  ['^(?:foo|bar)', ['foo_bar', 'bar_baz', 'foo', 'bar', 'foo.', 'foo$']],
+  [
+    'x?',
+    [
+      'tidy_scores',
+      '.hidden',
+      'foo_bar',
+      'bar_baz',
+      'foo',
+      'bar',
+      'a',
+      'aa',
+      'aaa',
+      'aaaa',
+      'abc',
+      'ac',
+      'Abc',
+      'A1_b',
+      'print.foo',
+      'getX',
+      'setY',
+      'x',
+      '',
+      '_x',
+      '1a',
+      'foo.',
+      'a.c',
+      'a{,2}',
+      'a{',
+      'a|b',
+      '[',
+      'a]',
+      ']',
+      'foo$',
+      'my_internal',
+      'x.y',
+      'aaab',
+      'ab',
+    ],
+  ],
+  ['a{2,3}', ['aa', 'aaa', 'aaaa', 'aaab']],
+  ['^a{2}$', ['aa']],
+  [
+    '^\\w+$',
+    [
+      'tidy_scores',
+      'foo_bar',
+      'bar_baz',
+      'foo',
+      'bar',
+      'a',
+      'aa',
+      'aaa',
+      'aaaa',
+      'abc',
+      'ac',
+      'Abc',
+      'A1_b',
+      'getX',
+      'setY',
+      'x',
+      '_x',
+      '1a',
+      'my_internal',
+      'aaab',
+      'ab',
+    ],
+  ],
+  ['^\\d', ['1a']],
+  ['\\bfoo\\b', ['foo', 'print.foo', 'foo.', 'foo$']],
+  [
+    '^[[:alpha:]][[:alnum:]._]*$',
+    [
+      'tidy_scores',
+      'foo_bar',
+      'bar_baz',
+      'foo',
+      'bar',
+      'a',
+      'aa',
+      'aaa',
+      'aaaa',
+      'abc',
+      'ac',
+      'Abc',
+      'A1_b',
+      'print.foo',
+      'getX',
+      'setY',
+      'x',
+      'foo.',
+      'a.c',
+      'my_internal',
+      'x.y',
+      'aaab',
+      'ab',
+    ],
+  ],
+  ['^print\\.', ['print.foo']],
+  ['^(get|set)[A-Z]', ['getX', 'setY']],
+  ['a.c', ['abc', 'a.c']],
+  ['^.{3}$', ['foo', 'bar', 'aaa', 'abc', 'Abc', 'a.c', 'a|b', 'x.y']],
+  // Leading `]` in a bracket expression WITHOUT a POSIX class: these two rows record the
+  // JS-RegExp reading (`[]` is an empty class), not TRE's. They cannot tell a working
+  // matcher from a never-matching one; the discriminating checks are in the
+  // 'leading ] in a bracket expression' block below.
+  ['[]a]', []],
+  ['[^]a]', []],
+  ['^[\\]]', [']']],
+  [
+    'a+?',
+    [
+      'foo_bar',
+      'bar_baz',
+      'bar',
+      'a',
+      'aa',
+      'aaa',
+      'aaaa',
+      'abc',
+      'ac',
+      '1a',
+      'a.c',
+      'a{,2}',
+      'a{',
+      'a|b',
+      'a]',
+      'my_internal',
+      'aaab',
+      'ab',
+    ],
+  ],
+  ['a{,2}', ['a{,2}']],
+  ['a{', ['a{,2}', 'a{']],
+  ['^[[:punct:]]', ['.hidden', '_x', '[', ']']],
+  ['^.*_internal$', ['my_internal']],
+  ['^[A-Z]', ['Abc', 'A1_b']],
+  ['\\$', ['foo$']],
+  ['a\\|b', ['a|b']],
+  ['^(a+)+$', ['a', 'aa', 'aaa', 'aaaa']],
+  ['^(a|a)+$', ['a', 'aa', 'aaa', 'aaaa']],
+  ['^(a*)*b', ['bar_baz', 'bar', 'abc', 'aaab', 'ab']],
+  ['^[[:digit:]a-c_]+$', ['a', 'aa', 'aaa', 'aaaa', 'abc', 'ac', '1a', 'aaab', 'ab']],
+];
+
+describe('compileRExportPattern characterisation', () => {
+  it.each(CHARACTERISATION)('pattern %s keeps its recorded matches', (pattern, expected) => {
+    const matcher = compileRExportPattern(pattern);
+    if (expected === null) {
+      expect(matcher).toBeNull();
+      return;
+    }
+    expect(matcher).not.toBeNull();
+    expect(NAMES.filter((n) => matcher?.test(n) === true)).toEqual(expected);
+  });
+});
+
+// R compiles exportPattern() with TRE (POSIX extended): a `]` in first position of a bracket
+// expression, after an optional `^`, is a literal member. The translator only applies that
+// rule when the pattern also contains a POSIX class (`[:`); otherwise the text reaches the
+// matcher verbatim and is read as a JavaScript RegExp, where `[]` is an empty class and
+// `[^]` matches any character. The first block characterises what the code does today with
+// names that discriminate (`a`, `]`, `xa]`, `5`); the second states the TRE expectation and
+// is marked `it.fails` until export-pattern.ts translates the leading `]` unconditionally.
+// The gap is listed under the limits in docs/languages/r-provider.md.
+describe('compileRExportPattern: leading ] in a bracket expression', () => {
+  const BRACKET_NAMES = ['a', ']', 'b', '5', 'xa]', 'ba]', 'a]', 'x]', ']a'];
+  const matched = (pattern: string): readonly string[] | null => {
+    const matcher = compileRExportPattern(pattern);
+    return matcher === null ? null : BRACKET_NAMES.filter((n) => matcher.test(n));
+  };
+
+  describe('current behaviour (characterisation, JS-RegExp reading)', () => {
+    it.each([
+      ['[]a]', []],
+      ['[]]', []],
+      ['[^]a]', ['xa]', 'ba]']],
+      ['[^]]', ['xa]', 'ba]', 'a]', 'x]']],
+    ] as const)('%s matches %j', (pattern, expected) => {
+      expect(matched(pattern)).toEqual(expected);
+    });
+
+    it('applies the TRE rule once a POSIX class is present (translated path)', () => {
+      expect(matched('[]a[:digit:]]')).toEqual(['a', ']', '5', 'xa]', 'ba]', 'a]', 'x]', ']a']);
+      expect(matched('[^]a[:digit:]]')).toEqual(['b', 'xa]', 'ba]', 'x]']);
+    });
+  });
+
+  describe('TRE expectation (known gap)', () => {
+    // The expected sets come from the equivalent JavaScript RegExp with the leading `]`
+    // escaped, so the expectation is computed, not hand-listed, and is never empty by luck.
+    it.fails.each([
+      ['[]a]', /[\]a]/],
+      ['[]]', /[\]]/],
+      ['[^]a]', /[^\]a]/],
+      ['[^]]', /[^\]]/],
+    ] as const)('%s behaves like its escaped equivalent', (pattern, oracle) => {
+      const expected = BRACKET_NAMES.filter((n) => oracle.test(n));
+      expect(expected.length).toBeGreaterThan(0);
+      expect(matched(pattern)).toEqual(expected);
+    });
+  });
+});
+
+// Differential check against the JavaScript RegExp the matcher replaced. Patterns are
+// built from a fixed atom list by a seeded generator, so the corpus is deterministic.
+// Names are short enough that even a catastrophic generated pattern finishes instantly
+// on the oracle.
+describe('compileRExportPattern agrees with RegExp on generated patterns', () => {
+  const ATOMS = [
+    'a',
+    'b',
+    '1',
+    '_',
+    '\\.',
+    '.',
+    '[ab]',
+    '[^a]',
+    '[a-c]',
+    '[^.]',
+    '(?:$)',
+    '(\\b)',
+    '[a.]',
+    '\\d',
+    '\\w',
+    '\\s',
+    '\\D',
+    '\\W',
+    '\\b',
+    '\\B',
+    '^',
+    '$',
+    '(',
+    '(?:',
+    ')',
+    '|',
+    '*',
+    '+',
+    '?',
+    '{2}',
+    '{1,2}',
+    '{2,}',
+    '{,1}',
+    '{',
+    '}',
+    '*?',
+    '+?',
+    '??',
+    '{1,2}?',
+    '[',
+    ']',
+    '[]',
+    '\\x61',
+    '\\u0062',
+    '\\t',
+    '\\-',
+    '[\\d-z]',
+    '[z-a]',
+  ];
+  const NAME_ALPHABET = ['a', 'b', '1', '_', '.', ' ', 'c', '\t'];
+
+  function lcg(seed: number): () => number {
+    let state = seed >>> 0;
+    return () => {
+      state = (Math.imul(state, 1664525) + 1013904223) >>> 0;
+      return state / 0x100000000;
+    };
+  }
+
+  it('returns the same verdict, or null exactly when RegExp rejects the source', () => {
+    const rand = lcg(20260930);
+    const pick = <T>(xs: readonly T[]): T => xs[Math.floor(rand() * xs.length)];
+    const names: string[] = [''];
+    for (let i = 0; i < 60; i++) {
+      const len = Math.floor(rand() * 6);
+      let n = '';
+      for (let j = 0; j < len; j++) n += pick(NAME_ALPHABET);
+      names.push(n);
+    }
+    let compiled = 0;
+    let rejected = 0;
+    for (let i = 0; i < 4000; i++) {
+      const parts = Math.floor(rand() * 7) + 1;
+      let source = '';
+      for (let j = 0; j < parts; j++) source += pick(ATOMS);
+      let oracle: RegExp | null = null;
+      try {
+        oracle = new RegExp(source);
+      } catch {
+        oracle = null;
+      }
+      const matcher = compileRExportPattern(source);
+      if (oracle === null) {
+        expect(matcher, `source ${JSON.stringify(source)} is invalid for RegExp`).toBeNull();
+        rejected++;
+        continue;
+      }
+      expect(matcher, `source ${JSON.stringify(source)} is valid for RegExp`).not.toBeNull();
+      compiled++;
+      for (const name of names) {
+        expect(matcher?.test(name), `${JSON.stringify(source)} vs ${JSON.stringify(name)}`).toBe(
+          oracle.test(name),
+        );
+      }
+    }
+    // The corpus must exercise both branches, or the comparison proves nothing.
+    expect(compiled).toBeGreaterThan(500);
+    expect(rejected).toBeGreaterThan(500);
+  });
+});
+
+// docs/languages/r-provider.md: "Character classes use ASCII semantics." R's TRE engine would
+// match a locale's letters; the translator deliberately does not, so this is pinned.
+describe('compileRExportPattern: POSIX classes are ASCII-only', () => {
+  it.each([
+    ['^[[:alpha:]]+$', 'abc', 'caf\u00e9'],
+    ['^[[:alnum:]]+$', 'ab12', 'na\u00efve1'],
+    ['^[[:upper:]]+$', 'ABC', '\u00c9COLE'],
+    ['^[[:lower:]]+$', 'abc', 'stra\u00dfe'],
+    ['^[[:punct:]]+$', '!?', '\u00bf'],
+  ])('%s matches %s but not %s', (source, ascii, nonAscii) => {
+    const matcher = compileRExportPattern(source);
+    expect(matcher).not.toBeNull();
+    expect(matcher?.test(ascii)).toBe(true);
+    expect(matcher?.test(nonAscii)).toBe(false);
+  });
+});
+
+// A hostile pattern must not be able to stall the analyzer. The matching runs in a child
+// process with a hard timeout so that a regression fails the test instead of hanging the
+// whole suite for minutes. The timeout is only that hang guard: the bound itself is on the
+// matcher's deterministic state-visit counter, never on wall-clock time.
+describe('compileRExportPattern is linear-time on catastrophic patterns', () => {
+  const modulePath = path.resolve(
+    path.dirname(fileURLToPath(import.meta.url)),
+    '../../src/core/ingestion/languages/r/export-pattern.ts',
+  );
+  const GITNEXUS_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
+  const HOSTILE = [
+    '^(a+)+$',
+    '^(a|a)+$',
+    '^(a*)*b',
+    '(a|aa)+$',
+    '^(.*a){20}$',
+    '(x+x+)+y',
+    '^([a-z]+)*$',
+    '^(a?){30}a{30}$',
+  ];
+
+  it('does linear work on every hostile pattern for 40 and 10,000 character names', () => {
+    const script = `
+      const { compileRExportPattern } = await import(${JSON.stringify(pathToFileURL(modulePath).href)});
+      const out = [];
+      for (const p of ${JSON.stringify(HOSTILE)}) {
+        for (const len of [40, 10000]) {
+          const name = 'a'.repeat(len - 1) + '!';
+          const m = compileRExportPattern(p);
+          const r = m ? m.test(name) : false;
+          out.push({ p, len, r, work: m?.work, states: m?.stateCount, exhausted: m?.exhausted });
+        }
+      }
+      console.log('RESULT' + JSON.stringify(out));
+    `;
+    const res = spawnSync(
+      process.execPath,
+      ['--import', 'tsx', '--input-type=module', '-e', script],
+      {
+        encoding: 'utf-8',
+        timeout: 30_000,
+        // `cwd` pins how `--import tsx` resolves (vitest may be run from the repository root).
+        cwd: GITNEXUS_ROOT,
+      },
+    );
+    expect(res.error, 'hostile pattern stalled past the 30 s guard').toBeUndefined();
+    expect(res.status, res.stderr).toBe(0);
+    const line = res.stdout.split('\n').find((l) => l.startsWith('RESULT'));
+    expect(line).toBeDefined();
+    const rows = JSON.parse((line ?? '').slice('RESULT'.length)) as Array<{
+      p: string;
+      len: number;
+      r: boolean;
+      work?: number;
+      states?: number;
+      exhausted?: boolean;
+    }>;
+    expect(rows).toHaveLength(HOSTILE.length * 2);
+    for (const row of rows) {
+      const label = `${row.p} on ${row.len} characters`;
+      expect(row.r, `${row.p} must not match`).toBe(false);
+      // A backtracking RegExp has no counter: `work` would be undefined and this fails.
+      expect(typeof row.work, label).toBe('number');
+      expect(row.exhausted, label).toBe(false);
+      // Linear: at most a few state visits per input character per NFA state (measured
+      // peak is ~1.6), and nowhere near the per-matcher budget.
+      expect(row.work as number, label).toBeLessThanOrEqual(
+        3 * (row.states as number) * (row.len + 1),
+      );
+      expect(row.work as number, label).toBeLessThan(MAX_TOTAL_WORK);
+    }
+  }, 60_000);
+
+  it('still reports a true match for a hostile-shaped pattern', () => {
+    expect(compileRExportPattern('^(a+)+$')?.test('a'.repeat(10_000))).toBe(true);
+    expect(compileRExportPattern('^(a|a)+$')?.test('aaaa')).toBe(true);
+    expect(compileRExportPattern('^(a*)*b')?.test('aab')).toBe(true);
+  });
+
+  it('no longer hands back a backtracking RegExp', () => {
+    expect(compileRExportPattern('^(a+)+$')).not.toBeInstanceOf(RegExp);
+    expect(compileRExportPattern('^[[:alpha:]]+')).not.toBeInstanceOf(RegExp);
+  });
+
+  it('drops constructs it cannot match in linear time, like an uncompilable pattern', () => {
+    for (const unsupported of [
+      '(a)\\1',
+      '(?=a)a',
+      '(?!a)a',
+      '(?<=a)b',
+      '(?<!a)b',
+      '(?<n>a)\\k<n>',
+    ]) {
+      expect(compileRExportPattern(unsupported), unsupported).toBeNull();
+    }
+  });
+
+  describe('"(?<" is only a group opener outside a character class and an escape', () => {
+    it.each([
+      ['[(?<]', ['(', '?', '<'], ['a', '']],
+      ['[^(?<]x', ['ax'], ['(x', '<x']],
+      ['^[(?<]+$', ['(<?', '<'], ['a<', '']],
+      ['[(?<]\\k', ['(k'], ['k']],
+      ['\\(?<x', ['<x', '(<x'], ['x']],
+      ['\\[[(?<]', ['[<', '[('], ['<']],
+      ['[\\]](?:a)', [']a'], ['a']],
+      ['[\\](?<]x', ['(x', ']x', '<x'], ['ax']],
+      ['[[(?<]', ['[', '('], ['a']],
+    ])('compiles %s and matches it as written', (pattern, matching, notMatching) => {
+      const regex = compileLinearRegex(pattern);
+      expect(regex, pattern).not.toBeNull();
+      for (const name of matching) expect(regex?.test(name), `${pattern} ~ ${name}`).toBe(true);
+      for (const name of notMatching) {
+        expect(regex?.test(name), `${pattern} !~ ${name}`).toBe(false);
+      }
+    });
+
+    it.each([
+      ['a real look-behind', '(?<=x)y'],
+      ['a negative look-behind', '(?<!x)y'],
+      ['a named group', '(?<n>a)'],
+      ['after a closed class', '[ab](?<=x)'],
+      ['after a class holding an escaped ]', '[\\]](?<=x)'],
+      ['after an escaped [', '\\[(?<=x)'],
+      ['after a class that holds (?<', '[(?<](?<=x)'],
+      ['inside a group', '(a|(?<=x)b)'],
+    ])('still rejects %s', (_label, pattern) => {
+      expect(compileLinearRegex(pattern), pattern).toBeNull();
+    });
+
+    it('reports a named group or look-behind as such', () => {
+      for (const pattern of ['(?<=x)y', '(?<n>a)']) {
+        expect(compileLinearRegexDetailed(pattern)).toMatchObject({
+          regex: null,
+          reason: expect.stringContaining('look-behind'),
+        });
+      }
+    });
+  });
+
+  it('bounds the matcher by pattern size, not by the name it is run against', () => {
+    // The state count is fixed at compile time and capped, so the work per tested name
+    // is at most name length x MAX_STATES whatever the pattern says.
+    const nested = compileLinearRegex('^(a+)+$');
+    expect(nested).not.toBeNull();
+    expect(nested?.stateCount).toBeLessThanOrEqual(16);
+    const widest = compileLinearRegex('a{' + (MAX_STATES - 2) + '}');
+    expect(widest).not.toBeNull();
+    expect(widest?.stateCount).toBeLessThanOrEqual(MAX_STATES);
+    expect(compileLinearRegex('a{' + (MAX_STATES + 1) + '}')).toBeNull();
+  });
+
+  it('rejects nested empty repetition that would expand exponentially', () => {
+    expect(
+      compileRExportPattern(
+        '((((((((((){1000}){1000}){1000}){1000}){1000}){1000}){1000}){1000}){1000}){1000}',
+      ),
+    ).toBeNull();
+  });
+
+  it('drops a pattern whose repetition expands beyond the size cap', () => {
+    expect(compileRExportPattern('(a{1000}){1000}')).toBeNull();
+    expect(compileRExportPattern('a{100000}')).toBeNull();
+    expect(compileRExportPattern('a{3}')).not.toBeNull();
+  });
+});
diff --git a/gitnexus/test/unit/r-export-pattern-scale.test.ts b/gitnexus/test/unit/r-export-pattern-scale.test.ts
new file mode 100644
index 000000000..8d00e7822
--- /dev/null
+++ b/gitnexus/test/unit/r-export-pattern-scale.test.ts
@@ -0,0 +1,340 @@
+import { describe, it, expect } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { SupportedLanguages } from 'gitnexus-shared';
+import { createKnowledgeGraph } from '../../src/core/graph/graph.js';
+import { refineRExportStatus } from '../../src/core/ingestion/languages/r/post-parse.js';
+import {
+  loadRPackageConfig,
+  reportRExportPatternProblems,
+  type RPackageConfig,
+} from '../../src/core/ingestion/languages/r/package-config.js';
+import {
+  compileLinearRegex,
+  MAX_PATTERN_LENGTH,
+  MAX_STATES,
+  MAX_TOTAL_WORK,
+} from '../../src/core/ingestion/languages/r/linear-regex.js';
+import { compileRExportPattern } from '../../src/core/ingestion/languages/r/export-pattern.js';
+import { _captureLogger } from '../../src/core/logger.js';
+import { createTempDirPool } from '../helpers/temp-dir-pool.js';
+
+/** The `gitnexus/` package root: child processes run from here so `--import tsx` resolves. */
+const GITNEXUS_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
+
+// Seeded generator so the corpus is the same on every run.
+const rng = (seed: number) => () => {
+  seed = (Math.imul(seed, 1664525) + 1013904223) >>> 0;
+  return seed / 0x100000000;
+};
+
+/** `count` distinct identifiers of 8 to 20 characters, many sharing prefixes. */
+const identifiers = (count: number, seed: number): string[] => {
+  const next = rng(seed);
+  const prefixes = ['get_', 'set_', 'tidy_', 'my_function_', 'read.', 'write.', ''];
+  const alphabet = 'abcdefghijklmnopqrstuvwxyz_0123456789';
+  const seen = new Set<string>();
+  while (seen.size < count) {
+    const prefix = prefixes[Math.floor(next() * prefixes.length)];
+    let word = prefix;
+    const length = 8 + Math.floor(next() * 12);
+    while (word.length < length) word += alphabet[Math.floor(next() * alphabet.length)];
+    seen.add(word);
+  }
+  return [...seen];
+};
+
+describe('exportPattern alternations and repeats at realistic sizes', () => {
+  const pool = createTempDirPool('gn-r-scale-');
+
+  const loadWith = async (namespace: string): Promise<RPackageConfig> => {
+    const root = pool.dir();
+    fs.writeFileSync(path.join(root, 'DESCRIPTION'), 'Package: scalepkg\n');
+    fs.writeFileSync(path.join(root, 'NAMESPACE'), namespace);
+    return loadRPackageConfig(root);
+  };
+
+  /** Run refineRExportStatus over one node per name and return the exported ones. */
+  const exported = (config: RPackageConfig, names: readonly string[]): Set<string> => {
+    const graph = createKnowledgeGraph();
+    for (const name of names) {
+      graph.addNode({
+        id: `Function:R/a.R:${name}`,
+        label: 'Function',
+        properties: {
+          name,
+          filePath: 'R/a.R',
+          language: SupportedLanguages.R,
+          isExported: true,
+        },
+      });
+    }
+    refineRExportStatus(graph, config);
+    const out = new Set<string>();
+    graph.forEachNode((n) => {
+      if (n.properties.isExported === true) out.add(String(n.properties.name));
+    });
+    return out;
+  };
+
+  for (const count of [80, 200, 500]) {
+    it(`marks exactly the ${count} alternated names as exported`, async () => {
+      const wanted = identifiers(count, count);
+      const decoys = [
+        ...wanted.map((n) => n + 'x'),
+        ...wanted.map((n) => 'x' + n),
+        ...wanted.map((n) => n.slice(0, -1)),
+        ...identifiers(count, count + 1000).filter((n) => !wanted.includes(n)),
+      ];
+      const pattern = `^(${wanted.map((n) => n.replace(/\./g, '\\\\.')).join('|')})$`;
+      const config = await loadWith(`exportPattern("${pattern}")\n`);
+
+      const info = config.namespaceInfoByPackageDir.get('');
+      expect(info?.exportPatterns).toHaveLength(1);
+      expect(info?.droppedExportPatterns ?? []).toEqual([]);
+      expect(exported(config, [...wanted, ...decoys])).toEqual(new Set(wanted));
+    });
+  }
+
+  it('accepts an unanchored alternation of 500 names and agrees with RegExp', () => {
+    const wanted = identifiers(500, 7);
+    const source = `(${wanted.map((n) => n.replace(/\./g, '\\.')).join('|')})`;
+    const matcher = compileRExportPattern(source);
+    const oracle = new RegExp(source);
+    expect(matcher).not.toBeNull();
+    const probes = [
+      ...wanted,
+      ...wanted.map((n) => `pre_${n}_post`),
+      ...wanted.map((n) => n.slice(1)),
+      ...identifiers(300, 99),
+    ];
+    for (const name of probes) expect(matcher?.test(name), name).toBe(oracle.test(name));
+  });
+
+  it('accepts a bounded repeat of 2000 and applies its bounds', async () => {
+    const config = await loadWith('exportPattern("^[[:alpha:]]{1,2000}$")\n');
+    expect(config.namespaceInfoByPackageDir.get('')?.droppedExportPatterns ?? []).toEqual([]);
+    const inside = ['a', 'Z'.repeat(1999), 'q'.repeat(2000)];
+    const outside = ['q'.repeat(2001), 'a1', '_a', 'a'.repeat(1000) + '.'];
+    const got = exported(config, [...inside, ...outside]);
+    // Compared by length: a failure should not print 2,000-character names.
+    expect([...got].map((n) => n.length).sort((a, b) => a - b)).toEqual([1, 1999, 2000]);
+    expect(inside.every((n) => got.has(n))).toBe(true);
+  });
+
+  it('shares prefixes without changing what an alternation of literals matches', () => {
+    const next = rng(2024);
+    const pieces = ['a', 'b', 'ab', 'ba', 'abc', 'x_', '.', '', 'ab.'];
+    const words = (n: number): string[] =>
+      Array.from({ length: n }, () =>
+        Array.from({ length: Math.floor(next() * 4) }, () => pieces[Math.floor(next() * 9)]).join(
+          '',
+        ),
+      );
+    const esc = (w: string): string => w.replace(/\./g, '\\.');
+    let compared = 0;
+    for (let i = 0; i < 300; i++) {
+      const alternatives = words(1 + Math.floor(next() * 8)).map(esc);
+      const body = alternatives.join('|');
+      const wrappers = [
+        `^(${body})$`,
+        `(${body})`,
+        `^(?:${body})`,
+        `(?:${body})$`,
+        `(${body})+$`,
+        `\\b(${body})\\b`,
+        `^x?(${body}){1,2}c?$`,
+      ];
+      for (const source of wrappers) {
+        const matcher = compileLinearRegex(source);
+        const oracle = new RegExp(source);
+        expect(matcher, source).not.toBeNull();
+        for (const probe of [...words(12), 'abab', 'x_ab.c', 'c', 'a b']) {
+          expect(matcher?.test(probe), `${source} vs ${JSON.stringify(probe)}`).toBe(
+            oracle.test(probe),
+          );
+          compared++;
+        }
+      }
+    }
+    expect(compared).toBeGreaterThan(20000);
+  });
+
+  it('keeps the caps above the sizes above and still rejects what exceeds them', () => {
+    expect(MAX_STATES).toBeGreaterThanOrEqual(8000);
+    expect(MAX_PATTERN_LENGTH).toBeGreaterThanOrEqual(8000);
+    expect(compileLinearRegex('x'.repeat(MAX_PATTERN_LENGTH + 1))).toBeNull();
+    expect(compileLinearRegex('(' + 'a{1,' + MAX_STATES + '}|b)')).toBeNull();
+  });
+});
+
+describe('a dropped exportPattern is reported', () => {
+  const pool = createTempDirPool('gn-r-drop-');
+
+  const load = async (namespace: string, pkgDir = ''): Promise<RPackageConfig> => {
+    const root = pool.dir();
+    const dir = path.join(root, pkgDir);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, 'DESCRIPTION'), 'Package: dropped\n');
+    fs.writeFileSync(path.join(dir, 'NAMESPACE'), namespace);
+    return loadRPackageConfig(root);
+  };
+
+  const captured = async (run: () => Promise<void> | void): Promise<string[]> => {
+    const cap = _captureLogger();
+    try {
+      await run();
+      return cap.records().map((r) => String(r.msg ?? ''));
+    } finally {
+      cap.restore();
+    }
+  };
+
+  it('records and warns once for a construct outside the supported subset', async () => {
+    const config = await load('export(keep)\nexportPattern("^(?=a)a")\n', 'pkgs/dropped');
+    const info = config.namespaceInfoByPackageDir.get('pkgs/dropped');
+    expect(info?.exportPatterns).toEqual([]);
+    expect(info?.droppedExportPatterns).toEqual([
+      { pattern: '^(?=a)a', reason: expect.stringContaining('look-around') },
+    ]);
+
+    const messages = await captured(() => reportRExportPatternProblems(config));
+    expect(messages).toHaveLength(1);
+    expect(messages[0]).toContain('pkgs/dropped');
+    expect(messages[0]).toContain('^(?=a)a');
+    expect(messages[0]).toContain('look-around');
+  });
+
+  it('records and warns once for a pattern over the size cap, quoting a truncated pattern', async () => {
+    const tooLong = '^[[:alpha:]]{1,' + MAX_STATES + '}$';
+    const config = await load(`exportPattern("${tooLong}")\nexportPattern("${tooLong}")\n`);
+    const info = config.namespaceInfoByPackageDir.get('');
+    expect(info?.droppedExportPatterns).toHaveLength(1);
+
+    const longest = '^(' + 'a'.repeat(MAX_PATTERN_LENGTH) + ')$';
+    const config2 = await load(`exportPattern("${longest}")\n`);
+    const messages = await captured(() => {
+      reportRExportPatternProblems(config);
+      reportRExportPatternProblems(config2);
+    });
+    expect(messages).toHaveLength(2);
+    expect(messages[0]).toContain('state cap');
+    expect(messages[1]).toContain(`longer than ${MAX_PATTERN_LENGTH}`);
+    // The pattern is quoted, but only its first 60 characters.
+    expect(messages[1]).toContain('^(' + 'a'.repeat(58) + '...');
+    expect(messages[1]).not.toContain('a'.repeat(100));
+  });
+
+  it('reports an unterminated bracket or unknown POSIX class', async () => {
+    const config = await load('exportPattern("^[[:nope:]]")\n');
+    const messages = await captured(() => reportRExportPatternProblems(config));
+    expect(messages).toHaveLength(1);
+    expect(messages[0]).toContain('POSIX class');
+  });
+
+  it('stays silent when every pattern compiles', async () => {
+    const config = await load('exportPattern("^[[:alpha:]]+")\nexportPattern("^(a|b)$")\n');
+    expect(config.namespaceInfoByPackageDir.get('')?.droppedExportPatterns).toEqual([]);
+    expect(await captured(() => reportRExportPatternProblems(config))).toEqual([]);
+  });
+});
+
+describe('a hostile exportPattern stays within its work budget', () => {
+  const HOSTILE = [
+    'a?'.repeat(500) + 'c',
+    'a?'.repeat(8000) + 'c',
+    '[A-Za-z]{1,2000}c',
+    '(' + Array.from({ length: 120 }, (_, i) => 'a'.repeat(i + 1) + 'b').join('|') + ')',
+    '(a*)*(a*)*(a*)*(a*)*c',
+  ];
+  const distinctNames = (count: number): string[] =>
+    Array.from({ length: count }, (_, i) => 'a'.repeat(94) + String(i).padStart(5, '0') + 'a');
+
+  it('spends at most the budget however many names it is tested against', () => {
+    const names = distinctNames(30_000);
+    for (const source of HOSTILE) {
+      const matcher = compileLinearRegex(source);
+      expect(matcher, source.slice(0, 40)).not.toBeNull();
+      let matched = 0;
+      for (const name of names) if (matcher?.test(name)) matched++;
+      expect(matched).toBe(0);
+      // One position may overshoot the check by a closure, never by more.
+      expect(matcher?.work, source.slice(0, 40)).toBeLessThanOrEqual(
+        MAX_TOTAL_WORK + 4 * (matcher?.stateCount ?? 0),
+      );
+    }
+  }, 60_000);
+
+  it('reports exhaustion, answers false afterwards and does no more work', () => {
+    const matcher = compileLinearRegex('a?'.repeat(500) + 'c');
+    const names = distinctNames(30_000);
+    for (const name of names) matcher?.test(name);
+    expect(matcher?.exhausted).toBe(true);
+    const spent = matcher?.work;
+    expect(matcher?.test('a'.repeat(99) + 'c')).toBe(false);
+    expect(matcher?.work).toBe(spent);
+  }, 60_000);
+
+  it('does not exhaust on patterns of realistic size run against many realistic names', () => {
+    const names = Array.from({ length: 50_000 }, (_, i) => `obj_${i}_handler_name`);
+    const wanted = identifiers(500, 3);
+    const sources = [
+      `^(${wanted.join('|').replace(/\./g, '\\.')})$`,
+      `(${wanted.join('|').replace(/\./g, '\\.')})`,
+      '^[A-Za-z]{1,2000}$',
+      '^[^.]',
+      '_handler',
+    ];
+    for (const source of sources) {
+      const matcher = compileLinearRegex(source);
+      for (const name of names) matcher?.test(name);
+      expect(matcher?.exhausted, source.slice(0, 40)).toBe(false);
+    }
+  });
+
+  it('completes the hostile set on 50,000 distinct 100-character names in a child process', () => {
+    const modulePath = path.resolve(
+      path.dirname(fileURLToPath(import.meta.url)),
+      '../../src/core/ingestion/languages/r/export-pattern.ts',
+    );
+    const script = `
+      const { compileRExportPattern } = await import(${JSON.stringify(pathToFileURL(modulePath).href)});
+      const names = Array.from({ length: 50000 }, (_, i) => 'a'.repeat(94) + String(i).padStart(5, '0') + 'a');
+      const out = [];
+      for (const p of ${JSON.stringify(HOSTILE)}) {
+        const m = compileRExportPattern(p);
+        let hits = 0;
+        for (const n of names) if (m.test(n)) hits++;
+        out.push({ hits, exhausted: m.exhausted, work: m.work, states: m.stateCount });
+      }
+      console.log('RESULT' + JSON.stringify(out));
+    `;
+    const res = spawnSync(
+      process.execPath,
+      ['--import', 'tsx', '--input-type=module', '-e', script],
+      // `cwd` pins how `--import tsx` resolves (vitest may be run from the repository root).
+      { encoding: 'utf-8', timeout: 60_000, cwd: GITNEXUS_ROOT },
+    );
+    // The spawn is only a hang guard; the bound below is on the deterministic work counter.
+    expect(res.error, 'hostile patterns stalled past the 60 s guard').toBeUndefined();
+    expect(res.status, res.stderr).toBe(0);
+    const line = res.stdout.split('\n').find((l) => l.startsWith('RESULT'));
+    const rows = JSON.parse((line ?? '').slice('RESULT'.length)) as Array<{
+      hits: number;
+      exhausted: boolean;
+      work: number;
+      states: number;
+    }>;
+    expect(rows).toHaveLength(HOSTILE.length);
+    // Bounded by state visits (see MAX_TOTAL_WORK), not by time: a backtracking matcher
+    // has no `work` counter at all and fails the type check.
+    for (const row of rows) {
+      expect(row.hits).toBe(0);
+      expect(typeof row.work).toBe('number');
+      expect(row.work).toBeGreaterThan(0);
+      expect(row.work).toBeLessThanOrEqual(MAX_TOTAL_WORK + 4 * row.states);
+    }
+  }, 90_000);
+});
diff --git a/gitnexus/test/unit/r-export-pattern-shared-budget.test.ts b/gitnexus/test/unit/r-export-pattern-shared-budget.test.ts
new file mode 100644
index 000000000..297e35b41
--- /dev/null
+++ b/gitnexus/test/unit/r-export-pattern-shared-budget.test.ts
@@ -0,0 +1,558 @@
+import { describe, it, expect } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+import { SupportedLanguages } from 'gitnexus-shared';
+import { createKnowledgeGraph } from '../../src/core/graph/graph.js';
+import { refineRExportStatus } from '../../src/core/ingestion/languages/r/post-parse.js';
+import {
+  loadRPackageConfig,
+  MAX_LISTED_DROPPED_PATTERNS,
+  reportRExportPatternProblems,
+  rExportPatternMatches,
+  type RNamespaceInfo,
+  type RPackageConfig,
+} from '../../src/core/ingestion/languages/r/package-config.js';
+import {
+  compileLinearRegex,
+  compileLinearRegexDetailed,
+  MAX_PACKAGE_STATES,
+  MAX_PACKAGE_WORK,
+  MAX_SHARED_STATES,
+  MAX_SHARED_WORK,
+  MAX_STATES,
+  MAX_TOTAL_WORK,
+  SharedWorkBudget,
+  type LinearRegex,
+} from '../../src/core/ingestion/languages/r/linear-regex.js';
+import {
+  compileRExportPattern,
+  compileRExportPatternDetailed,
+} from '../../src/core/ingestion/languages/r/export-pattern.js';
+import { _captureLogger } from '../../src/core/logger.js';
+import { createTempDirPool } from '../helpers/temp-dir-pool.js';
+
+/** A pattern that keeps hundreds of states active on a long name: exhausts a matcher fast. */
+const hostile = (k: number): string => `${'a?'.repeat(500)}c${k}`;
+
+const distinctNames = (count: number, prefix = 94): string[] =>
+  Array.from({ length: count }, (_, i) => 'a'.repeat(prefix) + String(i).padStart(5, '0') + 'a');
+
+describe('a shared work budget bounds the total across matchers', () => {
+  it('is larger than one matcher budget, so a single heavy pattern is not cut earlier', () => {
+    expect(MAX_SHARED_WORK).toBeGreaterThan(MAX_TOTAL_WORK);
+  });
+
+  it('charges every matcher that draws on it and stops them all once it is spent', () => {
+    const budget = new SharedWorkBudget(2_000_000);
+    const first = compileLinearRegex(hostile(1), budget) as LinearRegex;
+    const second = compileLinearRegex(hostile(2), budget) as LinearRegex;
+    const names = distinctNames(5_000);
+
+    for (const name of names) first.test(name);
+    expect(first.exhausted).toBe(true);
+    // One position may overshoot the check by a closure, never by more.
+    expect(budget.spent).toBeLessThanOrEqual(2_000_000 + 4 * first.stateCount);
+    expect(budget.spent).toBe(first.work);
+
+    // The second matcher never ran, yet it stops at once: no work, exhausted, false.
+    const before = budget.spent;
+    for (const name of names) expect(second.test(name)).toBe(false);
+    expect(second.exhausted).toBe(true);
+    expect(second.work).toBe(0);
+    expect(budget.spent).toBe(before);
+  });
+
+  it('keeps answering names it already decided after the budget is spent', () => {
+    const budget = new SharedWorkBudget(1_000_000);
+    const matcher = compileLinearRegex('^foo_', budget) as LinearRegex;
+    expect(matcher.test('foo_bar')).toBe(true);
+    expect(matcher.test('bar')).toBe(false);
+    const spender = compileLinearRegex(hostile(3), budget) as LinearRegex;
+    for (const name of distinctNames(5_000)) spender.test(name);
+    expect(spender.exhausted).toBe(true);
+    expect(matcher.test('foo_bar')).toBe(true);
+    expect(matcher.test('bar')).toBe(false);
+    expect(matcher.exhausted).toBe(false);
+    // A name it has not decided is read as not matching, and is reported.
+    expect(matcher.test('foo_new')).toBe(false);
+    expect(matcher.exhausted).toBe(true);
+  });
+
+  it('still applies the per-matcher cap with a budget that is not yet spent', () => {
+    const budget = new SharedWorkBudget(10 * MAX_TOTAL_WORK);
+    const matcher = compileLinearRegex(hostile(4), budget) as LinearRegex;
+    for (const name of distinctNames(30_000)) matcher.test(name);
+    expect(matcher.exhausted).toBe(true);
+    expect(matcher.work).toBeLessThanOrEqual(MAX_TOTAL_WORK + 4 * matcher.stateCount);
+    expect(budget.spent).toBe(matcher.work);
+  }, 60_000);
+
+  it('is deterministic: the same inputs spend the same work', () => {
+    const run = (): number[] => {
+      const budget = new SharedWorkBudget(3_000_000);
+      const matchers = [hostile(5), hostile(6), '^(get|set)_'].map(
+        (p) => compileLinearRegex(p, budget) as LinearRegex,
+      );
+      for (const name of distinctNames(2_000)) for (const m of matchers) m.test(name);
+      return [...matchers.map((m) => m.work), budget.spent];
+    };
+    expect(run()).toEqual(run());
+  });
+
+  it('threads through compileRExportPattern', () => {
+    const budget = new SharedWorkBudget(100_000);
+    const m = compileRExportPattern(hostile(7), budget);
+    for (const name of distinctNames(500)) m?.test(name);
+    expect(m?.exhausted).toBe(true);
+    expect(budget.spent).toBeLessThanOrEqual(100_000 + 4_000);
+  });
+});
+
+describe('budgets nest: a package draws on its own sub-budget and on the load', () => {
+  it('orders the caps: package inside load, load above one matcher', () => {
+    expect(MAX_PACKAGE_WORK).toBeLessThan(MAX_SHARED_WORK);
+    expect(MAX_PACKAGE_STATES).toBeLessThan(MAX_SHARED_STATES);
+    expect(MAX_PACKAGE_STATES).toBeGreaterThanOrEqual(MAX_STATES);
+  });
+
+  it('charges a child to its parent, not to its sibling, and spends the parent with it', () => {
+    const load = new SharedWorkBudget(1_000, 100);
+    const a = load.child(600, 60);
+    const b = load.child(600, 60);
+    a.charge(500);
+    expect([a.spent, b.spent, load.spent]).toEqual([500, 0, 500]);
+    expect([a.isSpent, b.isSpent, load.isSpent]).toEqual([false, false, false]);
+    a.charge(100);
+    expect([a.isSpent, b.isSpent, load.isSpent]).toEqual([true, false, false]);
+    b.charge(400);
+    // The load is spent, and so is every package under it, whatever its own share.
+    expect([a.isSpent, b.isSpent, load.isSpent]).toEqual([true, true, true]);
+  });
+
+  it('limits states by the tighter of package and load', () => {
+    const load = new SharedWorkBudget(1_000, 100);
+    const a = load.child(1_000, 80);
+    const b = load.child(1_000, 80);
+    expect(a.statesLeft).toBe(80);
+    a.reserveStates(70);
+    expect([a.statesLeft, b.statesLeft, load.statesLeft]).toEqual([10, 30, 30]);
+    b.reserveStates(30);
+    expect([a.statesLeft, b.statesLeft, load.statesLeft]).toEqual([0, 0, 0]);
+  });
+
+  it('refuses a pattern that does not fit the states left, without keeping its NFA', () => {
+    const budget = new SharedWorkBudget(MAX_SHARED_WORK, 1_000);
+    expect(compileLinearRegex('a'.repeat(600), budget)).not.toBeNull();
+    // A pattern that fits is compiled.
+    expect(compileLinearRegex('b'.repeat(200), budget)).not.toBeNull();
+    const used = budget.states;
+    expect(used).toBeGreaterThanOrEqual(800);
+    expect(budget.statesLeft).toBeGreaterThan(0);
+
+    const refused = compileLinearRegexDetailed('c'.repeat(600), budget);
+    expect(refused.regex).toBeNull();
+    expect('reason' in refused && refused.reason).toContain('allowance');
+    // The refused build stopped at the allowance and kept nothing.
+    expect(budget.states).toBe(used);
+    // The first pattern that does not fit closes the allowance: even a tiny one is now
+    // refused at once, so a remainder no pattern fits cannot make later patterns cost a
+    // partial build each.
+    expect(budget.statesLeft).toBe(0);
+    const after = compileLinearRegexDetailed('^ok$', budget);
+    expect(after.regex).toBeNull();
+    expect('reason' in after && after.reason).toContain('allowance');
+    expect(budget.states).toBe(used);
+  });
+
+  it('closes only the budgets whose allowance was the tight one', () => {
+    const load = new SharedWorkBudget(MAX_SHARED_WORK, 1_000);
+    const a = load.child(MAX_SHARED_WORK, 300);
+    const b = load.child(MAX_SHARED_WORK, 800);
+    expect(compileLinearRegex('x'.repeat(100), a)).not.toBeNull();
+    // 300 - 101 = 199 left in `a`, which is tighter than the load's 899: only `a` closes.
+    expect(compileLinearRegex('y'.repeat(400), a)).toBeNull();
+    expect(a.statesLeft).toBe(0);
+    expect(load.statesLeft).toBeGreaterThan(0);
+    expect(compileLinearRegex('^ok$', b)).not.toBeNull();
+  });
+
+  it('threads the state allowance through compileRExportPatternDetailed', () => {
+    const budget = new SharedWorkBudget(MAX_SHARED_WORK, 10);
+    expect(compileRExportPatternDetailed('^[[:alpha:]]+', budget).matcher).not.toBeNull();
+    const refused = compileRExportPatternDetailed('^[[:alpha:]]+_[[:digit:]]{20}', budget);
+    expect(refused.matcher).toBeNull();
+  });
+});
+
+describe('rExportPatternMatches stops asking matchers once the budget is spent', () => {
+  const counting = (answer: boolean) => {
+    const calls = { n: 0 };
+    return {
+      calls,
+      matcher: {
+        source: 'counting',
+        test: () => {
+          calls.n++;
+          return answer;
+        },
+      },
+    };
+  };
+
+  it('asks every matcher while the budget lasts, and answers like `some`', () => {
+    const a = counting(false);
+    const b = counting(true);
+    const c = counting(true);
+    const info = {
+      exportPatterns: [a.matcher, b.matcher, c.matcher],
+      exportPatternBudget: new SharedWorkBudget(),
+    };
+    expect(rExportPatternMatches(info, 'x')).toBe(true);
+    expect([a.calls.n, b.calls.n, c.calls.n]).toEqual([1, 1, 0]);
+    expect(info.exportPatternBudget.cutShort).toBe(false);
+    expect(rExportPatternMatches({ exportPatterns: [a.matcher] }, 'x')).toBe(false);
+  });
+
+  it('calls no matcher after the budget is spent, however many patterns and names', () => {
+    const budget = new SharedWorkBudget(1_000, 10_000_000);
+    const hostileMatchers = Array.from({ length: 2_000 }, (_, i) => {
+      const inner = compileLinearRegex(hostile(i), budget) as LinearRegex;
+      const calls = { n: 0 };
+      return {
+        calls,
+        matcher: {
+          source: inner.source,
+          test: (name: string) => {
+            calls.n++;
+            return inner.test(name);
+          },
+          get exhausted() {
+            return inner.exhausted;
+          },
+        },
+      };
+    });
+    const info = {
+      exportPatterns: hostileMatchers.map((m) => m.matcher),
+      exportPatternBudget: budget,
+    };
+    for (const name of distinctNames(5_000)) expect(rExportPatternMatches(info, name)).toBe(false);
+    const calls = hostileMatchers.reduce((sum, m) => sum + m.calls.n, 0);
+    // 10 million (pattern, name) pairs without the skip; a handful before the budget ran out.
+    expect(calls).toBeLessThan(50);
+    expect(budget.cutShort).toBe(true);
+    expect(budget.spent).toBeLessThanOrEqual(1_000 + 4 * 16384);
+  });
+
+  it('is spent by a spent parent', () => {
+    const load = new SharedWorkBudget(10);
+    const pkg = load.child();
+    load.charge(10);
+    const probe = counting(true);
+    expect(
+      rExportPatternMatches({ exportPatterns: [probe.matcher], exportPatternBudget: pkg }, 'x'),
+    ).toBe(false);
+    expect(probe.calls.n).toBe(0);
+  });
+});
+
+describe('loadRPackageConfig shares one work budget across every package it discovers', () => {
+  const pool = createTempDirPool('gn-r-shared-budget-');
+
+  const writePackage = (
+    root: string,
+    dir: string,
+    name: string,
+    patterns: readonly string[],
+  ): void => {
+    const pkgRoot = path.join(root, dir);
+    fs.mkdirSync(path.join(pkgRoot, 'R'), { recursive: true });
+    fs.writeFileSync(path.join(pkgRoot, 'DESCRIPTION'), `Package: ${name}\n`);
+    fs.writeFileSync(
+      path.join(pkgRoot, 'NAMESPACE'),
+      patterns.map((p) => `exportPattern("${p}")`).join('\n') + '\n',
+    );
+  };
+
+  const nodesFor = (names: readonly string[], file: string) => {
+    const graph = createKnowledgeGraph();
+    for (const name of names) {
+      graph.addNode({
+        id: `Function:${file}:${name}`,
+        label: 'Function',
+        properties: { name, filePath: file, language: SupportedLanguages.R, isExported: true },
+      });
+    }
+    return graph;
+  };
+
+  const matchers = (config: RPackageConfig): LinearRegex[] =>
+    [...config.namespaceInfoByPackageDir.values()].flatMap(
+      (info) => info.exportPatterns as unknown as LinearRegex[],
+    );
+
+  const exportedNames = (graph: ReturnType<typeof createKnowledgeGraph>): string[] => {
+    const out: string[] = [];
+    graph.forEachNode((n) => {
+      if (n.properties.isExported === true) out.push(String(n.properties.name));
+    });
+    return out.sort();
+  };
+
+  const captured = (run: () => void): string[] => {
+    const cap = _captureLogger();
+    try {
+      run();
+      return cap.records().map((r) => String(r.msg ?? ''));
+    } finally {
+      cap.restore();
+    }
+  };
+
+  // Per-pattern budgets alone allow 200 patterns x 40M visits (~77 s); the shared budget
+  // allows ~100M in total. The bound is asserted on the work counters below, not on wall-clock
+  // time, which varies with the runner and with coverage instrumentation.
+  it('bounds a NAMESPACE with 200 distinct hostile patterns', async () => {
+    const root = pool.dir();
+    const patterns = Array.from({ length: 200 }, (_, i) => `(a?){${600 + (i % 7) * 100}}c${i}`);
+    writePackage(root, '', 'hostilepkg', patterns);
+    const names = distinctNames(2_000);
+
+    const config = await loadRPackageConfig(root);
+    const graph = nodesFor(names, 'R/a.R');
+    refineRExportStatus(graph, config);
+    const messages = captured(() => reportRExportPatternProblems(config));
+
+    const all = matchers(config);
+    const info = config.namespaceInfoByPackageDir.get('');
+    // The package's allowance of states fits only some of the 200 patterns; the others were
+    // refused (listed up to a limit, the rest counted).
+    expect(
+      all.length +
+        (info?.droppedExportPatterns?.length ?? 0) +
+        (info?.omittedDroppedExportPatterns ?? 0),
+    ).toBe(200);
+    const total = all.reduce((sum, m) => sum + m.work, 0);
+    // One package: it may spend its own share of the load's budget, no more.
+    expect(total).toBeLessThanOrEqual(MAX_PACKAGE_WORK + 4 * 16384);
+    // Nothing matched, so every name reads as unexported; every compiled pattern the
+    // package's budget cut short is reported once.
+    expect(exportedNames(graph)).toEqual([]);
+    // At most MAX_LISTED_DROPPED_PATTERNS are named; the rest are summed in one line.
+    expect(messages.filter((m) => m.includes('exceeded its work budget'))).toHaveLength(
+      Math.min(all.length, MAX_LISTED_DROPPED_PATTERNS),
+    );
+    expect(messages.some((m) => m.includes('further exportPattern() arguments exceeded'))).toBe(
+      all.length > MAX_LISTED_DROPPED_PATTERNS,
+    );
+  }, 60_000);
+
+  it('spends the same work and drops the same patterns on every load', async () => {
+    const root = pool.dir();
+    writePackage(
+      root,
+      '',
+      'detpkg',
+      Array.from({ length: 40 }, (_, i) => `(a?){800}c${i}`),
+    );
+    const run = async (): Promise<Array<[number, boolean]>> => {
+      const config = await loadRPackageConfig(root);
+      refineRExportStatus(nodesFor(distinctNames(1_000), 'R/a.R'), config);
+      return matchers(config).map((m) => [m.work, m.exhausted]);
+    };
+    expect(await run()).toEqual(await run());
+  }, 60_000);
+
+  it('spans packages: hostile patterns in several packages share the one budget', async () => {
+    const root = pool.dir();
+    for (let p = 0; p < 20; p++) {
+      writePackage(
+        root,
+        `pkgs/p${p}`,
+        `p${p}`,
+        Array.from({ length: 5 }, (_, i) => `(a?){800}c${p}x${i}`),
+      );
+    }
+    const config = await loadRPackageConfig(root);
+    const graph = createKnowledgeGraph();
+    for (let p = 0; p < 20; p++) {
+      for (const name of distinctNames(500)) {
+        graph.addNode({
+          id: `Function:pkgs/p${p}/R/a.R:${name}`,
+          label: 'Function',
+          properties: {
+            name,
+            filePath: `pkgs/p${p}/R/a.R`,
+            language: SupportedLanguages.R,
+            isExported: true,
+          },
+        });
+      }
+    }
+    refineRExportStatus(graph, config);
+    const total = matchers(config).reduce((sum, m) => sum + m.work, 0);
+    expect(matchers(config)).toHaveLength(100);
+    expect(total).toBeLessThanOrEqual(MAX_SHARED_WORK + 4 * 16384);
+    expect(matchers(config).some((m) => m.exhausted)).toBe(true);
+  }, 60_000);
+
+  it('does not penalise a monorepo of benign packages', async () => {
+    const root = pool.dir();
+    const patterns = ['^[[:alpha:]]+', '^(foo|bar)_', '\\\\.internal$'];
+    const oracle = [/^[A-Za-z]+/, /^(foo|bar)_/, /\.internal$/];
+    const expected: string[] = [];
+    const graph = createKnowledgeGraph();
+    for (let p = 0; p < 50; p++) {
+      writePackage(root, `pkgs/p${p}`, `p${p}`, patterns);
+      const names = [
+        ...Array.from({ length: 30 }, (_, i) => `fn_${p}_${i}`),
+        ...Array.from({ length: 10 }, (_, i) => `foo_${p}_${i}`),
+        ...Array.from({ length: 10 }, (_, i) => `.hidden_${p}_${i}`),
+        `thing${p}.internal`,
+        `_private_${p}`,
+      ];
+      for (const name of names) {
+        if (oracle.some((re) => re.test(name))) expected.push(name);
+        graph.addNode({
+          id: `Function:pkgs/p${p}/R/a.R:${name}`,
+          label: 'Function',
+          properties: {
+            name,
+            filePath: `pkgs/p${p}/R/a.R`,
+            language: SupportedLanguages.R,
+            isExported: true,
+          },
+        });
+      }
+    }
+    const config = await loadRPackageConfig(root);
+    refineRExportStatus(graph, config);
+
+    expect(exportedNames(graph)).toEqual(expected.sort());
+    const all = matchers(config);
+    expect(all).toHaveLength(150);
+    expect(all.some((m) => m.exhausted)).toBe(false);
+    const total = all.reduce((sum, m) => sum + m.work, 0);
+    expect(total).toBeLessThan(MAX_SHARED_WORK / 10);
+    expect(captured(() => reportRExportPatternProblems(config))).toEqual([]);
+  });
+
+  const budgetOf = (info: RNamespaceInfo | undefined) => info?.exportPatternBudget;
+
+  it('bounds a NAMESPACE of 50,000 distinct cheap patterns', async () => {
+    const root = pool.dir();
+    const patterns = Array.from({ length: 50_000 }, (_, i) => `^zq${i.toString(36)}_[a-z]+$`);
+    writePackage(root, '', 'manypkg', patterns);
+    const names = distinctNames(2_000, 30);
+
+    const config = await loadRPackageConfig(root);
+    const info = config.namespaceInfoByPackageDir.get('');
+    const graph = nodesFor(names, 'R/a.R');
+    refineRExportStatus(graph, config);
+    const messages = captured(() => reportRExportPatternProblems(config));
+
+    // What was compiled fits the package's allowance of states; the rest was refused
+    // without being compiled, listed (a few) and counted (the rest), never 50,000 warnings.
+    expect(budgetOf(info)?.states).toBeLessThanOrEqual(MAX_PACKAGE_STATES);
+    expect(info?.exportPatterns.length).toBeLessThan(50_000);
+    expect(info?.droppedExportPatterns).toHaveLength(MAX_LISTED_DROPPED_PATTERNS);
+    expect(
+      (info?.exportPatterns.length ?? 0) +
+        (info?.droppedExportPatterns?.length ?? 0) +
+        (info?.omittedDroppedExportPatterns ?? 0),
+    ).toBe(50_000);
+    expect(budgetOf(info)?.spent).toBeLessThanOrEqual(MAX_PACKAGE_WORK + 4 * 16384);
+    // Warnings are bounded too: a listed few per package plus one summary line each.
+    expect(messages.length).toBeLessThanOrEqual(2 * MAX_LISTED_DROPPED_PATTERNS + 4);
+    expect(messages.some((m) => m.includes('further exportPattern()'))).toBe(true);
+    expect(exportedNames(graph)).toEqual([]);
+  }, 60_000);
+
+  it('bounds the NFA states many packages of maximum-size patterns may keep', async () => {
+    const root = pool.dir();
+    // [a-z]{8000}Qk is about 8,000 states: 12 fill a package, ~60 the load.
+    for (let p = 0; p < 30; p++) {
+      writePackage(
+        root,
+        `pkgs/p${p}`,
+        `p${p}`,
+        Array.from({ length: 30 }, (_, i) => `[a-z]{8000}Q${p.toString(36)}${i.toString(36)}`),
+      );
+    }
+    const config = await loadRPackageConfig(root);
+    const infos = [...config.namespaceInfoByPackageDir.values()];
+    expect(infos).toHaveLength(30);
+    let kept = 0;
+    let compiled = 0;
+    for (const info of infos) {
+      expect(budgetOf(info)?.states).toBeLessThanOrEqual(MAX_PACKAGE_STATES);
+      for (const m of info.exportPatterns as unknown as LinearRegex[]) kept += m.stateCount;
+      compiled += info.exportPatterns.length;
+      // Every pattern is either compiled or dropped (and listed): none vanishes.
+      expect(info.exportPatterns.length + (info.droppedExportPatterns?.length ?? 0)).toBe(30);
+    }
+    expect(kept).toBeLessThanOrEqual(MAX_SHARED_STATES);
+    expect(kept).toBeGreaterThan(MAX_SHARED_STATES / 2);
+    expect(compiled).toBeLessThan(100);
+    expect(Math.max(...infos.map((i) => i.exportPatterns.length))).toBeLessThanOrEqual(12);
+    const reasons = infos.flatMap((i) => (i.droppedExportPatterns ?? []).map((d) => d.reason));
+    expect(reasons.length).toBeGreaterThan(0);
+    expect(reasons.every((r) => r.includes('allowance'))).toBe(true);
+  }, 60_000);
+
+  it('keeps the exports of benign packages after one hostile package', async () => {
+    const root = pool.dir();
+    // Directory order is a < b < c < d: the hostile package is processed first.
+    writePackage(
+      root,
+      'a',
+      'pa',
+      Array.from({ length: 30 }, (_, i) => `(a?){${700 + (i % 5) * 100}}c${i}`),
+    );
+    const benign = ['b', 'c', 'd'];
+    for (const dir of benign) writePackage(root, dir, `p${dir}`, ['^pub_', '^api[0-9]']);
+    const config = await loadRPackageConfig(root);
+
+    const graph = createKnowledgeGraph();
+    const add = (dir: string, name: string) =>
+      graph.addNode({
+        id: `Function:${dir}/R/x.R:${name}`,
+        label: 'Function',
+        properties: {
+          name,
+          filePath: `${dir}/R/x.R`,
+          language: SupportedLanguages.R,
+          isExported: true,
+        },
+      });
+    for (const name of distinctNames(600)) add('a', name);
+    for (const dir of benign) {
+      for (let i = 0; i < 40; i++) add(dir, `pub_${dir}${i}`);
+      for (let i = 0; i < 10; i++) add(dir, `internal_${dir}${i}`);
+    }
+    refineRExportStatus(graph, config);
+
+    const status = new Map<string, boolean>();
+    graph.forEachNode((n) =>
+      status.set(String(n.properties.name), n.properties.isExported === true),
+    );
+    // The hostile package spent its own share (30 %) and no more of the load's budget...
+    const hostileBudget = budgetOf(config.namespaceInfoByPackageDir.get('a'));
+    expect(hostileBudget?.isSpent).toBe(true);
+    expect(hostileBudget?.cutShort).toBe(true);
+    // ...so the load still has budget and the later packages are untouched.
+    for (const dir of benign) {
+      const b = budgetOf(config.namespaceInfoByPackageDir.get(dir));
+      expect(b?.isSpent).toBe(false);
+      expect(b?.cutShort).toBe(false);
+      for (let i = 0; i < 40; i++)
+        expect(status.get(`pub_${dir}${i}`), `pub_${dir}${i}`).toBe(true);
+      for (let i = 0; i < 10; i++) expect(status.get(`internal_${dir}${i}`)).toBe(false);
+    }
+    // The hostile package's own names read as unexported, and it is reported pattern by pattern.
+    for (const name of distinctNames(600)) expect(status.get(name)).toBe(false);
+    const messages = captured(() => reportRExportPatternProblems(config));
+    expect(messages).toHaveLength(30);
+    expect(messages.every((m) => m.includes('R package a:'))).toBe(true);
+  }, 60_000);
+});
diff --git a/gitnexus/test/unit/r-export-pattern.test.ts b/gitnexus/test/unit/r-export-pattern.test.ts
new file mode 100644
index 000000000..3569777db
--- /dev/null
+++ b/gitnexus/test/unit/r-export-pattern.test.ts
@@ -0,0 +1,146 @@
+import { describe, it, expect } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  compileRExportPattern,
+  unescapeRString,
+} from '../../src/core/ingestion/languages/r/export-pattern.js';
+import { loadRPackageConfig } from '../../src/core/ingestion/languages/r/package-config.js';
+import { createTempDirPool } from '../helpers/temp-dir-pool.js';
+
+// `exportPattern("...")` arguments are POSIX (TRE) regexes; JavaScript RegExp has no
+// `[:alpha:]`-style classes, so they must be translated before compiling.
+describe('compileRExportPattern', () => {
+  const matches = (pattern: string, name: string): boolean =>
+    compileRExportPattern(pattern)?.test(name) ?? false;
+
+  it('matches the RStudio default pattern against an ordinary name', () => {
+    expect(matches('^[[:alpha:]]+', 'tidy_scores')).toBe(true);
+    expect(matches('^[[:alpha:]]+', '.hidden')).toBe(false);
+  });
+
+  it.each([
+    ['[[:alpha:]]', 'q', '5'],
+    ['[[:alnum:]]', '7', '_'],
+    ['[[:digit:]]', '3', 'x'],
+    ['[[:upper:]]', 'Q', 'q'],
+    ['[[:lower:]]', 'q', 'Q'],
+    ['[[:punct:]]', '.', 'a'],
+    ['[[:space:]]', ' ', 'a'],
+  ])('translates %s', (pattern, hit, miss) => {
+    expect(matches(`^${pattern}$`, hit)).toBe(true);
+    expect(matches(`^${pattern}$`, miss)).toBe(false);
+  });
+
+  it('treats punct as ASCII punctuation including brackets, backslash, backtick and tilde', () => {
+    for (const ch of ['!', '/', ':', '@', '[', '\\', ']', '^', '_', '`', '{', '~']) {
+      expect(matches('^[[:punct:]]$', ch)).toBe(true);
+    }
+  });
+
+  it('translates a negated class', () => {
+    expect(matches('^[^[:digit:]]+$', 'abc')).toBe(true);
+    expect(matches('^[^[:digit:]]+$', 'ab1')).toBe(false);
+  });
+
+  it('combines a class with a range and literals in one bracket expression', () => {
+    expect(matches('^[[:digit:]a-c_]+$', '1a_c2')).toBe(true);
+    expect(matches('^[[:digit:]a-c_]+$', '1d')).toBe(false);
+  });
+
+  it('combines several classes in one bracket expression', () => {
+    expect(matches('^[[:upper:][:digit:]]+$', 'AB12')).toBe(true);
+    expect(matches('^[[:upper:][:digit:]]+$', 'Ab12')).toBe(false);
+  });
+
+  it('honours ^ and $ anchors around a class', () => {
+    expect(matches('^[[:alpha:]]', '9a')).toBe(false);
+    expect(matches('[[:digit:]]$', 'a9')).toBe(true);
+    expect(matches('[[:digit:]]$', '9a')).toBe(false);
+    expect(matches('[[:digit:]]', 'a9b')).toBe(true);
+  });
+
+  it('translates a class in a pattern with several bracket expressions', () => {
+    expect(matches('^[[:upper:]][a-z]+[[:digit:]]*$', 'Foo12')).toBe(true);
+    expect(matches('^[[:upper:]][a-z]+[[:digit:]]*$', 'foo12')).toBe(false);
+  });
+
+  it('leaves patterns without POSIX classes unchanged', () => {
+    expect(compileRExportPattern('^[a-z]')?.source).toBe('^[a-z]');
+    expect(compileRExportPattern('^Pattern')?.source).toBe('^Pattern');
+    expect(matches('^Pattern', 'PatternX')).toBe(true);
+    expect(matches('^Pattern', 'xPattern')).toBe(false);
+  });
+
+  it('does not treat an escaped bracket as a bracket expression', () => {
+    // `\[` is a literal bracket; the rest is an ordinary one-character class of `:alph`,
+    // so the pattern compiles (to itself) and matches `[` plus exactly one of those characters.
+    expect(compileRExportPattern('^\\[[:alpha:]$')?.source).toBe('^\\[[:alpha:]$');
+    expect(matches('^\\[[:alpha:]$', '[a')).toBe(true);
+    expect(matches('^\\[[:alpha:]$', '[:')).toBe(true);
+    expect(matches('^\\[[:alpha:]$', '[b')).toBe(false);
+    expect(matches('^\\[[:alpha:]$', '[:alpha:')).toBe(false);
+  });
+
+  it('never throws and yields null for an uncompilable pattern', () => {
+    for (const bad of ['(', '[abc', '[[:alpha:]', '[[:nosuch:]]', '*', '[[:alpha:', '\\']) {
+      expect(() => compileRExportPattern(bad)).not.toThrow();
+      expect(compileRExportPattern(bad)).toBeNull();
+    }
+  });
+});
+
+describe('loadRPackageConfig -> RNamespaceInfo.exportPatterns (POSIX classes)', () => {
+  const pool = createTempDirPool('gn-r-exp-');
+
+  const load = async (namespace: string) => {
+    const root = pool.dir();
+    fs.writeFileSync(path.join(root, 'DESCRIPTION'), 'Package: rootpkg\n');
+    fs.writeFileSync(path.join(root, 'NAMESPACE'), namespace);
+    const config = await loadRPackageConfig(root);
+    return config?.namespaceInfoByPackageDir.get('')?.exportPatterns ?? [];
+  };
+
+  it('compiles the RStudio default exportPattern so it matches tidy_scores', async () => {
+    const patterns = await load('exportPattern("^[[:alpha:]]+")\n');
+    expect(patterns).toHaveLength(1);
+    expect(patterns.some((p) => p.test('tidy_scores'))).toBe(true);
+  });
+
+  it('drops an invalid pattern without throwing and keeps the valid ones', async () => {
+    const patterns = await load('exportPattern("[[:nosuch:]]")\nexportPattern("^[[:digit:]]")\n');
+    expect(patterns).toHaveLength(1);
+    expect(patterns[0].test('1a')).toBe(true);
+  });
+
+  it('keeps a plain pattern working', async () => {
+    const patterns = await load('exportPattern("^Pattern")\n');
+    expect(patterns.some((p) => p.test('PatternX'))).toBe(true);
+    expect(patterns.some((p) => p.test('xPattern'))).toBe(false);
+  });
+});
+
+describe('unescapeRString', () => {
+  it('returns text without a backslash unchanged', () => {
+    expect(unescapeRString('^[[:alpha:]]+')).toBe('^[[:alpha:]]+');
+  });
+
+  it('handles the common single-character escapes', () => {
+    expect(unescapeRString('a\\\\b')).toBe('a\\b');
+    expect(unescapeRString('\\"\\\'\\`')).toBe('"\'`');
+    expect(unescapeRString('\\n\\t\\r\\a\\b\\f\\v')).toBe('\n\t\r\x07\b\f\v');
+  });
+
+  it('handles hex and unicode escapes, with and without braces', () => {
+    expect(unescapeRString('\\x41\\u0042\\u{43}\\U00000044\\U{45}')).toBe('ABCDE');
+    expect(unescapeRString('\\U{1F600}')).toBe('\u{1F600}');
+  });
+
+  it('keeps an unknown or malformed escape verbatim and never throws', () => {
+    expect(unescapeRString('\\.')).toBe('\\.');
+    expect(unescapeRString('\\xZZ')).toBe('\\xZZ');
+    expect(unescapeRString('\\u{110000}')).toBe('\\u{110000}');
+    expect(unescapeRString('\\u{41')).toBe('\\u{41');
+    expect(unescapeRString('trailing\\')).toBe('trailing\\');
+  });
+});
diff --git a/gitnexus/test/unit/r-export-status-layout.test.ts b/gitnexus/test/unit/r-export-status-layout.test.ts
new file mode 100644
index 000000000..47536bce4
--- /dev/null
+++ b/gitnexus/test/unit/r-export-status-layout.test.ts
@@ -0,0 +1,135 @@
+import { describe, it, expect } from 'vitest';
+import { createKnowledgeGraph } from '../../src/core/graph/graph.js';
+import { refineRExportStatus } from '../../src/core/ingestion/languages/r/post-parse.js';
+import type {
+  RNamespaceInfo,
+  RPackageConfig,
+} from '../../src/core/ingestion/languages/r/package-config.js';
+import { SupportedLanguages } from 'gitnexus-shared';
+
+// NAMESPACE export refinement is derived from the discovered package directory: it applies to
+// `<packageDir>/R/` only (R loads nothing else into a package namespace), and the longest
+// package directory containing a file owns it, whether or not that package has a NAMESPACE.
+const info = (over: Partial<RNamespaceInfo> = {}): RNamespaceInfo => ({
+  hasNamespaceFile: true,
+  namedExports: new Set(),
+  exportPatterns: [],
+  importFrom: [],
+  ...over,
+});
+
+const run = (
+  config: RPackageConfig | null,
+  defs: { name: string; filePath: string }[],
+): Map<string, unknown> => {
+  const graph = createKnowledgeGraph();
+  for (const d of defs) {
+    graph.addNode({
+      id: `Function:${d.filePath}:${d.name}`,
+      label: 'Function',
+      properties: {
+        name: d.name,
+        filePath: d.filePath,
+        language: SupportedLanguages.R,
+        isExported: true,
+      },
+    });
+  }
+  refineRExportStatus(graph, config);
+  const out = new Map<string, unknown>();
+  graph.forEachNode((n) =>
+    out.set(`${n.properties.filePath}:${n.properties.name}`, n.properties.isExported),
+  );
+  return out;
+};
+
+const NON_R_DIRS = ['tests/testthat', 'vignettes', 'inst/scripts', 'data-raw', 'scripts', 'demo'];
+
+describe.each([
+  { label: 'root-level package', dir: '', prefix: '' },
+  { label: 'nested package', dir: 'pkgs/foo', prefix: 'pkgs/foo/' },
+])('refineRExportStatus: $label', ({ dir, prefix }) => {
+  const config = (): RPackageConfig => ({
+    packages: new Map([['foo', dir]]),
+    namespaceInfoByPackageDir: new Map([[dir, info({ namedExports: new Set(['pub']) })]]),
+  });
+
+  it('flips only unexported R/ symbols; files outside R/ keep their default', () => {
+    const defs = [
+      { name: 'pub', filePath: `${prefix}R/a.R` },
+      { name: 'hidden', filePath: `${prefix}R/a.R` },
+      ...NON_R_DIRS.map((d) => ({ name: 'helper', filePath: `${prefix}${d}/x.R` })),
+    ];
+    const out = run(config(), defs);
+    expect(out.get(`${prefix}R/a.R:pub`)).toBe(true);
+    expect(out.get(`${prefix}R/a.R:hidden`)).toBe(false);
+    for (const d of NON_R_DIRS) expect(out.get(`${prefix}${d}/x.R:helper`)).toBe(true);
+  });
+
+  it('treats backslash-separated file paths like slash-separated ones', () => {
+    const win = (p: string): string => p.replace(/\//g, '\\');
+    const out = run(config(), [
+      { name: 'hidden', filePath: win(`${prefix}R/a.R`) },
+      { name: 'helper', filePath: win(`${prefix}tests/testthat/x.R`) },
+    ]);
+    expect(out.get(win(`${prefix}R/a.R`) + ':hidden')).toBe(false);
+    expect(out.get(win(`${prefix}tests/testthat/x.R`) + ':helper')).toBe(true);
+  });
+});
+
+// Only a nested package has a directory name for a sibling to share, so this is not part of the
+// root-level/nested table above (a skipped table row would count as an unexecuted test in CI).
+describe('refineRExportStatus: sibling directory sharing the package directory name', () => {
+  it('is not taken as inside the package', () => {
+    const dir = 'pkgs/foo';
+    const config: RPackageConfig = {
+      packages: new Map([['foo', dir]]),
+      namespaceInfoByPackageDir: new Map([[dir, info({ namedExports: new Set(['pub']) })]]),
+    };
+    const out = run(config, [{ name: 'hidden', filePath: `${dir}-extra/R/a.R` }]);
+    expect(out.get(`${dir}-extra/R/a.R:hidden`)).toBe(true);
+  });
+});
+
+describe('refineRExportStatus: nested packages', () => {
+  it('a nested package without NAMESPACE does not inherit the enclosing package NAMESPACE', () => {
+    const config: RPackageConfig = {
+      packages: new Map([
+        ['outer', ''],
+        ['inner', 'pkgs/inner'],
+      ]),
+      namespaceInfoByPackageDir: new Map([['', info({ namedExports: new Set(['outer_pub']) })]]),
+    };
+    const out = run(config, [
+      { name: 'outer_pub', filePath: 'R/o.R' },
+      { name: 'outer_hidden', filePath: 'R/o.R' },
+      { name: 'inner_fn', filePath: 'pkgs/inner/R/i.R' },
+      { name: 'inner_test_helper', filePath: 'pkgs/inner/tests/testthat/t.R' },
+    ]);
+    expect(out.get('R/o.R:outer_pub')).toBe(true);
+    expect(out.get('R/o.R:outer_hidden')).toBe(false);
+    expect(out.get('pkgs/inner/R/i.R:inner_fn')).toBe(true);
+    expect(out.get('pkgs/inner/tests/testthat/t.R:inner_test_helper')).toBe(true);
+  });
+
+  it('honours each package NAMESPACE, deepest package first', () => {
+    const config: RPackageConfig = {
+      packages: new Map([
+        ['outer', ''],
+        ['inner', 'pkgs/inner'],
+      ]),
+      namespaceInfoByPackageDir: new Map([
+        ['', info({ namedExports: new Set(['shared']) })],
+        ['pkgs/inner', info({ namedExports: new Set(['inner_pub']) })],
+      ]),
+    };
+    const out = run(config, [
+      { name: 'shared', filePath: 'R/o.R' },
+      { name: 'shared', filePath: 'pkgs/inner/R/i.R' },
+      { name: 'inner_pub', filePath: 'pkgs/inner/R/i.R' },
+    ]);
+    expect(out.get('R/o.R:shared')).toBe(true);
+    expect(out.get('pkgs/inner/R/i.R:shared')).toBe(false);
+    expect(out.get('pkgs/inner/R/i.R:inner_pub')).toBe(true);
+  });
+});
diff --git a/gitnexus/test/unit/r-export-status-root.test.ts b/gitnexus/test/unit/r-export-status-root.test.ts
new file mode 100644
index 000000000..fe3b9f14c
--- /dev/null
+++ b/gitnexus/test/unit/r-export-status-root.test.ts
@@ -0,0 +1,117 @@
+import { describe, it, expect } from 'vitest';
+import { createKnowledgeGraph } from '../../src/core/graph/graph.js';
+import { refineRExportStatus } from '../../src/core/ingestion/languages/r/post-parse.js';
+import type {
+  RNamespaceInfo,
+  RPackageConfig,
+} from '../../src/core/ingestion/languages/r/package-config.js';
+import { SupportedLanguages } from 'gitnexus-shared';
+
+// Regression tests: refineRExportStatus must treat the empty
+// package dir ('' = DESCRIPTION/NAMESPACE at the repo root) as containing every path.
+const info = (over: Partial<RNamespaceInfo> = {}): RNamespaceInfo => ({
+  hasNamespaceFile: true,
+  namedExports: new Set(),
+  exportPatterns: [],
+  importFrom: [],
+  ...over,
+});
+
+const configFor = (entries: Record<string, RNamespaceInfo>): RPackageConfig => ({
+  packages: new Map(Object.keys(entries).map((dir, i) => [`pkg${i}`, dir])),
+  namespaceInfoByPackageDir: new Map(Object.entries(entries)),
+});
+
+const run = (
+  config: RPackageConfig | null,
+  defs: { name: string; filePath: string }[],
+): Map<string, unknown> => {
+  const graph = createKnowledgeGraph();
+  for (const d of defs) {
+    graph.addNode({
+      id: `Function:${d.filePath}:${d.name}`,
+      label: 'Function',
+      properties: {
+        name: d.name,
+        filePath: d.filePath,
+        language: SupportedLanguages.R,
+        isExported: true,
+      },
+    });
+  }
+  refineRExportStatus(graph, config);
+  const out = new Map<string, unknown>();
+  graph.forEachNode((n) =>
+    out.set(`${n.properties.filePath}:${n.properties.name}`, n.properties.isExported),
+  );
+  return out;
+};
+
+describe('refineRExportStatus with a root-level package (pkgDir === "")', () => {
+  it('keeps explicit exports public and flips the rest to not exported', () => {
+    const out = run(configFor({ '': info({ namedExports: new Set(['pub']) }) }), [
+      { name: 'pub', filePath: 'R/a.R' },
+      { name: 'helper', filePath: 'R/a.R' },
+    ]);
+    expect(out.get('R/a.R:pub')).toBe(true);
+    expect(out.get('R/a.R:helper')).toBe(false);
+  });
+
+  it('honours exportPattern', () => {
+    const out = run(configFor({ '': info({ exportPatterns: [/^Pat/] }) }), [
+      { name: 'PatOne', filePath: 'R/a.R' },
+      { name: 'other', filePath: 'R/a.R' },
+    ]);
+    expect(out.get('R/a.R:PatOne')).toBe(true);
+    expect(out.get('R/a.R:other')).toBe(false);
+  });
+
+  it('treats S3method-derived names (in namedExports) as exported', () => {
+    const out = run(configFor({ '': info({ namedExports: new Set(['print.Foo']) }) }), [
+      { name: 'print.Foo', filePath: 'R/s3.R' },
+    ]);
+    expect(out.get('R/s3.R:print.Foo')).toBe(true);
+  });
+
+  it('leaves everything public when the root package has no NAMESPACE', () => {
+    const out = run(configFor({ '': info({ hasNamespaceFile: false }) }), [
+      { name: 'helper', filePath: 'R/a.R' },
+    ]);
+    expect(out.get('R/a.R:helper')).toBe(true);
+  });
+
+  it('normalises backslash paths', () => {
+    const out = run(configFor({ '': info() }), [{ name: 'helper', filePath: 'R\\a.R' }]);
+    expect(out.get('R\\a.R:helper')).toBe(false);
+  });
+});
+
+describe('refineRExportStatus with a nested package (unchanged)', () => {
+  it('applies the nested package NAMESPACE only to files under that dir', () => {
+    const out = run(configFor({ pkg: info({ namedExports: new Set(['pub']) }) }), [
+      { name: 'pub', filePath: 'pkg/R/a.R' },
+      { name: 'helper', filePath: 'pkg/R/a.R' },
+      { name: 'outside', filePath: 'scripts/run.R' },
+      { name: 'prefixed', filePath: 'pkgextra/R/a.R' },
+    ]);
+    expect(out.get('pkg/R/a.R:pub')).toBe(true);
+    expect(out.get('pkg/R/a.R:helper')).toBe(false);
+    expect(out.get('scripts/run.R:outside')).toBe(true);
+    expect(out.get('pkgextra/R/a.R:prefixed')).toBe(true);
+  });
+
+  it('lets the deepest package win when a root package also exists', () => {
+    const out = run(
+      configFor({
+        '': info({ namedExports: new Set() }),
+        sub: info({ namedExports: new Set(['inSub']) }),
+      }),
+      [
+        { name: 'inSub', filePath: 'sub/R/a.R' },
+        { name: 'inRoot', filePath: 'R/a.R' },
+      ],
+    );
+    expect(out.get('sub/R/a.R:inSub')).toBe(true);
+    expect(out.get('R/a.R:inRoot')).toBe(false);
+  });
+});
diff --git a/gitnexus/test/unit/r-field-extractor-class-owner.test.ts b/gitnexus/test/unit/r-field-extractor-class-owner.test.ts
new file mode 100644
index 000000000..f703ae2ed
--- /dev/null
+++ b/gitnexus/test/unit/r-field-extractor-class-owner.test.ts
@@ -0,0 +1,122 @@
+/**
+ * The S4 / RefClass field extractor must attach slots to the class the call defines,
+ * which is the argument that takes the `Class` formal (by name, else the first
+ * unnamed one), not the first string-valued argument. `setClass(contains = "Base",
+ * Class = "A", representation = ...)` defines `A`; `Base` is only its parent.
+ *
+ * Both owner paths are covered: `RFieldExtractor.extract` (the field metadata) and
+ * `getRTopLevelPropertyOwnerName` (the `ownerNameHint` that ties each slot Property
+ * to its class), since they must agree.
+ */
+import { describe, expect, it } from 'vitest';
+import Parser from 'tree-sitter';
+import R from '@eagleoutice/tree-sitter-r';
+import { SupportedLanguages } from 'gitnexus-shared';
+import {
+  RFieldExtractor,
+  getRTopLevelPropertyOwnerName,
+} from '../../src/core/ingestion/field-extractors/r.js';
+import type { FieldExtractorContext } from '../../src/core/ingestion/field-types.js';
+
+const parser = new Parser();
+parser.setLanguage(R as Parameters<Parser['setLanguage']>[0]);
+const extractor = new RFieldExtractor();
+const context = {
+  filePath: 'classes.R',
+  language: SupportedLanguages.R,
+} as unknown as FieldExtractorContext;
+
+/** The first `setClass` / `setRefClass` call in `source`. */
+function classCall(source: string): Parser.SyntaxNode {
+  const tree = parser.parse(source, undefined, { bufferSize: 1 << 24 });
+  const calls = tree.rootNode
+    .descendantsOfType('call')
+    .filter((c) =>
+      ['setClass', 'setRefClass'].includes(c.childForFieldName('function')?.text ?? ''),
+    );
+  expect(calls).toHaveLength(1);
+  return calls[0];
+}
+
+function extracted(source: string) {
+  const result = extractor.extract(classCall(source), context);
+  return result === null
+    ? null
+    : { owner: result.ownerFqn, fields: result.fields.map((f) => f.name) };
+}
+
+/** The slot Property's `ownerNameHint` target: the owner name of the first slot entry. */
+function propertyOwner(source: string): string | null {
+  const call = classCall(source);
+  const slot = call
+    .descendantsOfType('argument')
+    .find((a) => a.childForFieldName('name')?.text === 'x');
+  expect(slot).toBeDefined();
+  return getRTopLevelPropertyOwnerName(slot as Parser.SyntaxNode);
+}
+
+const SLOTS = 'representation = representation(x = "numeric")';
+
+describe('R field extractor: slots attach to the Class argument', () => {
+  it('uses the positional first argument (unchanged behaviour)', () => {
+    const source = `setClass("A", ${SLOTS})`;
+    expect(extracted(source)).toEqual({ owner: 'A', fields: ['x'] });
+    expect(propertyOwner(source)).toBe('A');
+  });
+
+  it('still reads slots= and setRefClass(fields=) for a positional class', () => {
+    expect(extracted('setClass("A", slots = list(x = "numeric"))')).toEqual({
+      owner: 'A',
+      fields: ['x'],
+    });
+    expect(extracted('setRefClass("R", fields = list(x = "numeric"))')).toEqual({
+      owner: 'R',
+      fields: ['x'],
+    });
+  });
+
+  it('does not attach slots to a contains= string that precedes Class= (the reported defect)', () => {
+    const source = `setClass(contains = "Base", Class = "A", ${SLOTS})`;
+    expect(extracted(source)).toEqual({ owner: 'A', fields: ['x'] });
+    expect(extracted(source)?.owner).not.toBe('Base');
+    expect(propertyOwner(source)).toBe('A');
+  });
+
+  it('finds Class= when it follows the representation argument', () => {
+    const source = `setClass(${SLOTS}, Class = "A")`;
+    expect(extracted(source)).toEqual({ owner: 'A', fields: ['x'] });
+    expect(propertyOwner(source)).toBe('A');
+  });
+
+  it('finds Class= after a contains= string and the representation argument', () => {
+    const source = `setClass(contains = "Base", ${SLOTS}, Class = "A")`;
+    expect(extracted(source)?.owner).toBe('A');
+    expect(propertyOwner(source)).toBe('A');
+  });
+
+  it('takes the first unnamed argument when contains= precedes it', () => {
+    const source = `setClass(contains = "Base", "A", ${SLOTS})`;
+    expect(extracted(source)).toEqual({ owner: 'A', fields: ['x'] });
+    expect(propertyOwner(source)).toBe('A');
+  });
+
+  it('accepts the Class formal spelled in backticks or quotes', () => {
+    for (const formal of ['`Class`', '"Class"']) {
+      const source = `setClass(contains = "Base", ${formal} = "A", ${SLOTS})`;
+      expect(extracted(source)).toEqual({ owner: 'A', fields: ['x'] });
+      expect(propertyOwner(source)).toBe('A');
+    }
+  });
+
+  it('attaches setRefClass fields to the Class argument as well', () => {
+    const source = 'setRefClass(contains = "Base", Class = "R", fields = list(x = "numeric"))';
+    expect(extracted(source)).toEqual({ owner: 'R', fields: ['x'] });
+    expect(propertyOwner(source)).toBe('R');
+  });
+
+  it('names no owner (so no slots) when the Class argument is not a string', () => {
+    const source = `setClass(contains = "Base", Class = cls, ${SLOTS})`;
+    expect(extracted(source)).toBeNull();
+    expect(propertyOwner(source)).toBeNull();
+  });
+});
diff --git a/gitnexus/test/unit/r-grammar-manifest-contract.test.ts b/gitnexus/test/unit/r-grammar-manifest-contract.test.ts
new file mode 100644
index 000000000..c06bef95d
--- /dev/null
+++ b/gitnexus/test/unit/r-grammar-manifest-contract.test.ts
@@ -0,0 +1,47 @@
+/**
+ * Read-only contract over the REAL gitnexus/package.json for the R grammar. The
+ * prepare-tree-sitter-bundle unit tests use a synthetic fixture, so nothing else in the
+ * unit tier notices if the shipped manifest stops bundling or exact-pinning the R grammar,
+ * or if its version drifts from the audited peer table that the pack step validates.
+ * (The packaged-install smoke in CI is the end-to-end check; this fails earlier.)
+ */
+import { describe, expect, it } from 'vitest';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
+const manifest = JSON.parse(readFileSync(path.join(root, 'package.json'), 'utf8')) as {
+  dependencies: Record<string, string>;
+  bundleDependencies: string[];
+};
+const script = readFileSync(path.join(root, 'scripts/prepare-tree-sitter-bundle.cjs'), 'utf8');
+
+const R_GRAMMAR = '@eagleoutice/tree-sitter-r';
+const EXACT_VERSION = /^\d+\.\d+\.\d+$/;
+
+/** The keys of the script's AUDITED_PEERS map literal (`['name@version', 'range']`). */
+function auditedPeerKeys(): string[] {
+  const block = /const AUDITED_PEERS = new Map\(\[([\s\S]*?)\]\);/.exec(script)?.[1] ?? '';
+  return [...block.matchAll(/\[\s*'([^']+)'\s*,/g)].map((m) => m[1]);
+}
+
+describe('R grammar entry in the shipped package.json', () => {
+  it('is a runtime dependency pinned to an exact version', () => {
+    expect(manifest.dependencies[R_GRAMMAR]).toMatch(EXACT_VERSION);
+  });
+
+  it('is bundled, so consumers do not depend on npm overrides', () => {
+    expect(manifest.bundleDependencies).toContain(R_GRAMMAR);
+  });
+
+  it('matches a version in the AUDITED_PEERS table of the pack step', () => {
+    const keys = auditedPeerKeys();
+    expect(keys.length).toBeGreaterThan(1); // the parse of the table itself works
+    expect(keys).toContain(`${R_GRAMMAR}@${manifest.dependencies[R_GRAMMAR]}`);
+  });
+
+  it('is the only audited version of the R grammar', () => {
+    expect(auditedPeerKeys().filter((k) => k.startsWith(`${R_GRAMMAR}@`))).toHaveLength(1);
+  });
+});
diff --git a/gitnexus/test/unit/r-import-root-package.test.ts b/gitnexus/test/unit/r-import-root-package.test.ts
new file mode 100644
index 000000000..29de373da
--- /dev/null
+++ b/gitnexus/test/unit/r-import-root-package.test.ts
@@ -0,0 +1,32 @@
+import { describe, it, expect } from 'vitest';
+import { resolveRImportTarget } from '../../src/core/ingestion/import-resolvers/r.js';
+import type { RPackageConfig } from '../../src/core/ingestion/languages/r/package-config.js';
+
+// `library("pkg")` resolves to the `R/` files of the local package, whatever directory the
+// package lives in; a root-level package has the directory '' and must not be skipped for it.
+const wildcard = { parsedImport: { kind: 'wildcard' } } as never;
+
+const config = (dir: string): RPackageConfig => ({
+  packages: new Map([['mypkg', dir]]),
+  namespaceInfoByPackageDir: new Map(),
+});
+
+const resolve = (dir: string, files: string[]): readonly string[] | string | null =>
+  resolveRImportTarget('mypkg', 'scripts/use.R', new Set(files), config(dir), wildcard);
+
+describe('resolveRImportTarget: library() of a local package', () => {
+  it('resolves a root-level package to its R/ files only', () => {
+    const out = resolve('', ['R/a.R', 'R/b.r', 'scripts/use.R', 'tests/testthat/t.R', 'inst/x.R']);
+    expect([...(out as string[])].sort()).toEqual(['R/a.R', 'R/b.r']);
+  });
+
+  it('resolves a nested package to its R/ files only', () => {
+    const out = resolve('pkgs/mypkg', [
+      'pkgs/mypkg/R/a.R',
+      'pkgs/mypkg/tests/t.R',
+      'R/other.R',
+      'scripts/use.R',
+    ]);
+    expect(out).toEqual(['pkgs/mypkg/R/a.R']);
+  });
+});
diff --git a/gitnexus/test/unit/r-language-classification.test.ts b/gitnexus/test/unit/r-language-classification.test.ts
new file mode 100644
index 000000000..e4edf2ff9
--- /dev/null
+++ b/gitnexus/test/unit/r-language-classification.test.ts
@@ -0,0 +1,16 @@
+import { describe, expect, it } from 'vitest';
+import { LanguageClassifications, isProductionLanguage } from 'gitnexus-shared';
+import { SupportedLanguages } from '../../src/config/supported-languages.js';
+
+// docs/languages/r-provider.md describes R as an experimental provider. The classification
+// map is type-forced to contain R but nothing else asserts its value, so a silent
+// promotion to 'production' (a governance change) would otherwise go unnoticed.
+describe('R language classification', () => {
+  it('classifies R as experimental', () => {
+    expect(LanguageClassifications[SupportedLanguages.R]).toBe('experimental');
+  });
+
+  it('does not treat R as a production language', () => {
+    expect(isProductionLanguage(SupportedLanguages.R)).toBe(false);
+  });
+});
diff --git a/gitnexus/test/unit/r-method-extractor-owner.test.ts b/gitnexus/test/unit/r-method-extractor-owner.test.ts
new file mode 100644
index 000000000..a9bf56220
--- /dev/null
+++ b/gitnexus/test/unit/r-method-extractor-owner.test.ts
@@ -0,0 +1,99 @@
+/**
+ * The R method extractor must name the owner of a method from the argument R would
+ * match to the formal, not from "the first" or "the second" string-valued argument.
+ *
+ * - `setRefClass`: the class is the argument that takes the `Class` formal (by name,
+ *   else the first unnamed one), so `contains = "Base"` ahead of `Class = "Acc"`
+ *   never names the owner.
+ * - `setMethod(f, signature, definition, where, valueClass, sealed)`: the owner is
+ *   the `signature` argument. R matches named arguments first and fills the formals
+ *   that remain from the unnamed ones, in order, so a named `where =` or `valueClass =`
+ *   string must not be counted as the second string.
+ */
+import { describe, expect, it } from 'vitest';
+import Parser from 'tree-sitter';
+import R from '@eagleoutice/tree-sitter-r';
+import { SupportedLanguages } from 'gitnexus-shared';
+import {
+  getRTopLevelMethodOwnerName,
+  rMethodExtractor,
+} from '../../src/core/ingestion/method-extractors/r.js';
+import type { MethodExtractorContext } from '../../src/core/ingestion/method-types.js';
+
+const parser = new Parser();
+parser.setLanguage(R as Parameters<Parser['setLanguage']>[0]);
+const context = {
+  filePath: 'classes.R',
+  language: SupportedLanguages.R,
+} as unknown as MethodExtractorContext;
+
+/** The only call to `callee` in `source`. */
+function callTo(source: string, callee: string): Parser.SyntaxNode {
+  const tree = parser.parse(source, undefined, { bufferSize: 1 << 24 });
+  const calls = tree.rootNode
+    .descendantsOfType('call')
+    .filter((c) => c.childForFieldName('function')?.text === callee);
+  expect(calls).toHaveLength(1);
+  return calls[0];
+}
+
+const methodOwner = (source: string) =>
+  getRTopLevelMethodOwnerName(callTo(source, 'setMethod') as never);
+
+const refClassOwner = (source: string) =>
+  rMethodExtractor.extract(callTo(source, 'setRefClass') as never, context)?.ownerName ?? null;
+
+describe('R method extractor: setMethod owner is the signature argument', () => {
+  it.each([
+    ['positional', 'setMethod("show", "Foo", function(object) 1)'],
+    ['all named', 'setMethod(f = "show", signature = "Foo", definition = function(object) 1)'],
+    ['signature named first', 'setMethod(signature = "Foo", f = "show", function(object) 1)'],
+    ['signature named, f positional', 'setMethod("show", signature = "Foo", function(object) 1)'],
+    ['signature named before f', 'setMethod(signature = "Foo", "show", function(object) 1)'],
+    ['f named, signature positional', 'setMethod(f = "show", "Foo", function(object) 1)'],
+    ['f named after signature', 'setMethod("Foo", f = "show", function(object) 1)'],
+    ['definition named', 'setMethod("show", "Foo", definition = function(object) 1)'],
+    ['a named where= string between', 'setMethod("show", where = "pkg", "Foo", function(o) 1)'],
+    [
+      'a named valueClass= before signature=',
+      'setMethod("show", valueClass = "x", signature = "Foo")',
+    ],
+    [
+      'a named sealed= before the positional',
+      'setMethod(sealed = "yes", "show", "Foo", function(o) 1)',
+    ],
+    ['backticked formal', 'setMethod("show", `signature` = "Foo", function(object) 1)'],
+  ])('%s', (_label, source) => {
+    expect(methodOwner(source)).toBe('Foo');
+  });
+
+  it('names no owner when the signature is not a string', () => {
+    expect(methodOwner('setMethod("show", c("A", "B"), function(object) 1)')).toBeNull();
+    expect(methodOwner('setMethod("show", signature("A"), function(object) 1)')).toBeNull();
+    expect(methodOwner('setMethod("show", where = "pkg")')).toBeNull();
+  });
+});
+
+describe('R method extractor: setRefClass owner is the Class argument', () => {
+  const METHODS = 'methods = list(m = function() 1)';
+
+  it('uses the first unnamed argument (unchanged behaviour)', () => {
+    expect(refClassOwner(`setRefClass("Acc", ${METHODS})`)).toBe('Acc');
+  });
+
+  it('does not name a contains= string that precedes Class= (the defect)', () => {
+    expect(refClassOwner(`setRefClass(contains = "Base", Class = "Acc", ${METHODS})`)).toBe('Acc');
+  });
+
+  it('takes the first unnamed argument when contains= precedes it', () => {
+    expect(refClassOwner(`setRefClass(contains = "Base", "Acc", ${METHODS})`)).toBe('Acc');
+  });
+
+  it('accepts the Class formal in backticks and finds it after the methods', () => {
+    expect(refClassOwner(`setRefClass(${METHODS}, \`Class\` = "Acc")`)).toBe('Acc');
+  });
+
+  it('names no owner when the Class argument is not a string', () => {
+    expect(refClassOwner(`setRefClass(contains = "Base", Class = cls, ${METHODS})`)).toBeNull();
+  });
+});
diff --git a/gitnexus/test/unit/r-namespace-exports.test.ts b/gitnexus/test/unit/r-namespace-exports.test.ts
new file mode 100644
index 000000000..ba195a9fe
--- /dev/null
+++ b/gitnexus/test/unit/r-namespace-exports.test.ts
@@ -0,0 +1,297 @@
+import { describe, it, expect } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+import { loadRPackageConfig } from '../../src/core/ingestion/languages/r/package-config.js';
+import { createTempDirPool } from '../helpers/temp-dir-pool.js';
+
+// Regression tests: export()/exportClasses()/exportMethods()/S3method()/
+// exportPattern() must be read from the whole NAMESPACE text (wrapped, quoted,
+// backticked, commented, CRLF), not line by line. Everything goes through the
+// public loader, `loadRPackageConfig`, with synthetic NAMESPACE files.
+describe('loadRPackageConfig -> RNamespaceInfo exports', () => {
+  const pool = createTempDirPool('gn-r-nsx-');
+
+  const load = async (namespace: string) => {
+    const root = pool.dir();
+    fs.writeFileSync(path.join(root, 'DESCRIPTION'), 'Package: rootpkg\n');
+    fs.writeFileSync(path.join(root, 'NAMESPACE'), namespace);
+    const config = await loadRPackageConfig(root);
+    const info = config?.namespaceInfoByPackageDir.get('');
+    return {
+      names: [...(info?.namedExports ?? [])].sort(),
+      patterns: info?.exportPatterns ?? [],
+    };
+  };
+
+  describe('single-line forms (unchanged)', () => {
+    it('reads export, exportClasses, exportMethods, S3method and exportPattern', async () => {
+      const { names, patterns } = await load(
+        [
+          'export(a, b)',
+          'exportClasses(K)',
+          'exportMethods(show)',
+          'S3method(print, foo)',
+          'exportPattern("^x")',
+        ].join('\n') + '\n',
+      );
+      expect(names).toEqual(['K', 'a', 'b', 'print.foo', 'show']);
+      expect(patterns.map((p) => p.source)).toEqual(['^x']);
+    });
+
+    it('strips quotes from names and ignores full-line comments and blank lines', async () => {
+      const { names } = await load('# export(gone)\n\nexport("q1", \'q2\', bare)\n');
+      expect(names).toEqual(['bare', 'q1', 'q2']);
+    });
+
+    it('does not export from a conditional directive', async () => {
+      const { names } = await load('if (cond) export(hidden)\nexport(shown)\n');
+      expect(names).toEqual(['shown']);
+    });
+  });
+
+  describe('wrapped directives', () => {
+    it('reads export() wrapped over several lines', async () => {
+      const { names } = await load('export(alpha,\n  beta,\n\n  gamma\n)\n');
+      expect(names).toEqual(['alpha', 'beta', 'gamma']);
+    });
+
+    it('reads a directive with the head and opening paren on separate lines', async () => {
+      const { names } = await load('export\n(\n  alpha\n)\n');
+      expect(names).toEqual(['alpha']);
+    });
+
+    it('reads exportClasses/exportMethods wrapped over several lines', async () => {
+      const { names } = await load('exportClasses(\n  K1,\n  K2)\nexportMethods(m1,\n  m2)\n');
+      expect(names).toEqual(['K1', 'K2', 'm1', 'm2']);
+    });
+
+    it('reads a wrapped S3method()', async () => {
+      const { names } = await load('S3method(\n  print,\n  foo\n)\nS3method(summary,\n  bar)\n');
+      expect(names).toEqual(['print.foo', 'summary.bar']);
+    });
+
+    it('reads a wrapped exportPattern()', async () => {
+      const { patterns } = await load('exportPattern(\n  "^pub_"\n)\n');
+      expect(patterns.map((p) => p.source)).toEqual(['^pub_']);
+    });
+
+    it('tolerates a trailing comma inside a wrapped export()', async () => {
+      const { names } = await load('export(a,\n  b,\n  )\n');
+      expect(names).toEqual(['a', 'b']);
+    });
+  });
+
+  describe('quoting', () => {
+    it('reads double-, single- and backtick-quoted export names', async () => {
+      const { names } = await load('export("dq", \'sq\', `bt`, `%+%`, .dot)\n');
+      expect(names).toEqual(['%+%', '.dot', 'bt', 'dq', 'sq']);
+    });
+
+    it('keeps a comma, paren or # inside a quoted name', async () => {
+      const { names } = await load('export("a,b", `c(d)`, "e#f")\n');
+      expect(names).toEqual(['a,b', 'c(d)', 'e#f']);
+    });
+
+    it('reads quoted S3method arguments, including operator generics', async () => {
+      const { names } = await load('S3method("[", foo)\nS3method(`$`, "bar")\n');
+      expect(names).toEqual(['$.bar', '[.foo']);
+    });
+
+    // R registers the third argument (not `generic.class`) as the method for the class.
+    it('registers the optional third S3method() argument instead of generic.class', async () => {
+      const { names } = await load('S3method(print, foo, print_foo_impl)\n');
+      expect(names).toEqual(['print_foo_impl']);
+    });
+
+    it('reads a quoted, backticked or wrapped third S3method() argument', async () => {
+      const { names } = await load(
+        'S3method(print, a, "print a")\nS3method(print, b, `print_b`)\nS3method(\n  print,\n  c,\n  print_c # impl\n)\n',
+      );
+      expect(names).toEqual(['print a', 'print_b', 'print_c']);
+    });
+
+    it('falls back to generic.class when the third S3method() argument is empty or not a name', async () => {
+      const { names } = await load(
+        'S3method(print, a, )\nS3method(print, b, f(x))\nS3method(print, c, m = impl)\n',
+      );
+      expect(names).toEqual(['print.a', 'print.b', 'print.c']);
+    });
+
+    it('keeps a two-argument S3method() as generic.class next to a three-argument one', async () => {
+      const { names } = await load('S3method(print, foo)\nS3method(summary, foo, sum_foo)\n');
+      expect(names).toEqual(['print.foo', 'sum_foo']);
+    });
+  });
+
+  describe('comments and line endings', () => {
+    it('ignores a trailing comment after a directive', async () => {
+      const { names } = await load('export(a) # export(hidden)\nexport(b)\n');
+      expect(names).toEqual(['a', 'b']);
+    });
+
+    it('ignores comments inside a wrapped directive', async () => {
+      const { names } = await load('export(a, # first\n  # export(hidden)\n  b)\n');
+      expect(names).toEqual(['a', 'b']);
+    });
+
+    it('is CRLF-safe for wrapped and single-line directives', async () => {
+      const { names, patterns } = await load(
+        'export(a,\r\n  b)\r\nS3method(print,\r\n  foo)\r\nexportPattern("^z")\r\nexportClasses(K)\r\n',
+      );
+      expect(names).toEqual(['K', 'a', 'b', 'print.foo']);
+      expect(patterns.map((p) => p.source)).toEqual(['^z']);
+    });
+  });
+
+  describe('exportPattern string arguments are R-unescaped', () => {
+    it('turns the R string "\\\\." into the regex \\.', async () => {
+      const { patterns } = await load('exportPattern("^a\\\\.b$")\n');
+      expect(patterns).toHaveLength(1);
+      expect(patterns[0].source).toBe('^a\\.b$');
+      expect(patterns[0].test('a.b')).toBe(true);
+      expect(patterns[0].test('axb')).toBe(false);
+    });
+
+    it('unescapes quotes and the common control escapes', async () => {
+      const { patterns } = await load(
+        'exportPattern("^a\\"b")\nexportPattern(\'^c\\\'d\')\nexportPattern("^e\\tf")\nexportPattern("^g\\nh")\n',
+      );
+      // RegExp#source re-escapes a line terminator, so compare behaviour for those two.
+      expect(patterns.map((p) => p.test('a"b'))).toEqual([true, false, false, false]);
+      expect(patterns[1].test("c'd")).toBe(true);
+      expect(patterns[2].test('e\tf')).toBe(true);
+      expect(patterns[3].test('g\nh')).toBe(true);
+    });
+
+    it('unescapes \\\\ to one backslash and leaves POSIX classes working', async () => {
+      const { patterns } = await load('exportPattern("^[[:alpha:]]+\\\\.R$")\n');
+      expect(patterns).toHaveLength(1);
+      expect(patterns[0].test('tidy.R')).toBe(true);
+      expect(patterns[0].test('tidyXR')).toBe(false);
+    });
+
+    it('accepts several patterns in one exportPattern() call', async () => {
+      const { patterns } = await load('exportPattern("^a",\n  "^b")\n');
+      expect(patterns.map((p) => p.source)).toEqual(['^a', '^b']);
+    });
+
+    it('keeps a ) or # inside a pattern string', async () => {
+      const { patterns } = await load('exportPattern("^(a|b)#")\n');
+      expect(patterns.map((p) => p.source)).toEqual(['^(a|b)#']);
+    });
+
+    it('drops an empty or non-string pattern argument without throwing', async () => {
+      const { patterns } = await load(
+        'exportPattern("")\nexportPattern(bare)\nexportPattern("^ok")\n',
+      );
+      expect(patterns.map((p) => p.source)).toEqual(['^ok']);
+    });
+  });
+
+  describe('realistic shapes', () => {
+    it('parses a 10-directive NAMESPACE where 5 directives wrap (aggregate shape)', async () => {
+      const ns = [
+        '# Generated by roxygen2: do not edit by hand',
+        '',
+        'S3method(print,scorecard)',
+        'S3method(summary,',
+        '  scorecard)',
+        'export(build_card)',
+        'export(',
+        '  rank_scores,',
+        '  clip_scores,',
+        '  normalise_scores',
+        ')',
+        'exportClasses(',
+        '  ScoreCard,',
+        '  ScoreBand)',
+        'exportMethods(show)',
+        'exportPattern("^tidy_")',
+        'importFrom(dplyr,',
+        '  mutate,',
+        '  filter)',
+        'importFrom(stats, sd)',
+        'export(last_one)',
+      ].join('\n');
+      const { names, patterns } = await load(ns + '\n');
+      expect(names).toEqual([
+        'ScoreBand',
+        'ScoreCard',
+        'build_card',
+        'clip_scores',
+        'last_one',
+        'normalise_scores',
+        'print.scorecard',
+        'rank_scores',
+        'show',
+        'summary.scorecard',
+      ]);
+      expect(patterns.map((p) => p.source)).toEqual(['^tidy_']);
+    });
+
+    it('keeps directives parsed before a garbled one and never throws', async () => {
+      const { names } = await load('export(a)\nexport(b, "unterminated\n');
+      expect(names).toEqual(['a']);
+    });
+
+    // Resynchronisation rule: a garbled or unbalanced directive is discarded and
+    // scanning resumes at the next line that begins at column 0 with
+    // `identifier(`. Quoted strings never span lines.
+    describe('resynchronises after a malformed directive', () => {
+      it('keeps valid directives on both sides of an unbalanced paren', async () => {
+        const { names } = await load('export(a)\nexport(b, c\nexport(d)\nS3method(print, e)\n');
+        expect(names).toEqual(['a', 'd', 'print.e']);
+      });
+
+      it('keeps directives after an unterminated quote instead of swallowing them', async () => {
+        const { names, patterns } = await load(
+          'export(a)\nexport(b, "c)\nexport("d")\nexportPattern("^p_")\nexportClasses(E)\n',
+        );
+        expect(names).toEqual(['E', 'a', 'd']);
+        expect(patterns.map((p) => p.source)).toEqual(['^p_']);
+      });
+
+      it('recovers from a garbled exportPattern, S3method and stray characters', async () => {
+        const { names, patterns } = await load(
+          'export(a)\nexportPattern("^broken\n@@ ;; S3method(x\nS3method(print, ok)\nexportPattern("^good")\n',
+        );
+        expect(names).toEqual(['a', 'print.ok']);
+        expect(patterns.map((p) => p.source)).toEqual(['^good']);
+      });
+
+      it('drops a garbled directive at the end of file and a garbled first directive', async () => {
+        expect((await load('export(a)\nexport(b, "c\n')).names).toEqual(['a']);
+        expect((await load('export(a, "b\nexport(c)\n')).names).toEqual(['c']);
+      });
+
+      it('survives several garbled directives, CRLF and comments', async () => {
+        const src = [
+          '# export(hidden, "never',
+          'export(a',
+          'export(b)',
+          'export(c, "d)',
+          'exportMethods(m)',
+          'export(',
+          'export(f)',
+        ].join('\r\n');
+        expect((await load(src)).names).toEqual(['b', 'f', 'm']);
+      });
+
+      it('resumes only at column 0 and recovers after a garbled conditional body', async () => {
+        expect((await load('export(a\n  export(b)\nexport(c)\n')).names).toEqual(['c']);
+        expect((await load('if (TRUE) export(a\nexport(b)\n')).names).toEqual(['b']);
+      });
+
+      it('always makes forward progress on many garbled lines and still finds the tail', async () => {
+        const garbled = Array.from({ length: 3000 }, () => 'export(a, "x').join('\n');
+        expect((await load(garbled + '\nexport(last)\n')).names).toEqual(['last']);
+      });
+    });
+
+    it('never throws on garbage input', async () => {
+      for (const src of ['', ')))((( ,,, """ \'\'\' ```', 'export(', 'S3method(', '{ { {']) {
+        await expect(load(src)).resolves.toEqual({ names: [], patterns: [] });
+      }
+    });
+  });
+});
diff --git a/gitnexus/test/unit/r-namespace-parser.test.ts b/gitnexus/test/unit/r-namespace-parser.test.ts
new file mode 100644
index 000000000..12db4e002
--- /dev/null
+++ b/gitnexus/test/unit/r-namespace-parser.test.ts
@@ -0,0 +1,334 @@
+import { describe, it, expect } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+import { parseRNamespaceImportFrom } from '../../src/core/ingestion/languages/r/namespace-imports.js';
+import { loadRPackageConfig } from '../../src/core/ingestion/languages/r/package-config.js';
+import { createTempDirPool } from '../helpers/temp-dir-pool.js';
+
+// `parseRNamespaceImportFrom` is pure and package-blind: it returns every
+// `importFrom()` pair in file order. Own-package drop, last-wins and external
+// skipping are consumer policy (`populateRNamespaceImports`), not parser behaviour.
+describe('parseRNamespaceImportFrom', () => {
+  it('parses a single-line directive with several names', () => {
+    expect(parseRNamespaceImportFrom('importFrom(dplyr, mutate, filter)\n')).toEqual([
+      { pkg: 'dplyr', name: 'mutate' },
+      { pkg: 'dplyr', name: 'filter' },
+    ]);
+  });
+
+  it('parses a wrapped multi-line directive with leading/trailing commas and blank lines', () => {
+    const src = [
+      'importFrom(scorelib,',
+      '  normalise_scores,',
+      '',
+      '  rank_scores,',
+      '  clip_scores,',
+      '  )',
+      'importFrom(,tidyr,',
+      '  pivot_longer,)',
+    ].join('\n');
+    expect(parseRNamespaceImportFrom(src)).toEqual([
+      { pkg: 'scorelib', name: 'normalise_scores' },
+      { pkg: 'scorelib', name: 'rank_scores' },
+      { pkg: 'scorelib', name: 'clip_scores' },
+    ]);
+  });
+
+  it('parses a 6-line wrapped directive', () => {
+    const src = 'importFrom(\n  scorelib,\n  a,\n  b,\n  c,\n  d\n)\n';
+    expect(parseRNamespaceImportFrom(src)).toEqual([
+      { pkg: 'scorelib', name: 'a' },
+      { pkg: 'scorelib', name: 'b' },
+      { pkg: 'scorelib', name: 'c' },
+      { pkg: 'scorelib', name: 'd' },
+    ]);
+  });
+
+  it('accepts bare, double-quoted, single-quoted and backticked names', () => {
+    const src = `importFrom("dplyr", "mutate", 'filter', \`select\`, bare)\nimportFrom(magrittr, \`%>%\`, .data)\n`;
+    expect(parseRNamespaceImportFrom(src)).toEqual([
+      { pkg: 'dplyr', name: 'mutate' },
+      { pkg: 'dplyr', name: 'filter' },
+      { pkg: 'dplyr', name: 'select' },
+      { pkg: 'dplyr', name: 'bare' },
+      { pkg: 'magrittr', name: '%>%' },
+      { pkg: 'magrittr', name: '.data' },
+    ]);
+  });
+
+  it('strips backticks and quotes from the package name too', () => {
+    expect(parseRNamespaceImportFrom('importFrom(`pkg.a`, x)\nimportFrom("pkg-b", y)')).toEqual([
+      { pkg: 'pkg.a', name: 'x' },
+      { pkg: 'pkg-b', name: 'y' },
+    ]);
+  });
+
+  it('tolerates whitespace between the directive head and the parenthesis', () => {
+    expect(parseRNamespaceImportFrom('importFrom (dplyr, mutate)')).toEqual([
+      { pkg: 'dplyr', name: 'mutate' },
+    ]);
+  });
+
+  it('strips comments: full-line, inline, and inside a wrapped directive', () => {
+    const src = [
+      '# importFrom(ignored, gone)',
+      'importFrom(dplyr, mutate) # trailing comment importFrom(x, y)',
+      'importFrom(scorelib,  # why',
+      '  rank_scores)',
+    ].join('\n');
+    expect(parseRNamespaceImportFrom(src)).toEqual([
+      { pkg: 'dplyr', name: 'mutate' },
+      { pkg: 'scorelib', name: 'rank_scores' },
+    ]);
+  });
+
+  it('keeps a # inside a quoted name', () => {
+    expect(parseRNamespaceImportFrom('importFrom(pkg, "a#b", c)')).toEqual([
+      { pkg: 'pkg', name: 'a#b' },
+      { pkg: 'pkg', name: 'c' },
+    ]);
+  });
+
+  it('is CRLF-safe', () => {
+    const src =
+      'importFrom(dplyr,\r\n  mutate,\r\n  filter)\r\nimportFrom(tidyr, pivot_longer)\r\n';
+    expect(parseRNamespaceImportFrom(src)).toEqual([
+      { pkg: 'dplyr', name: 'mutate' },
+      { pkg: 'dplyr', name: 'filter' },
+      { pkg: 'tidyr', name: 'pivot_longer' },
+    ]);
+  });
+
+  it('ignores import(), importClassesFrom(), importMethodsFrom(), S3method(), export*(), useDynLib()', () => {
+    const src = [
+      'import(dplyr)',
+      'importClassesFrom(methods, setClass)',
+      'importMethodsFrom(methods, show)',
+      'S3method(print, thing)',
+      'export(a, b)',
+      'exportPattern("^[a-z]")',
+      'exportClasses(K)',
+      'useDynLib(pkg, .registration = TRUE)',
+      'importFrom(dplyr, mutate)',
+    ].join('\n');
+    expect(parseRNamespaceImportFrom(src)).toEqual([{ pkg: 'dplyr', name: 'mutate' }]);
+  });
+
+  it('does not extract an importFrom nested inside another directive', () => {
+    expect(parseRNamespaceImportFrom('export(importFrom(a, b))')).toEqual([]);
+  });
+
+  it('ignores conditional importFrom (if / else, with or without braces)', () => {
+    const src = [
+      'if (getRversion() >= "4.0.0") importFrom(newpkg, fn)',
+      'if (cond) {',
+      '  importFrom(bracedpkg, fn2)',
+      '} else {',
+      '  importFrom(otherpkg, fn3)',
+      '}',
+      'if (cond) importFrom(a, b) else importFrom(c, d)',
+      'importFrom(dplyr, mutate)',
+    ].join('\n');
+    expect(parseRNamespaceImportFrom(src)).toEqual([{ pkg: 'dplyr', name: 'mutate' }]);
+  });
+
+  it('returns a self-import entry like any other (dropping it is the consumer job)', () => {
+    expect(parseRNamespaceImportFrom('importFrom(analytics, helper)\n')).toEqual([
+      { pkg: 'analytics', name: 'helper' },
+    ]);
+  });
+
+  it('preserves file order and keeps a duplicate symbol from two packages', () => {
+    const src = 'importFrom(pkga, filter)\nimportFrom(dplyr, mutate)\nimportFrom(pkgb, filter)\n';
+    expect(parseRNamespaceImportFrom(src)).toEqual([
+      { pkg: 'pkga', name: 'filter' },
+      { pkg: 'dplyr', name: 'mutate' },
+      { pkg: 'pkgb', name: 'filter' },
+    ]);
+  });
+
+  it('keeps a repeated identical entry (no dedup in the parser)', () => {
+    expect(parseRNamespaceImportFrom('importFrom(a, f)\nimportFrom(a, f)')).toHaveLength(2);
+  });
+
+  it('yields nothing for a directive with a package but no names, or no arguments', () => {
+    expect(parseRNamespaceImportFrom('importFrom(dplyr)\nimportFrom()\nimportFrom(,)')).toEqual([]);
+  });
+
+  it('never throws on empty, whitespace-only, unbalanced or garbage input', () => {
+    for (const src of [
+      '',
+      '   \n\t\n',
+      'importFrom(dplyr, mutate',
+      'importFrom(dplyr, "mutate)',
+      'importFrom(',
+      'importFrom',
+      ')))((( ,,, """ \'\'\' ```',
+      '\u0000\u0001 importFrom(a, b',
+      '{ { {',
+    ]) {
+      expect(() => parseRNamespaceImportFrom(src)).not.toThrow();
+      expect(parseRNamespaceImportFrom(src)).toEqual([]);
+    }
+  });
+
+  it('keeps directives parsed before an unbalanced one', () => {
+    expect(parseRNamespaceImportFrom('importFrom(dplyr, mutate)\nimportFrom(broken, x')).toEqual([
+      { pkg: 'dplyr', name: 'mutate' },
+    ]);
+  });
+
+  // Resynchronisation rule: a garbled or unbalanced directive
+  // is discarded and scanning resumes at the next line that begins at column 0
+  // with `identifier(`. Quoted strings never span lines, and a column-0
+  // `identifier(` line ends any directive still open, so a broken directive
+  // cannot swallow the ones after it.
+  describe('resynchronises after a malformed directive', () => {
+    it('keeps valid directives on both sides of an unbalanced paren', () => {
+      expect(
+        parseRNamespaceImportFrom('importFrom(a, x)\nimportFrom(b, y\nimportFrom(c, z)\n'),
+      ).toEqual([
+        { pkg: 'a', name: 'x' },
+        { pkg: 'c', name: 'z' },
+      ]);
+    });
+
+    it('keeps directives after an unterminated quote instead of swallowing them', () => {
+      const src = 'importFrom(a, x)\nimportFrom(b, "y)\nimportFrom(c, "z")\nimportFrom(d, w)\n';
+      expect(parseRNamespaceImportFrom(src)).toEqual([
+        { pkg: 'a', name: 'x' },
+        { pkg: 'c', name: 'z' },
+        { pkg: 'd', name: 'w' },
+      ]);
+    });
+
+    it('keeps directives after stray characters and a stray unterminated top-level quote', () => {
+      const src = 'importFrom(a, x)\n@@ !! importFrom(b\n"stray\nimportFrom(c, z)\n';
+      expect(parseRNamespaceImportFrom(src)).toEqual([
+        { pkg: 'a', name: 'x' },
+        { pkg: 'c', name: 'z' },
+      ]);
+    });
+
+    it('drops a garbled directive at the end of the file and keeps the rest', () => {
+      expect(parseRNamespaceImportFrom('importFrom(a, x)\nimportFrom(b, "y\n')).toEqual([
+        { pkg: 'a', name: 'x' },
+      ]);
+    });
+
+    it('drops a garbled first directive and keeps everything after it', () => {
+      expect(parseRNamespaceImportFrom('importFrom(a, "x\nimportFrom(b, y)\n')).toEqual([
+        { pkg: 'b', name: 'y' },
+      ]);
+    });
+
+    it('survives several garbled directives interleaved with valid ones', () => {
+      const src = [
+        'importFrom(a, "x',
+        'importFrom(b, y)',
+        'importFrom(c, z',
+        'importFrom(d, "w)',
+        'importFrom(e, v)',
+        'importFrom(',
+        'importFrom(f, u)',
+      ].join('\n');
+      expect(parseRNamespaceImportFrom(src)).toEqual([
+        { pkg: 'b', name: 'y' },
+        { pkg: 'e', name: 'v' },
+        { pkg: 'f', name: 'u' },
+      ]);
+    });
+
+    it('resynchronises on CRLF input', () => {
+      const src = 'importFrom(a, x)\r\nimportFrom(b, "y)\r\nimportFrom(c, z)\r\n';
+      expect(parseRNamespaceImportFrom(src)).toEqual([
+        { pkg: 'a', name: 'x' },
+        { pkg: 'c', name: 'z' },
+      ]);
+    });
+
+    it('ignores garbage inside comments and ends an open directive at a commented line boundary', () => {
+      const src = [
+        '# importFrom(x, "unterminated',
+        'importFrom(a, y, # trailing (note',
+        'importFrom(b, z)',
+      ].join('\n');
+      expect(parseRNamespaceImportFrom(src)).toEqual([{ pkg: 'b', name: 'z' }]);
+    });
+
+    it('resumes only at column 0: an indented directive after a garbled one is dropped', () => {
+      const src = 'importFrom(a, x\n  importFrom(b, y)\nimportFrom(c, z)\n';
+      expect(parseRNamespaceImportFrom(src)).toEqual([{ pkg: 'c', name: 'z' }]);
+    });
+
+    it('resynchronises after a garbled conditional body', () => {
+      const src = 'if (TRUE) importFrom(a, y\nimportFrom(b, z)\nif (x) {\nimportFrom(c, w)\n';
+      expect(parseRNamespaceImportFrom(src)).toEqual([
+        { pkg: 'b', name: 'z' },
+        { pkg: 'c', name: 'w' },
+      ]);
+    });
+
+    it('always makes forward progress on many garbled lines and still finds the tail', () => {
+      const garbled = Array.from({ length: 3000 }, () => 'importFrom(a, "x').join('\n');
+      const unbalanced = Array.from({ length: 3000 }, () => 'importFrom(a, x').join('\n');
+      const tail = '\nimportFrom(z, last)\n';
+      expect(parseRNamespaceImportFrom(garbled + tail)).toEqual([{ pkg: 'z', name: 'last' }]);
+      expect(parseRNamespaceImportFrom(unbalanced + tail)).toEqual([{ pkg: 'z', name: 'last' }]);
+    });
+  });
+
+  it('skips a stray quoted string at top level without misreading its contents', () => {
+    expect(parseRNamespaceImportFrom('"importFrom(a, b)"\nimportFrom(c, d)')).toEqual([
+      { pkg: 'c', name: 'd' },
+    ]);
+  });
+
+  it('ignores non-simple arguments (named / nested) but keeps the simple ones', () => {
+    expect(parseRNamespaceImportFrom('importFrom(pkg, x = y, good, f(z))')).toEqual([
+      { pkg: 'pkg', name: 'good' },
+    ]);
+  });
+});
+
+describe('loadRPackageConfig -> RNamespaceInfo.importFrom', () => {
+  const pool = createTempDirPool('gn-r-ns-');
+
+  it('populates importFrom (all entries, file order) alongside the existing export fields', async () => {
+    const root = pool.dir();
+    const pkgDir = path.join(root, 'analytics');
+    fs.mkdirSync(pkgDir, { recursive: true });
+    fs.writeFileSync(path.join(pkgDir, 'DESCRIPTION'), 'Package: analytics\nVersion: 0.0.1\n');
+    fs.writeFileSync(
+      path.join(pkgDir, 'NAMESPACE'),
+      'export(run_all)\nimportFrom(scorelib,\n  rank_scores,\n  clip_scores)\nimportFrom(analytics, helper)\n',
+    );
+    const config = await loadRPackageConfig(root);
+    const info = config?.namespaceInfoByPackageDir.get('analytics');
+    expect(info?.hasNamespaceFile).toBe(true);
+    expect([...(info?.namedExports ?? [])]).toEqual(['run_all']);
+    expect(info?.importFrom).toEqual([
+      { pkg: 'scorelib', name: 'rank_scores' },
+      { pkg: 'scorelib', name: 'clip_scores' },
+      { pkg: 'analytics', name: 'helper' },
+    ]);
+  });
+
+  it('leaves no namespace entry when the package has no NAMESPACE file', async () => {
+    const root = pool.dir();
+    const pkgDir = path.join(root, 'plainpkg');
+    fs.mkdirSync(pkgDir, { recursive: true });
+    fs.writeFileSync(path.join(pkgDir, 'DESCRIPTION'), 'Package: plainpkg\n');
+    const config = await loadRPackageConfig(root);
+    expect(config?.packages.get('plainpkg')).toBe('plainpkg');
+    expect(config?.namespaceInfoByPackageDir.has('plainpkg')).toBe(false);
+  });
+
+  it('gives an empty importFrom for a NAMESPACE without importFrom directives', async () => {
+    const root = pool.dir();
+    fs.writeFileSync(path.join(root, 'DESCRIPTION'), 'Package: rootpkg\n');
+    fs.writeFileSync(path.join(root, 'NAMESPACE'), 'export(f)\n');
+    const config = await loadRPackageConfig(root);
+    expect(config?.namespaceInfoByPackageDir.get('')?.importFrom).toEqual([]);
+  });
+});
diff --git a/gitnexus/test/unit/r-owner-hooks.test.ts b/gitnexus/test/unit/r-owner-hooks.test.ts
new file mode 100644
index 000000000..f81c6b65b
--- /dev/null
+++ b/gitnexus/test/unit/r-owner-hooks.test.ts
@@ -0,0 +1,146 @@
+import { describe, it, expect, beforeAll } from 'vitest';
+import { SupportedLanguages } from 'gitnexus-shared';
+import { createParserForLanguage } from '../../src/core/tree-sitter/parser-loader.js';
+import type { SyntaxNode } from '../../src/core/ingestion/utils/ast-helpers.js';
+import {
+  rDefinitionProperties,
+  rResolveMemberOwnerNode,
+} from '../../src/core/ingestion/languages/r/owner-hooks.js';
+import type { DefinitionPropertiesContext } from '../../src/core/ingestion/language-provider.js';
+import { rProvider } from '../../src/core/ingestion/languages/r.js';
+import { getProvider } from '../../src/core/ingestion/languages/index.js';
+
+// R's member-owner node is found through
+// `LanguageProvider.resolveMemberOwnerNode`, not a `language === R` branch in the worker.
+// R classes are calls/assignments, not syntactic containers, so the hook returns the R6
+// `binary_operator` or the `setRefClass(...)` call that owns a member.
+
+const SOURCE = `Foo <- R6::R6Class("Foo", public = list(n = 1, bar = function() 1))
+Acc <- setRefClass("Acc", fields = list(a = "numeric"), methods = list(m = function() 1))
+setMethod("area", "Circle", function(shape) 1)
+plain <- function(x) x
+`;
+
+let root: SyntaxNode;
+
+const walk = (n: SyntaxNode, visit: (n: SyntaxNode) => void): void => {
+  visit(n);
+  for (let i = 0; i < n.namedChildCount; i++) {
+    const child = n.namedChild(i);
+    if (child) walk(child, visit);
+  }
+};
+
+const find = (pred: (n: SyntaxNode) => boolean): SyntaxNode => {
+  let hit: SyntaxNode | undefined;
+  walk(root, (n) => {
+    if (hit === undefined && pred(n)) hit = n;
+  });
+  if (hit === undefined) throw new Error('fixture node not found');
+  return hit;
+};
+
+const fnDefinitionOn = (row: number): SyntaxNode =>
+  find((n) => n.type === 'function_definition' && n.startPosition.row === row);
+
+beforeAll(async () => {
+  const parser = await createParserForLanguage(SupportedLanguages.R);
+  root = parser.parse(SOURCE).rootNode as unknown as SyntaxNode;
+});
+
+describe('rResolveMemberOwnerNode', () => {
+  it('resolves an R6 method to the enclosing `Foo <- R6Class(...)` binary_operator', () => {
+    const owner = rResolveMemberOwnerNode(fnDefinitionOn(0));
+    expect(owner?.type).toBe('binary_operator');
+    expect(owner?.childForFieldName('lhs')?.text).toBe('Foo');
+  });
+
+  it('resolves an R6 field to the same binary_operator', () => {
+    const field = find((n) => n.type === 'argument' && n.childForFieldName('name')?.text === 'n');
+    const owner = rResolveMemberOwnerNode(field);
+    expect(owner?.type).toBe('binary_operator');
+    expect(owner?.childForFieldName('lhs')?.text).toBe('Foo');
+  });
+
+  it('resolves a RefClass method to the `setRefClass(...)` call', () => {
+    const owner = rResolveMemberOwnerNode(fnDefinitionOn(1));
+    expect(owner?.type).toBe('call');
+    expect(owner?.childForFieldName('function')?.text).toBe('setRefClass');
+  });
+
+  it('returns null for a top-level function', () => {
+    expect(rResolveMemberOwnerNode(fnDefinitionOn(3))).toBeNull();
+  });
+
+  it('returns null for a setMethod(...) call (its owner arrives via ownerNameHint, not a node)', () => {
+    const call = find(
+      (n) => n.type === 'call' && n.childForFieldName('function')?.text === 'setMethod',
+    );
+    expect(rResolveMemberOwnerNode(call)).toBeNull();
+    expect(rResolveMemberOwnerNode(fnDefinitionOn(2))).toBeNull();
+  });
+});
+
+describe('resolveMemberOwnerNode provider wiring', () => {
+  it('is registered on the R provider', () => {
+    expect(rProvider.resolveMemberOwnerNode).toBe(rResolveMemberOwnerNode);
+    expect(getProvider(SupportedLanguages.R).resolveMemberOwnerNode).toBe(rResolveMemberOwnerNode);
+  });
+
+  it('is left undefined on other providers', () => {
+    for (const lang of [
+      SupportedLanguages.Python,
+      SupportedLanguages.TypeScript,
+      SupportedLanguages.Java,
+      SupportedLanguages.Zig,
+    ]) {
+      expect(getProvider(lang).resolveMemberOwnerNode).toBeUndefined();
+    }
+  });
+});
+
+describe('rDefinitionProperties (ownerNameHint)', () => {
+  const ctxFor = (
+    nodeLabel: DefinitionPropertiesContext['nodeLabel'],
+    definitionNode: SyntaxNode,
+  ): DefinitionPropertiesContext => ({
+    nodeLabel,
+    nodeName: 'x',
+    filePath: 'R/x.R',
+    definitionNode,
+    parsedImports: [],
+    isExported: true,
+  });
+  const setMethodCall = (): SyntaxNode =>
+    find((n) => n.type === 'call' && n.childForFieldName('function')?.text === 'setMethod');
+
+  it('hints the string class of a setMethod(...) Method', () => {
+    expect(rDefinitionProperties(ctxFor('Method', setMethodCall()))).toEqual({
+      ownerNameHint: 'Circle',
+    });
+  });
+
+  it('hints the R6 class of an R6 Method', () => {
+    expect(rDefinitionProperties(ctxFor('Method', fnDefinitionOn(0)))).toEqual({
+      ownerNameHint: 'Foo',
+    });
+  });
+
+  it('hints the R6 class of an R6 Property', () => {
+    const field = find((n) => n.type === 'argument' && n.childForFieldName('name')?.text === 'n');
+    expect(rDefinitionProperties(ctxFor('Property', field))).toEqual({ ownerNameHint: 'Foo' });
+  });
+
+  it('returns undefined for a Function label or a plain function', () => {
+    expect(rDefinitionProperties(ctxFor('Function', fnDefinitionOn(3)))).toBeUndefined();
+    expect(rDefinitionProperties(ctxFor('Method', fnDefinitionOn(3)))).toBeUndefined();
+    expect(rDefinitionProperties(ctxFor('Function', setMethodCall()))).toBeUndefined();
+  });
+
+  it('is registered as the R definitionPropertiesExtractor only', () => {
+    expect(rProvider.definitionPropertiesExtractor).toBe(rDefinitionProperties);
+    expect(getProvider(SupportedLanguages.Python).definitionPropertiesExtractor).not.toBe(
+      rDefinitionProperties,
+    );
+  });
+});
diff --git a/gitnexus/test/unit/r-package-discovery-order.test.ts b/gitnexus/test/unit/r-package-discovery-order.test.ts
new file mode 100644
index 000000000..be541f5e1
--- /dev/null
+++ b/gitnexus/test/unit/r-package-discovery-order.test.ts
@@ -0,0 +1,191 @@
+/**
+ * R package discovery must not depend on the order in which the filesystem lists
+ * directory entries (ext4 hash order, APFS, NTFS and overlayfs all differ).
+ *
+ * `readdir` is intercepted so a real temporary tree is listed in ascending,
+ * descending and seeded-shuffled order; the discovery result has to be the same
+ * for every order. A one-order test could pass by accident on a filesystem that
+ * happens to list entries sorted.
+ */
+import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { cleanupTempDirSync } from '../helpers/test-db.js';
+import fsReal from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {
+  hidesUndiscoveredPackage,
+  loadRPackageConfig,
+  type RPackageConfig,
+} from '../../src/core/ingestion/languages/r/package-config.js';
+
+type Order = 'asc' | 'desc' | number;
+const box = vi.hoisted(() => ({ order: 'asc' as 'asc' | 'desc' | number }));
+
+/** Reproducible Fisher-Yates (LCG seeded), so a failing order can be replayed. */
+function reorder<T extends { name: string }>(entries: readonly T[], order: Order): T[] {
+  const out = [...entries].sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+  if (order === 'asc') return out;
+  if (order === 'desc') return out.reverse();
+  let s = order;
+  const rand = (): number => {
+    s = (s * 1103515245 + 12345) & 0x7fffffff;
+    return s / 0x7fffffff;
+  };
+  for (let i = out.length - 1; i > 0; i--) {
+    const j = Math.floor(rand() * (i + 1));
+    [out[i], out[j]] = [out[j]!, out[i]!];
+  }
+  return out;
+}
+
+vi.mock('fs/promises', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('fs/promises')>();
+  const base = (actual as unknown as { default: typeof actual }).default ?? actual;
+  const readdir = (async (...args: Parameters<typeof actual.readdir>) => {
+    const entries = await (base.readdir as (...a: unknown[]) => Promise<unknown>)(...args);
+    return Array.isArray(entries) && entries.every((e) => typeof e === 'object' && e !== null)
+      ? reorder(entries as { name: string }[], box.order)
+      : entries;
+  }) as typeof actual.readdir;
+  return { ...actual, readdir, default: { ...base, readdir } };
+});
+
+const ORDERS: readonly Order[] = ['asc', 'desc', 1, 2, 3, 4, 5];
+
+let tmp: string;
+let counter = 0;
+
+async function write(root: string, rel: string, content: string): Promise<void> {
+  const full = path.join(root, rel);
+  await fsReal.mkdir(path.dirname(full), { recursive: true });
+  await fsReal.writeFile(full, content);
+}
+
+const desc = (name: string): string => `Package: ${name}\nVersion: 1.0\n`;
+
+async function newRepo(): Promise<string> {
+  const root = path.join(tmp, `repo${counter++}`);
+  await fsReal.mkdir(root, { recursive: true });
+  return root;
+}
+
+/** Everything observable about a config, including Map iteration order. */
+function snapshot(cfg: RPackageConfig): unknown {
+  return {
+    packages: [...cfg.packages],
+    namespaces: [...cfg.namespaceInfoByPackageDir.keys()],
+    truncated: cfg.truncated,
+  };
+}
+
+async function discover(root: string, order: Order): Promise<RPackageConfig> {
+  box.order = order;
+  return loadRPackageConfig(root);
+}
+
+describe('R package discovery is independent of readdir order', () => {
+  beforeAll(async () => {
+    tmp = await fsReal.mkdtemp(path.join(os.tmpdir(), 'gn-r-order-'));
+  });
+  afterAll(async () => {
+    box.order = 'asc';
+    cleanupTempDirSync(tmp);
+  });
+  beforeEach(() => {
+    box.order = 'asc';
+  });
+
+  it('same-depth duplicate package names resolve to the path that sorts first', async () => {
+    const root = await newRepo();
+    for (const dir of ['mm', 'zz', 'aa']) await write(root, `${dir}/DESCRIPTION`, desc('dup'));
+    for (const order of ORDERS) {
+      const cfg = await discover(root, order);
+      expect(cfg.packages.get('dup'), `order ${String(order)}`).toBe('aa');
+      expect(cfg.packages.size).toBe(1);
+    }
+  });
+
+  it('the shallowest duplicate wins even when a deeper one sorts earlier', async () => {
+    const root = await newRepo();
+    await write(root, 'aaa/nested/DESCRIPTION', desc('dup'));
+    await write(root, 'zzz/DESCRIPTION', desc('dup'));
+    for (const order of ORDERS) {
+      const cfg = await discover(root, order);
+      expect(cfg.packages.get('dup'), `order ${String(order)}`).toBe('zzz');
+    }
+  });
+
+  it('same-depth duplicates compare as whole paths, not segment by segment', async () => {
+    const root = await newRepo();
+    // '-' (U+002D) sorts before '/' (U+002F), so as whole strings 'a-b/x' < 'a/x',
+    // although the directory 'a' itself sorts before 'a-b'.
+    await write(root, 'a/x/DESCRIPTION', desc('dup'));
+    await write(root, 'a-b/x/DESCRIPTION', desc('dup'));
+    for (const order of ORDERS) {
+      const cfg = await discover(root, order);
+      expect(cfg.packages.get('dup'), `order ${String(order)}`).toBe('a-b/x');
+    }
+  });
+
+  it('a root-level package beats a nested package of the same name', async () => {
+    const root = await newRepo();
+    await write(root, 'DESCRIPTION', desc('dup'));
+    await write(root, 'inst/copy/DESCRIPTION', desc('dup'));
+    for (const order of ORDERS) {
+      expect((await discover(root, order)).packages.get('dup'), `order ${String(order)}`).toBe('');
+    }
+  });
+
+  it('packages and NAMESPACE entries come back in the same order for every listing order', async () => {
+    const root = await newRepo();
+    for (const name of ['delta', 'alpha', 'charlie', 'bravo']) {
+      await write(root, `pkgs/${name}/DESCRIPTION`, desc(name));
+      await write(root, `pkgs/${name}/NAMESPACE`, `export(${name}_fn)\n`);
+    }
+    const reference = snapshot(await discover(root, 'asc'));
+    expect((reference as { packages: [string, string][] }).packages.map(([n]) => n)).toEqual([
+      'alpha',
+      'bravo',
+      'charlie',
+      'delta',
+    ]);
+    for (const order of ORDERS) expect(snapshot(await discover(root, order))).toEqual(reference);
+  });
+
+  it('the 200-directory cap keeps the same packages and the same truncated flag', async () => {
+    const root = await newRepo();
+    // 250 sibling directories (root counts as the first scanned one): whichever 199 the
+    // walk reads first decide what is discovered. d010 is read, d240 is not.
+    for (let i = 0; i < 250; i++) {
+      const dir = `d${String(i).padStart(3, '0')}`;
+      await fsReal.mkdir(path.join(root, dir), { recursive: true });
+    }
+    await write(root, 'd010/DESCRIPTION', desc('early'));
+    await write(root, 'd240/DESCRIPTION', desc('late'));
+    const reference = await discover(root, 'asc');
+    expect([...reference.packages.keys()]).toEqual(['early']);
+    expect(reference.truncated).toBe(true);
+    for (const order of ORDERS)
+      expect(snapshot(await discover(root, order))).toEqual(snapshot(reference));
+  });
+
+  it('the hidden-package scan answers the same for every listing order', async () => {
+    const root = await newRepo();
+    await write(root, 'a/b/c/known/DESCRIPTION', desc('known'));
+    await write(root, 'a/b/c/z/deep/DESCRIPTION', desc('unknown'));
+    await write(root, 'q/none/file.txt', 'x');
+    const clean = await newRepo();
+    await write(clean, 'a/b/c/known/DESCRIPTION', desc('known'));
+    await write(clean, 'q/none/file.txt', 'x');
+    for (const order of ORDERS) {
+      box.order = order;
+      const known = new Set(['known']);
+      expect(await hidesUndiscoveredPackage([root], known), `hidden, ${String(order)}`).toBe(true);
+      expect(await hidesUndiscoveredPackage([clean], known), `clean, ${String(order)}`).toBe(false);
+      // Budget exhaustion is a count of directories, not of an order.
+      expect(await hidesUndiscoveredPackage([clean], known, 2), `budget, ${String(order)}`).toBe(
+        true,
+      );
+    }
+  });
+});
diff --git a/gitnexus/test/unit/r-package-discovery-vendored.test.ts b/gitnexus/test/unit/r-package-discovery-vendored.test.ts
new file mode 100644
index 000000000..f3657238f
--- /dev/null
+++ b/gitnexus/test/unit/r-package-discovery-vendored.test.ts
@@ -0,0 +1,155 @@
+/**
+ * R package discovery must not treat installed libraries and check output
+ * (`renv/`, `packrat/`, `revdep/`, `<pkg>.Rcheck/`) as repository packages.
+ *
+ * Every test builds a real temporary tree. The skip rule is exact: the near-miss
+ * names below must still be searched, because a real package can live in a
+ * directory called `renv-tools`.
+ */
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { cleanupTempDirSync } from '../helpers/test-db.js';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {
+  hidesUndiscoveredPackage,
+  loadRPackageConfig,
+} from '../../src/core/ingestion/languages/r/package-config.js';
+import { rQualifierLocality } from '../../src/core/ingestion/languages/r/qualified-call.js';
+
+let tmp: string;
+let counter = 0;
+
+const desc = (name: string): string => `Package: ${name}\nVersion: 1.0\n`;
+
+async function write(root: string, rel: string, content: string): Promise<void> {
+  const full = path.join(root, rel);
+  await fs.mkdir(path.dirname(full), { recursive: true });
+  await fs.writeFile(full, content);
+}
+
+async function newRepo(): Promise<string> {
+  const root = path.join(tmp, `repo${counter++}`);
+  await fs.mkdir(root, { recursive: true });
+  return root;
+}
+
+/** A repository whose own package is `mypkg`, at the root. */
+async function rootPackageRepo(): Promise<string> {
+  const root = await newRepo();
+  await write(root, 'DESCRIPTION', desc('mypkg'));
+  await write(root, 'NAMESPACE', 'export(f)\n');
+  return root;
+}
+
+/** Directory names the rule skips, as a (name, a path inside it that holds a package) pair. */
+const VENDORED: readonly (readonly [label: string, dir: string])[] = [
+  ['renv', 'renv/library/dplyr'],
+  ['packrat', 'packrat/lib/dplyr'],
+  ['revdep', 'revdep/library/dplyr'],
+  ['.Rcheck', 'mypkg.Rcheck/00_pkg_src/dplyr'],
+];
+
+/** Names that resemble the rule but must not be skipped. */
+const NEAR_MISSES: readonly string[] = [
+  'renv-tools',
+  'Renv',
+  'RENV',
+  'renv2',
+  'packrat_old',
+  'revdeps',
+  'Rcheck',
+  'pkg.rcheck',
+  'pkg.Rcheck.bak',
+  '.Rcheck',
+];
+
+describe('R package discovery skips vendored and generated trees', () => {
+  beforeAll(async () => {
+    tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'gn-r-vendored-'));
+  });
+  afterAll(async () => {
+    cleanupTempDirSync(tmp);
+  });
+
+  it('a renv library below the depth limit neither adds a package nor truncates discovery', async () => {
+    const root = await rootPackageRepo();
+    await write(root, 'renv/library/x86_64-pc-linux-gnu/4.3/dplyr/DESCRIPTION', desc('dplyr'));
+    const cfg = await loadRPackageConfig(root);
+    expect([...cfg.packages.keys()]).toEqual(['mypkg']);
+    expect(cfg.truncated).toBe(false);
+  });
+
+  describe.each(VENDORED)('%s directory', (_label, pkgDir) => {
+    it('is not searched for packages within the depth limit', async () => {
+      const root = await rootPackageRepo();
+      await write(root, `${pkgDir}/DESCRIPTION`, desc('dplyr'));
+      await write(root, `${pkgDir}/NAMESPACE`, 'export(filter)\n');
+      const cfg = await loadRPackageConfig(root);
+      expect(cfg.packages.has('dplyr')).toBe(false);
+      expect([...cfg.namespaceInfoByPackageDir.keys()]).toEqual(['']);
+      expect(cfg.truncated).toBe(false);
+    });
+
+    it('is skipped when nested below another directory', async () => {
+      const root = await rootPackageRepo();
+      await write(root, `analysis/${pkgDir}/DESCRIPTION`, desc('dplyr'));
+      const cfg = await loadRPackageConfig(root);
+      expect([...cfg.packages.keys()]).toEqual(['mypkg']);
+      expect(cfg.truncated).toBe(false);
+    });
+
+    it('does not truncate discovery when it lies beyond the depth limit', async () => {
+      const root = await rootPackageRepo();
+      await write(root, `a/b/c/d/${pkgDir}/DESCRIPTION`, desc('dplyr'));
+      const cfg = await loadRPackageConfig(root);
+      expect([...cfg.packages.keys()]).toEqual(['mypkg']);
+      expect(cfg.truncated).toBe(false);
+    });
+
+    it('is not entered by the hidden-package scan', async () => {
+      const root = await newRepo();
+      await write(root, `${pkgDir}/DESCRIPTION`, desc('dplyr'));
+      expect(await hidesUndiscoveredPackage([root], new Set())).toBe(false);
+    });
+  });
+
+  it('a genuine package beside a vendored tree is still discovered and not displaced by a same-named copy inside it', async () => {
+    const root = await rootPackageRepo();
+    await write(root, 'packages/dplyr/DESCRIPTION', desc('dplyr'));
+    await write(root, 'packages/dplyr/NAMESPACE', 'export(filter)\n');
+    for (const [, dir] of VENDORED) await write(root, `${dir}/DESCRIPTION`, desc('dplyr'));
+    const cfg = await loadRPackageConfig(root);
+    expect([...cfg.packages].sort()).toEqual([
+      ['dplyr', 'packages/dplyr'],
+      ['mypkg', ''],
+    ]);
+    expect([...cfg.namespaceInfoByPackageDir.keys()].sort()).toEqual(['', 'packages/dplyr']);
+    expect(cfg.truncated).toBe(false);
+  });
+
+  it('an installed library package is external for qualifier resolution', async () => {
+    const root = await rootPackageRepo();
+    await write(root, 'renv/library/x86_64-pc-linux-gnu/4.3/dplyr/DESCRIPTION', desc('dplyr'));
+    const cfg = await loadRPackageConfig(root);
+    expect(rQualifierLocality('dplyr', cfg, new Set())).toBe('external');
+    expect(rQualifierLocality('mypkg', cfg, new Set())).toBe('local');
+  });
+
+  describe.each(NEAR_MISSES)('near-miss name %s', (name) => {
+    it('is still searched for packages', async () => {
+      const root = await rootPackageRepo();
+      await write(root, `${name}/DESCRIPTION`, desc('real'));
+      await write(root, `${name}/NAMESPACE`, 'export(g)\n');
+      const cfg = await loadRPackageConfig(root);
+      expect(cfg.packages.get('real')).toBe(name);
+      expect(cfg.namespaceInfoByPackageDir.has(name)).toBe(true);
+    });
+
+    it('is still searched by the hidden-package scan', async () => {
+      const root = await newRepo();
+      await write(root, `${name}/DESCRIPTION`, desc('real'));
+      expect(await hidesUndiscoveredPackage([root], new Set())).toBe(true);
+    });
+  });
+});
diff --git a/gitnexus/test/unit/r-post-parse-owners.test.ts b/gitnexus/test/unit/r-post-parse-owners.test.ts
new file mode 100644
index 000000000..3e8d49f1c
--- /dev/null
+++ b/gitnexus/test/unit/r-post-parse-owners.test.ts
@@ -0,0 +1,188 @@
+import { describe, it, expect } from 'vitest';
+import { SupportedLanguages } from 'gitnexus-shared';
+import type { GraphRelationship, NodeLabel } from 'gitnexus-shared';
+import { createKnowledgeGraph } from '../../src/core/graph/graph.js';
+import { createSemanticModel } from '../../src/core/ingestion/model/semantic-model.js';
+import { attachDeferredROwners } from '../../src/core/ingestion/languages/r/post-parse.js';
+import { generateId } from '../../src/lib/utils.js';
+
+// Characterisation tests for the R deferred-owner attach.
+// R classes are calls (`R6::R6Class`, `setRefClass`, `setMethod`), so the worker cannot always name
+// an owner node; it leaves an `ownerNameHint` string that `attachDeferredROwners` resolves once every
+// Class is registered. These tests pin that behaviour.
+
+const FILE = 'R/a.R';
+
+const setup = () => {
+  const graph = createKnowledgeGraph();
+  const model = createSemanticModel();
+
+  const addClass = (name: string, filePath = FILE): string => {
+    const id = `Class:${filePath}:${name}`;
+    graph.addNode({
+      id,
+      label: 'Class',
+      properties: { name, filePath, language: SupportedLanguages.R },
+    });
+    model.symbols.add(filePath, name, id, 'Class');
+    return id;
+  };
+
+  const addMember = (
+    label: 'Method' | 'Property',
+    name: string,
+    properties: Record<string, unknown>,
+    opts: { language?: SupportedLanguages; ownerId?: string; filePath?: string } = {},
+  ): string => {
+    const filePath = opts.filePath ?? FILE;
+    const id = `${label}:${filePath}:${name}`;
+    graph.addNode({
+      id,
+      label: label as NodeLabel,
+      properties: {
+        name,
+        filePath,
+        language: opts.language ?? SupportedLanguages.R,
+        ...properties,
+      },
+    });
+    model.symbols.add(
+      filePath,
+      name,
+      id,
+      label,
+      opts.ownerId === undefined ? undefined : { ownerId: opts.ownerId },
+    );
+    return id;
+  };
+
+  const edges = (type: string): GraphRelationship[] => {
+    const out: GraphRelationship[] = [];
+    graph.forEachRelationship((r) => {
+      if (r.type === type) out.push(r);
+    });
+    return out;
+  };
+
+  return { graph, model, addClass, addMember, edges };
+};
+
+describe('attachDeferredROwners', () => {
+  it.each([
+    ['Method', 'HAS_METHOD'],
+    ['Property', 'HAS_PROPERTY'],
+  ] as const)(
+    '(a) resolves a unique class hint on a %s: ownerId, edge, registry, shared def',
+    (label, edgeType) => {
+      const { graph, model, addClass, addMember, edges } = setup();
+      const ownerId = addClass('Foo');
+      const nodeId = addMember(label, 'run', { ownerNameHint: 'Foo' });
+
+      attachDeferredROwners(graph, model, label, edgeType);
+
+      const node = graph.getNode(nodeId)!;
+      expect(node.properties.ownerId).toBe(ownerId);
+      expect(node.properties).not.toHaveProperty('ownerNameHint');
+
+      const rels = edges(edgeType);
+      expect(rels).toHaveLength(1);
+      expect(rels[0]).toEqual({
+        id: generateId(edgeType, `${ownerId}->${nodeId}`),
+        sourceId: ownerId,
+        targetId: nodeId,
+        type: edgeType,
+        confidence: 1.0,
+        reason: '',
+      });
+
+      const registered =
+        label === 'Method'
+          ? model.methods.lookupAllByOwner(ownerId, 'run')
+          : model.fields.lookupAllByOwner(ownerId, 'run');
+      expect(registered).toHaveLength(1);
+      expect(registered[0].nodeId).toBe(nodeId);
+      // The registered def is the same object the symbol table holds, and it now carries the owner.
+      const [def] = model.symbols.lookupExactAll(FILE, 'run');
+      expect(registered[0]).toBe(def);
+      expect(def.ownerId).toBe(ownerId);
+    },
+  );
+
+  it('only attaches nodes of the requested label', () => {
+    const { graph, model, addClass, addMember, edges } = setup();
+    addClass('Foo');
+    const propId = addMember('Property', 'field', { ownerNameHint: 'Foo' });
+
+    attachDeferredROwners(graph, model, 'Method', 'HAS_METHOD');
+
+    expect(edges('HAS_METHOD')).toHaveLength(0);
+    expect(graph.getNode(propId)!.properties.ownerNameHint).toBe('Foo');
+    expect(graph.getNode(propId)!.properties).not.toHaveProperty('ownerId');
+  });
+
+  it('(b) leaves the hint and registers nothing when two classes share the name', () => {
+    const { graph, model, addClass, addMember, edges } = setup();
+    const first = addClass('Foo', 'R/a.R');
+    addClass('Foo', 'R/b.R');
+    const nodeId = addMember('Method', 'run', { ownerNameHint: 'Foo' });
+
+    attachDeferredROwners(graph, model, 'Method', 'HAS_METHOD');
+
+    const node = graph.getNode(nodeId)!;
+    expect(node.properties.ownerNameHint).toBe('Foo');
+    expect(node.properties).not.toHaveProperty('ownerId');
+    expect(edges('HAS_METHOD')).toHaveLength(0);
+    expect(model.methods.lookupAllByOwner(first, 'run')).toHaveLength(0);
+    expect(model.symbols.lookupExactAll(FILE, 'run')[0].ownerId).toBeUndefined();
+  });
+
+  it('(c) leaves the hint and registers nothing when no class has the name', () => {
+    const { graph, model, addMember, edges } = setup();
+    const nodeId = addMember('Method', 'run', { ownerNameHint: 'Missing' });
+
+    attachDeferredROwners(graph, model, 'Method', 'HAS_METHOD');
+
+    const node = graph.getNode(nodeId)!;
+    expect(node.properties.ownerNameHint).toBe('Missing');
+    expect(node.properties).not.toHaveProperty('ownerId');
+    expect(edges('HAS_METHOD')).toHaveLength(0);
+  });
+
+  it('(d) does not touch a non-R node that carries a hint-looking property', () => {
+    const { graph, model, addClass, addMember, edges } = setup();
+    addClass('Foo');
+    const nodeId = addMember(
+      'Method',
+      'run',
+      { ownerNameHint: 'Foo' },
+      { language: SupportedLanguages.Python, filePath: 'src/a.py' },
+    );
+
+    attachDeferredROwners(graph, model, 'Method', 'HAS_METHOD');
+
+    const node = graph.getNode(nodeId)!;
+    expect(node.properties.ownerNameHint).toBe('Foo');
+    expect(node.properties).not.toHaveProperty('ownerId');
+    expect(edges('HAS_METHOD')).toHaveLength(0);
+  });
+
+  it('(e) an already-owned node drops its hint and is never re-attached or double-registered', () => {
+    const { graph, model, addClass, addMember, edges } = setup();
+    const ownerId = addClass('Foo');
+    const otherId = addClass('Bar');
+    // Owned up front: the def is registered once by the semantic model because it carries an ownerId,
+    // and the hint points at a DIFFERENT (unique) class to prove no re-resolution happens.
+    const nodeId = addMember('Method', 'run', { ownerId, ownerNameHint: 'Bar' }, { ownerId });
+    expect(model.methods.lookupAllByOwner(ownerId, 'run')).toHaveLength(1);
+
+    attachDeferredROwners(graph, model, 'Method', 'HAS_METHOD');
+
+    const node = graph.getNode(nodeId)!;
+    expect(node.properties.ownerId).toBe(ownerId);
+    expect(node.properties).not.toHaveProperty('ownerNameHint');
+    expect(edges('HAS_METHOD')).toHaveLength(0);
+    expect(model.methods.lookupAllByOwner(ownerId, 'run')).toHaveLength(1);
+    expect(model.methods.lookupAllByOwner(otherId, 'run')).toHaveLength(0);
+    expect(model.symbols.lookupExactAll(FILE, 'run')[0].ownerId).toBe(ownerId);
+  });
+});
diff --git a/gitnexus/test/unit/r-qualified-capture.test.ts b/gitnexus/test/unit/r-qualified-capture.test.ts
new file mode 100644
index 000000000..c4897f75f
--- /dev/null
+++ b/gitnexus/test/unit/r-qualified-capture.test.ts
@@ -0,0 +1,65 @@
+/**
+ * R scope query: `@reference.qualified-name` on `pkg::fn()` / `pkg:::fn()` calls.
+ *
+ * The free-call qualified hook fires only when a site carries `rawQualifiedName`, which the
+ * scope extractor copies from the `@reference.qualified-name` capture. Cached files cannot be
+ * re-read, hence the capture (and a SCHEMA_BUMP) rather than re-parsing at resolve time.
+ *
+ * Each form asserts the call, its name and the whole `namespace_operator` text together,
+ * so a form that fails to parse or loses its name capture cannot pass.
+ */
+import { describe, expect, it } from 'vitest';
+import { emitRScopeCaptures } from '../../src/core/ingestion/languages/r/captures.js';
+
+type Tags = Record<string, string>;
+
+function callMatches(source: string): Tags[] {
+  return emitRScopeCaptures(source, 'fixture.R')
+    .map((m) => Object.fromEntries(Object.entries(m).map(([tag, cap]) => [tag, cap.text])) as Tags)
+    .filter((t) => t['@reference.call.free'] !== undefined && t['@reference.name'] !== undefined);
+}
+
+/** The single `@reference.name === name` call match in `source`. */
+function only(source: string, name: string): Tags {
+  const found = callMatches(source).filter((t) => t['@reference.name'] === name);
+  if (found.length !== 1) throw new Error(`expected one match for ${name}, got ${found.length}`);
+  return found[0];
+}
+
+const FORMS: readonly {
+  readonly label: string;
+  readonly source: string;
+  readonly written: string;
+}[] = [
+  { label: 'pkg::f', source: 'run <- function(d) pkg::f(d)', written: 'pkg::f' },
+  { label: 'pkg:::f', source: 'run <- function(d) pkg:::f(d)', written: 'pkg:::f' },
+  { label: 'spaced pkg ::: f', source: 'run <- function(d) pkg ::: f(d)', written: 'pkg ::: f' },
+  { label: 'spaced pkg :: f', source: 'run <- function(d) pkg  ::  f(d)', written: 'pkg  ::  f' },
+  { label: 'quoted "pkg"::f', source: 'run <- function(d) "pkg"::f(d)', written: '"pkg"::f' },
+  { label: "quoted 'pkg'::f", source: "run <- function(d) 'pkg'::f(d)", written: "'pkg'::f" },
+  { label: 'backticked `pkg`::f', source: 'run <- function(d) `pkg`::f(d)', written: '`pkg`::f' },
+];
+
+describe('R query: qualified-name capture on namespace_operator calls', () => {
+  for (const form of FORMS) {
+    describe(form.label, () => {
+      it('captures the whole namespace_operator text as @reference.qualified-name', () => {
+        const t = only(form.source, 'f');
+        expect(t['@reference.name']).toBe('f');
+        expect(t['@reference.call.free']).toBe(form.written + '(d)');
+        expect(t['@reference.qualified-name']).toBe(form.written);
+      });
+    });
+  }
+
+  describe('unqualified and non-namespace calls carry no qualified name (qualified-name capture leaves them untouched)', () => {
+    it('a bare call f(x)', () => {
+      const t = only('run <- function(d) f(d)', 'f');
+      expect(t['@reference.qualified-name']).toBeUndefined();
+    });
+
+    it('a member call obj$f(x) is not a free call', () => {
+      expect(callMatches('run <- function(o) o$f(1)')).toEqual([]);
+    });
+  });
+});
diff --git a/gitnexus/test/unit/r-scope-naming-argument.test.ts b/gitnexus/test/unit/r-scope-naming-argument.test.ts
new file mode 100644
index 000000000..8368bba10
--- /dev/null
+++ b/gitnexus/test/unit/r-scope-naming-argument.test.ts
@@ -0,0 +1,149 @@
+/**
+ * R scope query: only the argument that names a class or an import yields
+ * `@declaration.name` / `@import.source`. The query captures every candidate
+ * argument; `emitRScopeCaptures` drops the rest. Each negative is paired with a
+ * positive control, and a scaling group guards the cost against a quadratic
+ * regression (an argument-prefix pattern in the query was quadratic in the number
+ * of leading comments and named arguments).
+ */
+import { describe, expect, it } from 'vitest';
+import { emitRScopeCaptures } from '../../src/core/ingestion/languages/r/captures.js';
+import { MAX_RATIO, SHAPES, measureScaling } from '../helpers/r-argument-scaling.js';
+
+function tagTexts(source: string, tag: string): string[] {
+  return emitRScopeCaptures(source, 'fixture.R')
+    .map((m) => m[tag]?.text)
+    .filter((t): t is string => t !== undefined);
+}
+
+const importSources = (source: string) => tagTexts(source, '@import.source');
+/**
+ * Every class declared by the scope query. Selected by capture kind (the match carries
+ * `@declaration.class`), not by spelling, so a lowercase class or a wrongly captured
+ * lowercase string is visible.
+ */
+const classNames = (source: string) =>
+  emitRScopeCaptures(source, 'fixture.R')
+    .filter((m) => m['@declaration.class'] !== undefined)
+    .map((m) => m['@declaration.name']?.text)
+    .filter((t): t is string => t !== undefined);
+
+describe('R scope query: imports name only their first argument', () => {
+  it('imports the first argument (positive controls)', () => {
+    expect(importSources('library(pkg)')).toEqual(['pkg']);
+    expect(importSources('require("pkg")')).toEqual(['"pkg"']);
+    expect(importSources('source("a.R")')).toEqual(['"a.R"']);
+  });
+
+  it('does not import a later argument', () => {
+    expect(importSources('library(pkg, lib.loc = lib)')).toEqual(['pkg']);
+    expect(importSources('source("a.R", local = env)')).toEqual(['"a.R"']);
+    expect(importSources('require(pkg, quietly = "yes")')).toEqual(['pkg']);
+  });
+
+  it('imports the first unnamed argument after named arguments', () => {
+    expect(importSources('library(character.only = TRUE, pkg)')).toEqual(['pkg']);
+    expect(importSources('library(lib.loc = lib, pkg)')).toEqual(['pkg']);
+    expect(importSources('source(local = env, "a.R")')).toEqual(['"a.R"']);
+  });
+
+  it('imports the argument named by package = / file =', () => {
+    expect(importSources('library(package = pkg)')).toEqual(['pkg']);
+    expect(importSources('source(file = "a.R")')).toEqual(['"a.R"']);
+    expect(importSources('library(package = pkg, "other")')).toEqual(['pkg']);
+  });
+
+  it('does not import an unnamed argument once a later argument is spelled package = / file =', () => {
+    expect(importSources('library("other", package = pkg)')).toEqual(['pkg']);
+    expect(importSources('source("b.R", local = env, file = "a.R")')).toEqual(['"a.R"']);
+  });
+
+  it('imports the first argument when a comment precedes it', () => {
+    expect(importSources('library(\n  # the package\n  pkg, lib.loc = lib)')).toEqual(['pkg']);
+    expect(importSources('source(\n  # c\n  "a.R", local = env)')).toEqual(['"a.R"']);
+  });
+});
+
+describe('R scope query: setClass declares only its naming argument', () => {
+  it('declares the class from the first argument (positive control)', () => {
+    expect(classNames('setClass("A", contains = "VIRTUAL")')).toEqual(['A']);
+    expect(classNames('setRefClass("R", contains = "Base")')).toEqual(['R']);
+  });
+
+  it('declares a lowercase class name (positive controls)', () => {
+    expect(classNames('setClass("a", contains = "VIRTUAL")')).toEqual(['a']);
+    expect(classNames('setRefClass("r")')).toEqual(['r']);
+    expect(classNames('setClass(Class = "a")')).toEqual(['a']);
+  });
+
+  it('does not declare a lowercase class from a non-naming argument', () => {
+    expect(classNames('setClass("A", contains = "numeric")')).toEqual(['A']);
+    expect(classNames('setRefClass("R", contains = "base")')).toEqual(['R']);
+    expect(classNames('setClass("a", contains = "numeric", package = "pkg")')).toEqual(['a']);
+    expect(classNames('setClass("A", representation("numeric", x = "character"))')).toEqual(['A']);
+  });
+
+  it('declares only Class = when it follows an unnamed argument', () => {
+    expect(classNames('setClass(a = "Q", "B", Class = "A")')).toEqual(['A']);
+    expect(classNames('setRefClass("B", Class = "A")')).toEqual(['A']);
+  });
+
+  it('declares the class when a comment precedes it', () => {
+    expect(classNames('setClass(\n  # doc\n  "A", contains = "VIRTUAL")')).toEqual(['A']);
+  });
+
+  it('declares the class from Class = after a named contains =', () => {
+    expect(classNames('setClass(contains = "Base", Class = "A")')).toEqual(['A']);
+    expect(classNames('setClass(representation = representation(x = "numeric"), "A")')).toEqual([
+      'A',
+    ]);
+  });
+});
+
+describe('R scope query: cost is linear in the argument count', () => {
+  /** What the query kept: the match count and the naming captures, in source order. */
+  const run = (source: string) => () => {
+    const matches = emitRScopeCaptures(source, 'fixture.R');
+    const naming: string[] = [];
+    for (const m of matches) {
+      for (const tag of ['@declaration.name', '@import.source']) {
+        const text = m[tag]?.text;
+        if (text !== undefined) naming.push(`${tag}=${text}`);
+      }
+    }
+    return { count: matches.length, naming };
+  };
+
+  // Every shape keeps exactly one naming capture regardless of the argument count: the
+  // count and the name are asserted at both sizes, so an early-return or empty parse
+  // cannot pass as "fast".
+  const cases = [
+    { shape: SHAPES.listNamedArguments, expected: { count: 2, naming: [] } },
+    { shape: SHAPES.setClassNamedBefore, expected: { count: 4, naming: ['@declaration.name=A'] } },
+    { shape: SHAPES.libraryNamedBefore, expected: { count: 3, naming: ['@import.source=pkg'] } },
+    {
+      shape: SHAPES.setClassCommentsBefore,
+      expected: { count: 4, naming: ['@declaration.name=A'] },
+    },
+    { shape: SHAPES.libraryCommentsBefore, expected: { count: 3, naming: ['@import.source=pkg'] } },
+    {
+      shape: SHAPES.setClassUnnamedStrings,
+      expected: { count: 4, naming: ['@declaration.name=s0'] },
+    },
+    {
+      shape: SHAPES.libraryUnnamedStrings,
+      expected: { count: 3, naming: ['@import.source="s0"'] },
+    },
+  ] as const;
+
+  it.each(cases)(
+    '$shape.name',
+    ({ shape, expected }) => {
+      const { small, large, ratio } = measureScaling(run, shape.build);
+      expect(small).toEqual(expected);
+      expect(large).toEqual(expected);
+      expect(ratio).toBeLessThan(MAX_RATIO);
+    },
+    120_000,
+  );
+});
diff --git a/gitnexus/test/unit/scope-resolution/external-import-conformance.test.ts b/gitnexus/test/unit/scope-resolution/external-import-conformance.test.ts
index fd29e7eea..672ef35a9 100644
--- a/gitnexus/test/unit/scope-resolution/external-import-conformance.test.ts
+++ b/gitnexus/test/unit/scope-resolution/external-import-conformance.test.ts
@@ -412,6 +412,21 @@ const CASES: ReadonlyMap<SupportedLanguages, ConformanceCase> = new Map([
       reachesDecoy: 'std.zig',
     },
   ],
+  [
+    SupportedLanguages.R,
+    {
+      files: ['scripts/main.R', 'vendor/ggplot2.py', 'pkgA/R/utils.R'],
+      fromFile: 'scripts/main.R',
+      resolutionConfig: undefined,
+      external: 'ggplot2',
+      decoy: 'vendor/ggplot2.py',
+      reachesDecoy: 'ggplot2.py',
+      parsedImport: (targetRaw) =>
+        targetRaw === 'ggplot2'
+          ? { kind: 'wildcard', targetRaw }
+          : { kind: 'side-effect', targetRaw },
+    },
+  ],
   [
     SupportedLanguages.ObjectiveC,
     {
@@ -541,4 +556,35 @@ describe('external imports never resolve into the repository (#2953)', () => {
       `${language}: '${testCase.external}' names nothing in this repo, but resolved to ${JSON.stringify(resolved)}`,
     ).toEqual([]);
   });
+  // R's NAMESPACE `importFrom(ggplot2, geom)` is a `named` import (the wildcard/side-effect arms
+  // above cover `library()`/`source()`). The bare package name must not suffix-match the
+  // same-named `vendor/ggplot2.py`, whether or not a local package config exists.
+  it.each([
+    ['no package config', undefined],
+    [
+      'a package config that lists only other packages',
+      { packages: new Map([['pkgA', 'pkgA']]), namespaceInfoByPackageDir: new Map() },
+    ],
+  ])(
+    'R: a named importFrom() of an external package resolves to nothing (%s)',
+    (_label, config) => {
+      const testCase = CASES.get(SupportedLanguages.R)!;
+      const answer = SCOPE_RESOLVERS.get(SupportedLanguages.R)!.resolveImportTarget(
+        testCase.external,
+        testCase.fromFile,
+        new Set(testCase.files),
+        config,
+        {
+          parsedFiles: [],
+          parsedImport: {
+            kind: 'named',
+            localName: 'geom',
+            importedName: 'geom',
+            targetRaw: testCase.external,
+          },
+        },
+      );
+      expect(filesOf(answer)).toEqual([]);
+    },
+  );
 });
diff --git a/gitnexus/test/unit/scope-resolution/import-target-index-reuse.contract.test.ts b/gitnexus/test/unit/scope-resolution/import-target-index-reuse.contract.test.ts
index af18b0a00..af5cd09ed 100644
--- a/gitnexus/test/unit/scope-resolution/import-target-index-reuse.contract.test.ts
+++ b/gitnexus/test/unit/scope-resolution/import-target-index-reuse.contract.test.ts
@@ -546,6 +546,19 @@ const FIXTURES: ReadonlyMap<SupportedLanguages, ImportTargetFixture> = new Map<
       minimumParsedFileReads: 0,
     },
   ],
+  [
+    SupportedLanguages.R,
+    {
+      files: ['scripts/main.R', 'scripts/utils.R', 'pkgA/R/other.R'],
+      fromFile: 'scripts/main.R',
+      resolutionConfig: undefined,
+      missTarget: (i) => `ghost${i}.R`,
+      hitTarget: 'utils.R',
+      parsedImport: (targetRaw) => ({ kind: 'side-effect', targetRaw }),
+      minimumScans: 1,
+      minimumParsedFileReads: 0,
+    },
+  ],
   [
     SupportedLanguages.ObjectiveC,
     {
diff --git a/gitnexus/test/unit/scope-resolution/r/r-dotted-s3-hooks.test.ts b/gitnexus/test/unit/scope-resolution/r/r-dotted-s3-hooks.test.ts
new file mode 100644
index 000000000..b860bd137
--- /dev/null
+++ b/gitnexus/test/unit/scope-resolution/r/r-dotted-s3-hooks.test.ts
@@ -0,0 +1,115 @@
+/**
+ * R dotted (S3) names vs bare names in the shared simple-name indexes:
+ * the `isCallableVisibleFromCaller` hook and the
+ * `expandRWildcardNames` tail guard. ParsedFiles come from the real R extractor.
+ */
+import { describe, expect, it } from 'vitest';
+import type { ParsedFile, SymbolDefinition } from 'gitnexus-shared';
+import { extractParsedFile } from '../../../../src/core/ingestion/scope-extractor-bridge.js';
+import { rProvider } from '../../../../src/core/ingestion/languages/r.js';
+import { populateClassOwnedMembers } from '../../../../src/core/ingestion/scope-resolution/scope/walkers.js';
+import {
+  expandRWildcardNames,
+  rIsCallableVisibleFromCaller,
+  rScopeResolver,
+} from '../../../../src/core/ingestion/languages/r/scope-resolver.js';
+
+function parse(src: string, filePath: string): ParsedFile {
+  const parsed = extractParsedFile(rProvider, src, filePath);
+  if (parsed === undefined) throw new Error(`no ParsedFile for ${filePath}`);
+  populateClassOwnedMembers(parsed);
+  return parsed;
+}
+
+const def = (parsed: ParsedFile, qualifiedName: string): SymbolDefinition => {
+  const found = parsed.localDefs.find((d) => d.qualifiedName === qualifiedName);
+  if (found === undefined) throw new Error(`no def ${qualifiedName}`);
+  return found;
+};
+
+const visible = (callerParsed: ParsedFile, candidate: SymbolDefinition): boolean =>
+  rIsCallableVisibleFromCaller({ callerParsed, candidate } as never);
+
+describe('rIsCallableVisibleFromCaller', () => {
+  const p = parse(
+    [
+      'print.foo <- function(x, ...) x',
+      'foo <- function(v) v',
+      '`odd name` <- function(v) v',
+      'Scorer <- R6::R6Class("Scorer", public = list(score = function(d) d))',
+    ].join('\n'),
+    'pkg/R/a.R',
+  );
+
+  it('is registered on rScopeResolver', () => {
+    expect(rScopeResolver.isCallableVisibleFromCaller).toBe(rIsCallableVisibleFromCaller);
+  });
+
+  it('refuses a dotted S3 def for a bare call', () => {
+    expect(visible(p, def(p, 'print.foo'))).toBe(false);
+  });
+
+  it('allows a bare def and a backticked non-dotted def', () => {
+    expect(visible(p, def(p, 'foo'))).toBe(true);
+    expect(visible(p, def(p, '`odd name`'))).toBe(true);
+  });
+
+  it('refuses a class member whose qualified name is dotted (never callable bare)', () => {
+    const member = p.localDefs.find(
+      (d) => d.type === 'Method' && d.qualifiedName?.endsWith('score'),
+    );
+    if (member === undefined) throw new Error('no R6 member def');
+    expect(member.qualifiedName).toContain('.');
+    expect(visible(p, member)).toBe(false);
+  });
+
+  it('allows a def with no qualified name (nothing to prove)', () => {
+    expect(visible(p, { ...def(p, 'foo'), qualifiedName: undefined })).toBe(true);
+  });
+});
+
+describe('expandRWildcardNames', () => {
+  const names = (src: string): readonly string[] => {
+    const parsed = parse(src, 'pkg/R/a.R');
+    return expandRWildcardNames(parsed.moduleScope, [parsed]);
+  };
+
+  it('drops a bare name whose file defines a dotted def with that tail (S3 method first)', () => {
+    expect(names('print.foo <- function(x) x\nfoo <- function(v) v\nqux <- function(v) v')).toEqual(
+      ['qux'],
+    );
+  });
+
+  it('drops it in the mirror layout too (order-blind)', () => {
+    expect(names('bar <- function(v) v\nprint.bar <- function(x) x\nqux <- function(v) v')).toEqual(
+      ['qux'],
+    );
+  });
+
+  it('keeps names that share no tail with a dotted def', () => {
+    expect(names('print.foo <- function(x) x\nplain_fn <- function(v) v')).toEqual(['plain_fn']);
+  });
+
+  it('keeps a bare name when the dotted def sits in a different file', () => {
+    const a = parse('foo <- function(v) v', 'pkg/R/a.R');
+    const b = parse('print.foo <- function(x) x', 'pkg/R/b.R');
+    expect(expandRWildcardNames(a.moduleScope, [a, b])).toEqual(['foo']);
+  });
+
+  it('keeps a bare name that only matches a class member (not a top-level dotted def)', () => {
+    expect(
+      names(
+        'Scorer <- R6::R6Class("Scorer", public = list(tidy = function(d) d))\ntidy <- function(d) d',
+      ),
+    ).toEqual(['Scorer', 'tidy']);
+  });
+
+  it('never lists dotted names themselves', () => {
+    expect(names('print.foo <- function(x) x')).toEqual([]);
+  });
+
+  it('returns nothing for an unknown module scope', () => {
+    const a = parse('foo <- function(v) v', 'pkg/R/a.R');
+    expect(expandRWildcardNames('scope:missing' as never, [a])).toEqual([]);
+  });
+});
diff --git a/gitnexus/test/unit/scope-resolution/r/r-namespace-imports.test.ts b/gitnexus/test/unit/scope-resolution/r/r-namespace-imports.test.ts
new file mode 100644
index 000000000..45bff26dd
--- /dev/null
+++ b/gitnexus/test/unit/scope-resolution/r/r-namespace-imports.test.ts
@@ -0,0 +1,1062 @@
+/**
+ * R NAMESPACE `importFrom()` binding:
+ *
+ *  - `rPackageDirForFile`: which package's `R/` directory a file belongs to;
+ *  - `populateRNamespaceImports`: synthesised `named` imports for local
+ *    providers (last-wins, self-import drop, external skip, own-package mask);
+ *  - `resolveRImportTarget`'s `named` branch: local-package check, dotted-name
+ *    guards, NAMESPACE export check, top-level-definition lookup, and the
+ *    "builds no workspace file index" property.
+ *
+ * ParsedFiles come from the real R extractor; package configs are built by hand
+ * (`RPackageConfig` has no other constructor than `loadRPackageConfig`).
+ */
+import { describe, expect, it } from 'vitest';
+import type { ParsedFile, ParsedImport } from 'gitnexus-shared';
+import { extractParsedFile } from '../../../../src/core/ingestion/scope-extractor-bridge.js';
+import { rProvider } from '../../../../src/core/ingestion/languages/r.js';
+import { populateClassOwnedMembers } from '../../../../src/core/ingestion/scope-resolution/scope/walkers.js';
+import type {
+  RNamespaceInfo,
+  RPackageConfig,
+} from '../../../../src/core/ingestion/languages/r/package-config.js';
+import {
+  isRGlobalNameFallbackPlausible,
+  populateRNamespaceImports,
+  rFileTopLevel,
+  rPackageDirForFile,
+  rRecordedPackageTopLevelNames,
+} from '../../../../src/core/ingestion/languages/r/namespace-imports.js';
+import {
+  compileRExportPattern,
+  type RExportMatcher,
+} from '../../../../src/core/ingestion/languages/r/export-pattern.js';
+import { resolveRImportTarget } from '../../../../src/core/ingestion/import-resolvers/r.js';
+import { CountingSet } from '../../../helpers/counting-file-set.js';
+
+// ─── builders ───────────────────────────────────────────────────────────────
+
+function parse(src: string, filePath: string): ParsedFile {
+  const parsed = extractParsedFile(rProvider, src, filePath);
+  if (parsed === undefined) throw new Error(`no ParsedFile for ${filePath}`);
+  populateClassOwnedMembers(parsed);
+  return parsed;
+}
+
+interface NsSpec {
+  readonly exports?: readonly string[];
+  readonly exportPatterns?: readonly RExportMatcher[];
+  readonly importFrom?: readonly (readonly [pkg: string, name: string])[];
+  /** Omit the NAMESPACE entry altogether (package without a NAMESPACE file). */
+  readonly none?: boolean;
+}
+
+function config(
+  packages: Record<string, string>,
+  namespaces: Record<string, NsSpec> = {},
+): RPackageConfig {
+  const namespaceInfoByPackageDir = new Map<string, RNamespaceInfo>();
+  for (const [name, dir] of Object.entries(packages)) {
+    const spec = namespaces[name];
+    if (spec === undefined || spec.none === true) continue;
+    namespaceInfoByPackageDir.set(dir, {
+      hasNamespaceFile: true,
+      namedExports: new Set(spec.exports ?? []),
+      exportPatterns: [...(spec.exportPatterns ?? [])],
+      importFrom: (spec.importFrom ?? []).map(([pkg, name]) => ({ pkg, name })),
+    });
+  }
+  return { packages: new Map(Object.entries(packages)), namespaceInfoByPackageDir };
+}
+
+const namedImportsOf = (parsed: ParsedFile): string[] =>
+  parsed.parsedImports
+    .filter((i): i is Extract<ParsedImport, { kind: 'named' }> => i.kind === 'named')
+    .map((i) => `${i.targetRaw}::${i.importedName}`)
+    .sort();
+
+const populate = (files: ParsedFile[], cfg: RPackageConfig | null): ParsedFile[] => {
+  populateRNamespaceImports(files, { resolutionConfig: cfg ?? undefined });
+  return files;
+};
+
+// ─── rPackageDirForFile ─────────────────────────────────────────────────────
+
+describe('rPackageDirForFile', () => {
+  const cfg = config({ alpha: 'alpha', beta: 'sub/beta' });
+
+  it('finds the package whose R/ directory holds the file', () => {
+    expect(rPackageDirForFile('alpha/R/a.R', cfg)).toEqual({ name: 'alpha', dir: 'alpha' });
+  });
+
+  it('finds a nested package directory', () => {
+    expect(rPackageDirForFile('sub/beta/R/b.R', cfg)).toEqual({ name: 'beta', dir: 'sub/beta' });
+  });
+
+  it('accepts Windows separators', () => {
+    expect(rPackageDirForFile('alpha\\R\\a.R', cfg)?.name).toBe('alpha');
+  });
+
+  it('returns nothing for a file outside every package R/ directory', () => {
+    expect(
+      [
+        'alpha/tests/testthat/test-a.R',
+        'alpha/scripts/x.R',
+        'alpha/plumber.R',
+        'other/R/x.R',
+        'alphaR/R/x.R',
+      ].map((f) => rPackageDirForFile(f, cfg)),
+    ).toEqual([undefined, undefined, undefined, undefined, undefined]);
+  });
+
+  it('handles a root-level package (dir "") without building a "/" prefix', () => {
+    const root = config({ rootpkg: '' });
+    expect([
+      rPackageDirForFile('R/a.R', root),
+      rPackageDirForFile('R/sub/a.R', root),
+      rPackageDirForFile('tests/R/a.R', root),
+      rPackageDirForFile('plumber.R', root),
+    ]).toEqual([{ name: 'rootpkg', dir: '' }, { name: 'rootpkg', dir: '' }, undefined, undefined]);
+  });
+
+  it('prefers the longest package directory when package directories nest', () => {
+    const nested = config({ outer: 'outer', inner: 'outer/inner' });
+    expect(rPackageDirForFile('outer/inner/R/x.R', nested)?.name).toBe('inner');
+    expect(rPackageDirForFile('outer/R/x.R', nested)?.name).toBe('outer');
+  });
+
+  it('returns nothing without a config', () => {
+    expect([
+      rPackageDirForFile('alpha/R/a.R', null),
+      rPackageDirForFile('a/R/a.R', undefined),
+    ]).toEqual([undefined, undefined]);
+  });
+});
+
+// ─── rFileTopLevel ──────────────────────────────────────────────────────────
+
+describe('rFileTopLevel', () => {
+  const parsed = parse(
+    [
+      'x <- 1',
+      'tidy <- function(a) { inner <- function(b) b; inner(a) }',
+      'print.tidy <- function(x) x',
+      'Scorer <- R6::R6Class("Scorer", public = list(method_only = function(z) z))',
+    ].join('\n'),
+    'p/R/a.R',
+  );
+  const top = rFileTopLevel(parsed);
+
+  it('lists top-level functions and classes, dotted names included', () => {
+    expect([...top.names].sort()).toEqual(['Scorer', 'print.tidy', 'tidy']);
+  });
+
+  it('excludes nested functions, R6 members and plain variables', () => {
+    expect([...top.names].filter((n) => ['inner', 'method_only', 'x'].includes(n))).toEqual([]);
+  });
+
+  it('records the tail of every dotted name', () => {
+    expect([...top.dottedTails]).toEqual(['tidy']);
+  });
+});
+
+// ─── populateRNamespaceImports ──────────────────────────────────────────────
+
+describe('populateRNamespaceImports', () => {
+  const pkgs = { analytics: 'analytics', scorelib: 'scorelib', legacyscore: 'legacyscore' };
+  const provider = (path: string, names: string[]) =>
+    parse(names.map((n) => `${n} <- function(d) d`).join('\n'), path);
+  const callerFile = (path: string, src = 'noop <- function() 1') => parse(src, path);
+
+  it('synthesises a named import for a local-package importFrom() into every R/ file of the caller', () => {
+    const files = populate(
+      [
+        callerFile('analytics/R/a.R'),
+        callerFile('analytics/R/b.R'),
+        callerFile('analytics/R/c.R'),
+        provider('scorelib/R/s.R', ['tidy_scores']),
+      ],
+      config(pkgs, {
+        analytics: { importFrom: [['scorelib', 'tidy_scores']] },
+        scorelib: { exports: ['tidy_scores'] },
+      }),
+    );
+    expect(files.map(namedImportsOf)).toEqual([
+      ['scorelib::tidy_scores'],
+      ['scorelib::tidy_scores'],
+      ['scorelib::tidy_scores'],
+      [],
+    ]);
+  });
+
+  it('shapes the import as a per-name, un-renamed named import of the package', () => {
+    const [caller] = populate(
+      [callerFile('analytics/R/a.R'), provider('scorelib/R/s.R', ['tidy_scores'])],
+      config(pkgs, { analytics: { importFrom: [['scorelib', 'tidy_scores']] } }),
+    );
+    expect(caller.parsedImports).toEqual([
+      {
+        kind: 'named',
+        localName: 'tidy_scores',
+        importedName: 'tidy_scores',
+        targetRaw: 'scorelib',
+      },
+    ]);
+  });
+
+  it('skips an importFrom() of an external package (nothing local to bind)', () => {
+    const files = populate(
+      [callerFile('analytics/R/a.R'), provider('scorelib/R/s.R', ['mutate'])],
+      config(pkgs, { analytics: { importFrom: [['dplyr', 'mutate']] } }),
+    );
+    expect(files.map(namedImportsOf)).toEqual([[], []]);
+  });
+
+  it('drops a self-import (the parser returns it; the package cannot import from itself)', () => {
+    const files = populate(
+      [callerFile('analytics/R/a.R'), provider('scorelib/R/s.R', ['f'])],
+      config(pkgs, { analytics: { importFrom: [['analytics', 'f']] } }),
+    );
+    expect(files.map(namedImportsOf)).toEqual([[], []]);
+  });
+
+  it('skips a name the caller package defines at top level, even in a different file', () => {
+    const files = populate(
+      [
+        callerFile('analytics/R/a.R', 'uses_it <- function() 1'),
+        callerFile('analytics/R/own.R', 'own_dup <- function(d) d'),
+        provider('scorelib/R/s.R', ['own_dup', 'other_fn']),
+      ],
+      config(pkgs, {
+        analytics: {
+          importFrom: [
+            ['scorelib', 'own_dup'],
+            ['scorelib', 'other_fn'],
+          ],
+        },
+      }),
+    );
+    expect(files.map(namedImportsOf)).toEqual([['scorelib::other_fn'], ['scorelib::other_fn'], []]);
+  });
+
+  it('does not treat an R6 method of the caller package as a top-level definition', () => {
+    const files = populate(
+      [
+        callerFile(
+          'analytics/R/own.R',
+          'Runner <- R6::R6Class("Runner", public = list(tidy_scores = function(d) d))',
+        ),
+        provider('scorelib/R/s.R', ['tidy_scores']),
+      ],
+      config(pkgs, { analytics: { importFrom: [['scorelib', 'tidy_scores']] } }),
+    );
+    expect(namedImportsOf(files[0])).toEqual(['scorelib::tidy_scores']);
+  });
+
+  it('keeps only the last entry when two local packages import one name (last wins)', () => {
+    const files = populate(
+      [
+        callerFile('analytics/R/a.R'),
+        provider('scorelib/R/s.R', ['dup']),
+        provider('legacyscore/R/l.R', ['dup']),
+      ],
+      config(pkgs, {
+        analytics: {
+          importFrom: [
+            ['scorelib', 'dup'],
+            ['legacyscore', 'dup'],
+          ],
+        },
+      }),
+    );
+    expect(namedImportsOf(files[0])).toEqual(['legacyscore::dup']);
+  });
+
+  it('synthesises nothing when an external package is imported LAST for a name (no resurrection)', () => {
+    const files = populate(
+      [callerFile('analytics/R/a.R'), provider('scorelib/R/s.R', ['dup_ext'])],
+      config(pkgs, {
+        analytics: {
+          importFrom: [
+            ['scorelib', 'dup_ext'],
+            ['dplyr', 'dup_ext'],
+          ],
+        },
+      }),
+    );
+    expect(namedImportsOf(files[0])).toEqual([]);
+  });
+
+  it('binds the local package when it is imported after an external one', () => {
+    const files = populate(
+      [callerFile('analytics/R/a.R'), provider('scorelib/R/s.R', ['dup_ext'])],
+      config(pkgs, {
+        analytics: {
+          importFrom: [
+            ['dplyr', 'dup_ext'],
+            ['scorelib', 'dup_ext'],
+          ],
+        },
+      }),
+    );
+    expect(namedImportsOf(files[0])).toEqual(['scorelib::dup_ext']);
+  });
+
+  it('touches only R/ files: scripts/ and tests/ of the caller package get no import', () => {
+    const files = populate(
+      [
+        callerFile('analytics/R/a.R'),
+        callerFile('analytics/scripts/x.R'),
+        callerFile('analytics/tests/testthat/test-x.R'),
+        callerFile('analytics/plumber.R'),
+        provider('scorelib/R/s.R', ['f']),
+      ],
+      config(pkgs, { analytics: { importFrom: [['scorelib', 'f']] } }),
+    );
+    expect(files.map(namedImportsOf)).toEqual([['scorelib::f'], [], [], [], []]);
+  });
+
+  it('handles a root-level caller package', () => {
+    const files = populate(
+      [callerFile('R/a.R'), callerFile('scripts/x.R'), provider('scorelib/R/s.R', ['f'])],
+      config(
+        { rootpkg: '', scorelib: 'scorelib' },
+        { rootpkg: { importFrom: [['scorelib', 'f']] } },
+      ),
+    );
+    expect(files.map(namedImportsOf)).toEqual([['scorelib::f'], [], []]);
+  });
+
+  it('replaces array entries with frozen copies and leaves the originals untouched', () => {
+    const original = callerFile('analytics/R/a.R');
+    const files = [original, provider('scorelib/R/s.R', ['f'])];
+    populate(files, config(pkgs, { analytics: { importFrom: [['scorelib', 'f']] } }));
+    expect([
+      files[0] === original,
+      Object.isFrozen(files[0]),
+      original.parsedImports.length,
+    ]).toEqual([false, true, 0]);
+  });
+
+  it('is idempotent: a second pass does not duplicate the synthesised imports', () => {
+    const files = [callerFile('analytics/R/a.R'), provider('scorelib/R/s.R', ['f'])];
+    const cfg = config(pkgs, { analytics: { importFrom: [['scorelib', 'f']] } });
+    populate(files, cfg);
+    populate(files, cfg);
+    expect(namedImportsOf(files[0])).toEqual(['scorelib::f']);
+  });
+
+  it('is a no-op without a config, with no packages, or when no package imports a local one', () => {
+    const files = [callerFile('analytics/R/a.R'), provider('scorelib/R/s.R', ['f'])];
+    const before = [...files];
+    populate(files, null);
+    populate(files, config({}));
+    populate(files, config(pkgs, { analytics: { importFrom: [['dplyr', 'f']] } }));
+    populate(files, config(pkgs, { scorelib: { exports: ['f'] } }));
+    expect(files.every((f, i) => f === before[i])).toBe(true);
+  });
+
+  it("records each participating package's top-level names for the fallback veto", () => {
+    const cfg = config(pkgs, { analytics: { importFrom: [['scorelib', 'f']] } });
+    populate(
+      [
+        callerFile('analytics/R/a.R', 'run <- function() 1'),
+        provider('scorelib/R/s.R', ['f', 'g']),
+        provider('legacyscore/R/l.R', ['h']),
+      ],
+      cfg,
+    );
+    const recorded = rRecordedPackageTopLevelNames(cfg);
+    expect([
+      [...(recorded?.get('analytics') ?? [])],
+      [...(recorded?.get('scorelib') ?? [])].sort(),
+      recorded?.has('legacyscore'),
+    ]).toEqual([['run'], ['f', 'g'], false]);
+  });
+
+  // 75eaac75: an importFrom() that resolveRNamedImport() rejects can never bind. A synthesised
+  // import for it would stay unresolved yet count as an explicit name claim, suppressing the
+  // documented 0.5-confidence `global-name-fallback`. Only `populate*` is exercised here, so
+  // these fail if the skip is removed (the integration suite used to be the only pin).
+  describe('skips importFrom() entries that can never bind', () => {
+    const wholePkg = (entries: readonly string[], provided: string[], exports?: string[]) => {
+      const files = [callerFile('analytics/R/a.R'), provider('scorelib/R/s.R', provided)];
+      populate(
+        files,
+        config(pkgs, {
+          analytics: { importFrom: entries.map((n) => ['scorelib', n] as const) },
+          ...(exports === undefined ? {} : { scorelib: { exports } }),
+        }),
+      );
+      return namedImportsOf(files[0]);
+    };
+
+    it('positive control: an exported, top-level, undotted name still binds', () => {
+      expect(wholePkg(['tidy_scores'], ['tidy_scores'], ['tidy_scores'])).toEqual([
+        'scorelib::tidy_scores',
+      ]);
+    });
+
+    it('skips a name the provider NAMESPACE does not export', () => {
+      expect(wholePkg(['hidden_fn'], ['hidden_fn', 'tidy_scores'], ['tidy_scores'])).toEqual([]);
+    });
+
+    it('skips a name no provider file defines at top level', () => {
+      expect(
+        wholePkg(['never_defined'], ['tidy_scores'], ['never_defined', 'tidy_scores']),
+      ).toEqual([]);
+    });
+
+    it('skips a dotted name, even when the provider exports and defines it', () => {
+      expect(wholePkg(['my.helper'], ['my.helper'], ['my.helper'])).toEqual([]);
+    });
+
+    it('skips a name defined beside a dotted S3-style def of the same tail', () => {
+      // finalize would index `print.tidy` under `tidy` and bind the wrong def.
+      expect(wholePkg(['tidy'], ['tidy', 'print.tidy'], ['tidy'])).toEqual([]);
+    });
+
+    it('skips only the unbindable entries and keeps the bindable ones', () => {
+      expect(
+        wholePkg(
+          ['tidy_scores', 'hidden_fn', 'never_defined', 'my.helper', 'tidy'],
+          ['tidy_scores', 'hidden_fn', 'my.helper', 'tidy', 'print.tidy'],
+          ['tidy_scores', 'never_defined', 'my.helper', 'tidy'],
+        ),
+      ).toEqual(['scorelib::tidy_scores']);
+    });
+
+    it('is decided against the files supplied, so a missing provider file drops the import', () => {
+      const files = [callerFile('analytics/R/a.R')];
+      populate(files, config(pkgs, { analytics: { importFrom: [['scorelib', 'tidy_scores']] } }));
+      expect(namedImportsOf(files[0])).toEqual([]);
+    });
+  });
+
+  it('records nothing for an unrelated config object', () => {
+    expect(rRecordedPackageTopLevelNames(config(pkgs))).toBeUndefined();
+    expect(rRecordedPackageTopLevelNames(undefined)).toBeUndefined();
+  });
+});
+
+// ─── resolveRImportTarget: named branch ─────────────────────────────────────
+
+describe('resolveRImportTarget — named imports (NAMESPACE importFrom)', () => {
+  const namedImport = (pkg: string, name: string): ParsedImport => ({
+    kind: 'named',
+    localName: name,
+    importedName: name,
+    targetRaw: pkg,
+  });
+
+  interface Setup {
+    readonly cfg: RPackageConfig;
+    readonly files: ParsedFile[];
+  }
+
+  /** scorelib provider files (source per path) plus a caller file. */
+  function setup(
+    providerSources: Record<string, string>,
+    ns: NsSpec | undefined,
+    dir = 'scorelib',
+  ): Setup {
+    const files = [
+      parse('run <- function() 1', 'analytics/R/use.R'),
+      ...Object.entries(providerSources).map(([p, src]) => parse(src, p)),
+    ];
+    return {
+      cfg: config(
+        { analytics: 'analytics', scorelib: dir },
+        ns === undefined ? {} : { scorelib: ns },
+      ),
+      files,
+    };
+  }
+
+  const resolve = (s: Setup, pkg: string, name: string) =>
+    resolveRImportTarget(pkg, 'analytics/R/use.R', new Set(s.files.map((f) => f.filePath)), s.cfg, {
+      parsedFiles: s.files,
+      parsedImport: namedImport(pkg, name),
+    });
+
+  const F = 'scorelib/R/s.R';
+
+  it('returns nothing for an external package', () => {
+    const s = setup({ [F]: 'mutate <- function(d) d' }, { exports: ['mutate'] });
+    expect(resolve(s, 'dplyr', 'mutate')).toBeNull();
+  });
+
+  it('returns nothing without a package config', () => {
+    const s = setup({ [F]: 'f <- function(d) d' }, undefined);
+    expect(
+      resolveRImportTarget('scorelib', 'analytics/R/use.R', new Set([F]), undefined, {
+        parsedFiles: s.files,
+        parsedImport: namedImport('scorelib', 'f'),
+      }),
+    ).toBeNull();
+  });
+
+  it('returns nothing when the local package has no definition of the name', () => {
+    const s = setup({ [F]: 'other <- function(d) d' }, { exports: ['f', 'other'] });
+    expect(resolve(s, 'scorelib', 'f')).toBeNull();
+  });
+
+  it('returns only the files that define the name at top level', () => {
+    const s = setup(
+      {
+        [F]: 'f <- function(d) d',
+        'scorelib/R/t.R': 'g <- function(d) d',
+        'scorelib/R/u.R': 'f <- function(d) d',
+      },
+      { exports: ['f', 'g'] },
+    );
+    expect(resolve(s, 'scorelib', 'f')).toEqual([F, 'scorelib/R/u.R']);
+  });
+
+  it('ignores same-named definitions outside the package R/ directory and in other packages', () => {
+    const s = setup(
+      {
+        'scorelib/scripts/x.R': 'f <- function(d) d',
+        'legacyscore/R/l.R': 'f <- function(d) d',
+      },
+      { exports: ['f'] },
+    );
+    expect(resolve(s, 'scorelib', 'f')).toBeNull();
+  });
+
+  it('does not bind an R6 method, nor a nested function, as a top-level definition', () => {
+    const s = setup(
+      {
+        [F]: [
+          'Scorer <- R6::R6Class("Scorer", public = list(method_only = function(d) d))',
+          'host <- function(d) { nested_only <- function(y) y; nested_only(d) }',
+        ].join('\n'),
+      },
+      { exports: ['method_only', 'nested_only'] },
+    );
+    expect([resolve(s, 'scorelib', 'method_only'), resolve(s, 'scorelib', 'nested_only')]).toEqual([
+      null,
+      null,
+    ]);
+  });
+
+  it('resolves an R6 class defined at top level', () => {
+    const s = setup(
+      { [F]: 'Scorer <- R6::R6Class("Scorer", public = list())' },
+      { exports: ['Scorer'] },
+    );
+    expect(resolve(s, 'scorelib', 'Scorer')).toEqual([F]);
+  });
+
+  it('strips quotes around the package name', () => {
+    const s = setup({ [F]: 'f <- function(d) d' }, { exports: ['f'] });
+    expect(resolve(s, '"scorelib"', 'f')).toEqual([F]);
+  });
+
+  describe('dotted-name guards', () => {
+    it('refuses a dotted importedName (finalize can never bind it)', () => {
+      const s = setup(
+        { [F]: 'normalise.scores <- function(d) d' },
+        { exports: ['normalise.scores'] },
+      );
+      expect(resolve(s, 'scorelib', 'normalise.scores')).toBeNull();
+    });
+
+    it('refuses tidy when print.tidy is defined BEFORE it in the same file', () => {
+      const s = setup(
+        { [F]: 'print.tidy <- function(x) x\ntidy <- function(d) d' },
+        { exports: ['tidy'] },
+      );
+      expect(resolve(s, 'scorelib', 'tidy')).toBeNull();
+    });
+
+    it('refuses tidy when print.tidy is defined AFTER it too (order-blind, conservative)', () => {
+      const s = setup(
+        { [F]: 'tidy <- function(d) d\nprint.tidy <- function(x) x' },
+        { exports: ['tidy'] },
+      );
+      expect(resolve(s, 'scorelib', 'tidy')).toBeNull();
+    });
+
+    it('does not fire for an underscore name in the same file as dotted defs', () => {
+      const s = setup(
+        { [F]: 'print.tidy <- function(x) x\nplain_fn <- function(d) d' },
+        { exports: ['plain_fn'] },
+      );
+      expect(resolve(s, 'scorelib', 'plain_fn')).toEqual([F]);
+    });
+
+    it('does not fire when the dotted def sits in a different file from the definition', () => {
+      const s = setup(
+        {
+          [F]: 'tidy <- function(d) d',
+          'scorelib/R/t.R': 'print.tidy <- function(x) x',
+        },
+        { exports: ['tidy'] },
+      );
+      expect(resolve(s, 'scorelib', 'tidy')).toEqual([F]);
+    });
+
+    it('does not fire for a same-named R6 method (only Module-scope bindings count)', () => {
+      const s = setup(
+        {
+          [F]: [
+            'Scorer <- R6::R6Class("Scorer", public = list(tidy = function(d) d))',
+            'tidy <- function(d) d',
+          ].join('\n'),
+        },
+        { exports: ['tidy'] },
+      );
+      expect(resolve(s, 'scorelib', 'tidy')).toEqual([F]);
+    });
+  });
+
+  describe('NAMESPACE export check', () => {
+    const src = 'f <- function(d) d\nhidden <- function(d) d\n`%+%` <- function(a, b) a';
+
+    it('resolves a name listed in export()', () => {
+      const s = setup({ [F]: src }, { exports: ['f'] });
+      expect(resolve(s, 'scorelib', 'f')).toEqual([F]);
+    });
+
+    it('refuses a defined name the provider NAMESPACE does not export', () => {
+      const s = setup({ [F]: src }, { exports: ['f'] });
+      expect(resolve(s, 'scorelib', 'hidden')).toBeNull();
+    });
+
+    it('resolves a name matched by an exportPattern()', () => {
+      const s = setup({ [F]: src }, { exportPatterns: [/^hid/] });
+      expect(resolve(s, 'scorelib', 'hidden')).toEqual([F]);
+    });
+
+    it('matches a backticked export() entry against the unquoted name (backticks stripped)', () => {
+      const s = setup({ [F]: src }, { exports: ['`%+%`'] });
+      // Export check passes; the def keeps its backticks, so the lookup ends with no file.
+      expect(resolve(s, 'scorelib', '%+%')).toBeNull();
+      const t = setup({ [F]: 'g <- function(d) d' }, { exports: ['`g`'] });
+      expect(resolve(t, 'scorelib', 'g')).toEqual([F]);
+    });
+
+    it('treats a package without a NAMESPACE file as exporting everything', () => {
+      const s = setup({ [F]: src }, undefined);
+      expect(resolve(s, 'scorelib', 'hidden')).toEqual([F]);
+    });
+
+    it('treats a package whose NAMESPACE entry is absent as exporting everything', () => {
+      const s = setup({ [F]: src }, { none: true });
+      expect(resolve(s, 'scorelib', 'hidden')).toEqual([F]);
+    });
+
+    it('checks a root-level provider package (dir "")', () => {
+      const files = [
+        parse('run <- function() 1', 'analytics/R/use.R'),
+        parse('f <- function(d) d\nhidden <- function(d) d', 'R/s.R'),
+      ];
+      const cfg = config({ analytics: 'analytics', rootpkg: '' }, { rootpkg: { exports: ['f'] } });
+      const ask = (name: string) =>
+        resolveRImportTarget('rootpkg', 'analytics/R/use.R', new Set(), cfg, {
+          parsedFiles: files,
+          parsedImport: namedImport('rootpkg', name),
+        });
+      expect([ask('f'), ask('hidden')]).toEqual([['R/s.R'], null]);
+    });
+
+    const compiled = (pattern: string): RExportMatcher => {
+      const re = compileRExportPattern(pattern);
+      if (!re) throw new Error(`exportPattern did not compile: ${pattern}`);
+      return re;
+    };
+
+    it('resolves a name matched by a POSIX-class exportPattern (the RStudio default)', () => {
+      // `exportPattern("^[[:alpha:]]+")` used to compile to a JS RegExp that matched nothing, so
+      // every name was judged non-exported and the import degraded to the baseline name-guess.
+      // Deliberate change: POSIX classes are translated by `compileRExportPattern`.
+      const s = setup(
+        { [F]: 'tidy_scores <- function(d) d' },
+        {
+          exportPatterns: [compiled('^[[:alpha:]]+')],
+        },
+      );
+      expect(resolve(s, 'scorelib', 'tidy_scores')).toEqual([F]);
+    });
+
+    it('still refuses a name the POSIX-class exportPattern does not match', () => {
+      const s = setup(
+        { [F]: 'hidden <- function(d) d' },
+        {
+          exportPatterns: [compiled('^[[:upper:]]+$')],
+        },
+      );
+      expect(resolve(s, 'scorelib', 'hidden')).toBeNull();
+      // Control: the same definition resolves when the package exports everything.
+      const t = setup({ [F]: 'hidden <- function(d) d' }, undefined);
+      expect(resolve(t, 'scorelib', 'hidden')).toEqual([F]);
+    });
+  });
+
+  describe('workspace file index', () => {
+    it('builds no file index for named imports (the file Set is never traversed)', () => {
+      const s = setup({ [F]: 'f <- function(d) d' }, { exports: ['f'] });
+      const paths = new CountingSet(s.files.map((f) => f.filePath));
+      for (let i = 0; i < 25; i++) {
+        resolveRImportTarget('scorelib', 'analytics/R/use.R', paths, s.cfg, {
+          parsedFiles: s.files,
+          parsedImport: namedImport('scorelib', 'f'),
+        });
+        resolveRImportTarget('dplyr', 'analytics/R/use.R', paths, s.cfg, {
+          parsedFiles: s.files,
+          parsedImport: namedImport('dplyr', 'f'),
+        });
+      }
+      expect(paths.scans).toBe(0);
+    });
+
+    it('still builds one memoised index for wildcard imports', () => {
+      const s = setup({ [F]: 'f <- function(d) d' }, { exports: ['f'] });
+      const paths = new CountingSet(s.files.map((f) => f.filePath));
+      for (let i = 0; i < 25; i++) {
+        resolveRImportTarget('scorelib', 'analytics/R/use.R', paths, s.cfg, {
+          parsedFiles: s.files,
+          parsedImport: { kind: 'wildcard', targetRaw: 'scorelib' },
+        });
+      }
+      expect(paths.scans).toBe(1);
+    });
+
+    it('indexes the parsed files once for many named imports', () => {
+      const s = setup({ [F]: 'f <- function(d) d\ng <- function(d) d' }, { exports: ['f', 'g'] });
+      const first = resolve(s, 'scorelib', 'f');
+      const second = resolve(s, 'scorelib', 'f');
+      expect(second).toBe(first);
+    });
+  });
+
+  describe('non-named kinds and context-less calls', () => {
+    it('leaves a wildcard import of an external package unresolved', () => {
+      const s = setup({ [F]: 'f <- function(d) d' }, { exports: ['f'] });
+      expect(
+        resolveRImportTarget('dplyr', 'analytics/R/use.R', new Set([F]), s.cfg, {
+          parsedFiles: s.files,
+          parsedImport: { kind: 'wildcard', targetRaw: 'dplyr' },
+        }),
+      ).toBeNull();
+    });
+
+    it('resolves a wildcard import of a local package to all its R/ files, unchanged', () => {
+      const s = setup(
+        { [F]: 'f <- function(d) d', 'scorelib/R/t.R': 'g <- function(d) d' },
+        { exports: ['f'] },
+      );
+      expect(
+        resolveRImportTarget(
+          'scorelib',
+          'analytics/R/use.R',
+          new Set(s.files.map((f) => f.filePath)),
+          s.cfg,
+          { parsedFiles: s.files, parsedImport: { kind: 'wildcard', targetRaw: 'scorelib' } },
+        ),
+      ).toEqual([F, 'scorelib/R/t.R']);
+    });
+
+    it('a context-less call is treated as before (suffix resolution, no named branch)', () => {
+      const s = setup({ [F]: 'f <- function(d) d' }, { exports: ['f'] });
+      expect(
+        resolveRImportTarget(
+          'scorelib',
+          'analytics/R/use.R',
+          new Set(s.files.map((f) => f.filePath)),
+          s.cfg,
+        ),
+      ).toEqual([F]);
+    });
+  });
+});
+
+// ─── isRGlobalNameFallbackPlausible (truth table T1-T11) ────────────────────
+
+describe('isRGlobalNameFallbackPlausible — global-name guess veto', () => {
+  const pkgs = {
+    analytics: 'analytics',
+    scorelib: 'scorelib',
+    legacyscore: 'legacyscore',
+    corelib: 'corelib',
+  };
+  const def = (path: string, names: string[]) =>
+    parse(names.map((n) => `${n} <- function(d) d`).join('\n'), path);
+
+  /**
+   * Runs the real `populateRNamespaceImports` (which records the per-package top-level names the
+   * veto reads) over `files`, then asks the veto about a call to `name` in `callerFile` whose
+   * unique-name guess landed in `candidateFile`.
+   */
+  const verdict = (opts: {
+    importFrom: readonly (readonly [string, string])[];
+    files: readonly ParsedFile[];
+    callerFile?: string;
+    candidateFile: string;
+    name: string;
+    packages?: Record<string, string>;
+    rawQualifiedName?: string;
+    skipPopulate?: boolean;
+  }): boolean => {
+    const cfg = config(opts.packages ?? pkgs, {
+      analytics: { importFrom: opts.importFrom },
+      scorelib: { exports: ['f', 'tidy_scores', 'reexp_fn'] },
+      legacyscore: { exports: ['f', 'tidy_scores', 'mutate'] },
+      corelib: { exports: ['f', 'reexp_fn'] },
+    });
+    const files = [...opts.files];
+    if (opts.skipPopulate !== true) populate(files, cfg);
+    return isRGlobalNameFallbackPlausible({
+      callerParsed: { filePath: opts.callerFile ?? 'analytics/R/use.R' },
+      candidate: { filePath: opts.candidateFile },
+      resolutionConfig: cfg,
+      site: { name: opts.name, rawQualifiedName: opts.rawQualifiedName },
+    });
+  };
+
+  const caller = () => def('analytics/R/use.R', ['run_all']);
+
+  it('T1: allows a candidate in the caller own package (own namespace masks; stays a fallback edge)', () => {
+    expect(
+      verdict({
+        importFrom: [['dplyr', 'filter']],
+        files: [caller(), def('analytics/R/own.R', ['filter'])],
+        candidateFile: 'analytics/R/own.R',
+        name: 'filter',
+      }),
+    ).toBe(true);
+  });
+
+  it('T2: vetoes a decoy in another local package when the name is imported from an external package', () => {
+    expect(
+      verdict({
+        importFrom: [['dplyr', 'mutate']],
+        files: [caller(), def('legacyscore/R/l.R', ['mutate'])],
+        candidateFile: 'legacyscore/R/l.R',
+        name: 'mutate',
+      }),
+    ).toBe(false);
+  });
+
+  it('T3a: vetoes a candidate in a third local package when the provider package defines the name', () => {
+    const files = [
+      caller(),
+      def('scorelib/R/s.R', ['tidy_scores']),
+      def('legacyscore/R/l.R', ['tidy_scores']),
+    ];
+    expect(
+      verdict({
+        importFrom: [['scorelib', 'tidy_scores']],
+        files,
+        candidateFile: 'legacyscore/R/l.R',
+        name: 'tidy_scores',
+      }),
+    ).toBe(false);
+  });
+
+  it('T3b: allows the candidate that lives in the imported-from package itself', () => {
+    const files = [
+      caller(),
+      def('scorelib/R/s.R', ['tidy_scores']),
+      def('legacyscore/R/l.R', ['tidy_scores']),
+    ];
+    expect(
+      verdict({
+        importFrom: [['scorelib', 'tidy_scores']],
+        files,
+        candidateFile: 'scorelib/R/s.R',
+        name: 'tidy_scores',
+      }),
+    ).toBe(true);
+  });
+
+  it('T4: allows the origin package when a local provider re-exports the name (it defines none)', () => {
+    expect(
+      verdict({
+        importFrom: [['scorelib', 'reexp_fn']],
+        files: [caller(), def('scorelib/R/s.R', ['other_fn']), def('corelib/R/c.R', ['reexp_fn'])],
+        candidateFile: 'corelib/R/c.R',
+        name: 'reexp_fn',
+      }),
+    ).toBe(true);
+  });
+
+  it('T4 (undecidable): allows when no per-package names were recorded for the provider', () => {
+    expect(
+      verdict({
+        importFrom: [['scorelib', 'f']],
+        files: [caller(), def('scorelib/R/s.R', ['f']), def('legacyscore/R/l.R', ['f'])],
+        candidateFile: 'legacyscore/R/l.R',
+        name: 'f',
+        skipPopulate: true,
+      }),
+    ).toBe(true);
+  });
+
+  describe('duplicate importFrom() entries: only the LAST entry counts', () => {
+    const files = () => [caller(), def('scorelib/R/s.R', ['f']), def('legacyscore/R/l.R', ['f'])];
+
+    it('T5a: external package last (scorelib, then dplyr) vetoes the candidate in scorelib', () => {
+      expect(
+        verdict({
+          importFrom: [
+            ['scorelib', 'f'],
+            ['dplyr', 'f'],
+          ],
+          files: files(),
+          candidateFile: 'scorelib/R/s.R',
+          name: 'f',
+        }),
+      ).toBe(false);
+    });
+
+    it('T5b: local package last (dplyr, then scorelib) vetoes a candidate in a third package', () => {
+      expect(
+        verdict({
+          importFrom: [
+            ['dplyr', 'f'],
+            ['scorelib', 'f'],
+          ],
+          files: files(),
+          candidateFile: 'legacyscore/R/l.R',
+          name: 'f',
+        }),
+      ).toBe(false);
+    });
+
+    it('T5c: local package last allows the candidate in that package', () => {
+      expect(
+        verdict({
+          importFrom: [
+            ['dplyr', 'f'],
+            ['scorelib', 'f'],
+          ],
+          files: files(),
+          candidateFile: 'scorelib/R/s.R',
+          name: 'f',
+        }),
+      ).toBe(true);
+    });
+  });
+
+  it('T6a: allows a candidate outside every package R/ directory (scripts/)', () => {
+    expect(
+      verdict({
+        importFrom: [['dplyr', 'mutate']],
+        files: [caller(), def('analytics/scripts/x.R', ['mutate'])],
+        candidateFile: 'analytics/scripts/x.R',
+        name: 'mutate',
+      }),
+    ).toBe(true);
+  });
+
+  it('T6b: allows any candidate when the caller file is outside the package R/ directory', () => {
+    for (const callerFile of [
+      'analytics/tests/testthat/test-x.R',
+      'analytics/scripts/run.R',
+      'plumber.R',
+    ]) {
+      expect(
+        verdict({
+          importFrom: [['dplyr', 'mutate']],
+          files: [def('legacyscore/R/l.R', ['mutate'])],
+          callerFile,
+          candidateFile: 'legacyscore/R/l.R',
+          name: 'mutate',
+        }),
+      ).toBe(true);
+    }
+  });
+
+  it('T7 (known limitation): a later import(corelib) is not tokenised, so the candidate in corelib is still vetoed', () => {
+    // NAMESPACE: importFrom(scorelib, f) then import(corelib). R would take the later binding;
+    // `import()` is dropped by the parser, so only the importFrom entry exists.
+    expect(
+      verdict({
+        importFrom: [['scorelib', 'f']],
+        files: [caller(), def('scorelib/R/s.R', ['f']), def('corelib/R/c.R', ['f'])],
+        candidateFile: 'corelib/R/c.R',
+        name: 'f',
+      }),
+    ).toBe(false);
+  });
+
+  it('T8: allows everything for a self-import (nothing is imported)', () => {
+    expect(
+      verdict({
+        importFrom: [['analytics', 'f']],
+        files: [caller(), def('legacyscore/R/l.R', ['f'])],
+        candidateFile: 'legacyscore/R/l.R',
+        name: 'f',
+      }),
+    ).toBe(true);
+  });
+
+  it('T9: allows a call whose name has no importFrom() entry', () => {
+    expect(
+      verdict({
+        importFrom: [['scorelib', 'f']],
+        files: [caller(), def('scorelib/R/s.R', ['f']), def('legacyscore/R/l.R', ['g'])],
+        candidateFile: 'legacyscore/R/l.R',
+        name: 'g',
+      }),
+    ).toBe(true);
+  });
+
+  describe('T10: cannot decide', () => {
+    const ctx = (resolutionConfig: unknown) => ({
+      callerParsed: { filePath: 'analytics/R/use.R' },
+      candidate: { filePath: 'legacyscore/R/l.R' },
+      resolutionConfig,
+      site: { name: 'mutate' },
+    });
+
+    it('allows without a resolution config, and for a config of an unexpected shape', () => {
+      expect([
+        isRGlobalNameFallbackPlausible(ctx(undefined)),
+        isRGlobalNameFallbackPlausible(ctx(null)),
+        isRGlobalNameFallbackPlausible(ctx({})),
+        isRGlobalNameFallbackPlausible(ctx('nope')),
+      ]).toEqual([true, true, true, true]);
+    });
+
+    it('allows when the caller package has no NAMESPACE entry', () => {
+      expect(
+        isRGlobalNameFallbackPlausible(ctx(config(pkgs, { legacyscore: { exports: ['mutate'] } }))),
+      ).toBe(true);
+    });
+
+    it('allows a caller file that belongs to no package', () => {
+      const cfg = config(pkgs, { analytics: { importFrom: [['dplyr', 'mutate']] } });
+      expect(
+        isRGlobalNameFallbackPlausible({ ...ctx(cfg), callerParsed: { filePath: 'other/R/x.R' } }),
+      ).toBe(true);
+    });
+  });
+
+  it('T11 (qualifier flip): allows the correct legacyscore::mutate() edge — the qualifier names the candidate package', () => {
+    expect(
+      verdict({
+        importFrom: [['dplyr', 'mutate']],
+        files: [caller(), def('legacyscore/R/l.R', ['mutate'])],
+        candidateFile: 'legacyscore/R/l.R',
+        name: 'mutate',
+        rawQualifiedName: 'legacyscore::mutate',
+      }),
+    ).toBe(true);
+  });
+
+  it('handles a root-level caller package (dir "")', () => {
+    const packages = { rootpkg: '', legacyscore: 'legacyscore' };
+    const cfg = config(packages, { rootpkg: { importFrom: [['dplyr', 'mutate']] } });
+    const ask = (callerFile: string) =>
+      isRGlobalNameFallbackPlausible({
+        callerParsed: { filePath: callerFile },
+        candidate: { filePath: 'legacyscore/R/l.R' },
+        resolutionConfig: cfg,
+        site: { name: 'mutate' },
+      });
+    expect([ask('R/use.R'), ask('tests/testthat/test-x.R')]).toEqual([false, true]);
+  });
+});
diff --git a/gitnexus/test/unit/scope-resolution/r/r-qualified-call-populate.test.ts b/gitnexus/test/unit/scope-resolution/r/r-qualified-call-populate.test.ts
new file mode 100644
index 000000000..a937e8aac
--- /dev/null
+++ b/gitnexus/test/unit/scope-resolution/r/r-qualified-call-populate.test.ts
@@ -0,0 +1,65 @@
+/**
+ * `populateRQualifiedCalls` attributes a local package's top-level definitions to the files of
+ * that package. A package known only from a `<name>/R/` directory owns the files under it, but
+ * never a file a discovered package owns, whatever that directory is called.
+ */
+import { describe, expect, it } from 'vitest';
+import type { ParsedFile, SymbolDefinition } from 'gitnexus-shared';
+import type { RPackageConfig } from '../../../../src/core/ingestion/languages/r/package-config.js';
+import {
+  populateRQualifiedCalls,
+  resolveRQualifiedFreeCall,
+} from '../../../../src/core/ingestion/languages/r/qualified-call.js';
+
+const callSite = {
+  kind: 'call',
+  name: 'helper',
+  rawQualifiedName: 'foo::helper',
+  atRange: { startLine: 3, startCol: 2, endLine: 3, endCol: 16 },
+};
+
+function definition(filePath: string): SymbolDefinition {
+  return { nodeId: `Function:${filePath}:helper`, filePath, type: 'Function' } as SymbolDefinition;
+}
+
+/** A file whose Module scope binds `helper` as a local top-level function. */
+function definingFile(filePath: string): ParsedFile {
+  const def = definition(filePath);
+  return {
+    filePath,
+    moduleScope: 'module',
+    scopes: [{ id: 'module', bindings: new Map([['helper', [{ origin: 'local', def }]]]) }],
+    referenceSites: [],
+  } as unknown as ParsedFile;
+}
+
+function callerFile(filePath: string): ParsedFile {
+  return {
+    filePath,
+    moduleScope: 'module',
+    scopes: [{ id: 'module', bindings: new Map() }],
+    referenceSites: [callSite],
+  } as unknown as ParsedFile;
+}
+
+describe('populateRQualifiedCalls: <name>/R/ ownership', () => {
+  it('binds `foo::helper` to the undiscovered foo/R/ package, not to a discovered package in a directory named foo', () => {
+    // Discovery found `Package: bar` in pkgs/foo; x/foo/R/ has no DESCRIPTION, so `foo` is a
+    // package only through its directory name.
+    const cfg: RPackageConfig = {
+      packages: new Map([['bar', 'pkgs/foo']]),
+      namespaceInfoByPackageDir: new Map(),
+      truncated: false,
+    };
+    const parsedFiles = [
+      definingFile('pkgs/foo/R/a.R'),
+      definingFile('x/foo/R/b.R'),
+      callerFile('scripts/use.R'),
+    ];
+    populateRQualifiedCalls(parsedFiles, { resolutionConfig: cfg });
+
+    const caller = parsedFiles[2];
+    expect(caller.referenceSites).toHaveLength(1); // not dropped as a duplicate definition
+    expect(resolveRQualifiedFreeCall(callSite, caller)?.filePath).toBe('x/foo/R/b.R');
+  });
+});
diff --git a/gitnexus/test/unit/scope-resolution/r/r-qualified-call.test.ts b/gitnexus/test/unit/scope-resolution/r/r-qualified-call.test.ts
new file mode 100644
index 000000000..61947500b
--- /dev/null
+++ b/gitnexus/test/unit/scope-resolution/r/r-qualified-call.test.ts
@@ -0,0 +1,509 @@
+/**
+ * R qualified-call helpers:
+ *
+ *  - `parseRQualifier(raw)`: the package named by a `@reference.qualified-name` text;
+ *  - `rQualifierLocality(pkg, cfg, filePaths)`: `local` | `external` | `unknown`;
+ *  - `loadRPackageConfig` sets `RPackageConfig.truncated` only when a subtree its depth-3 /
+ *    200-directory walk skipped may hide an undiscovered package (or a directory of the walk
+ *    is unreadable); skipped subtrees without a package do not truncate;
+ *  - the global-name-fallback veto's qualifier rule (`isRGlobalNameFallbackPlausible`).
+ */
+import { describe, expect, it, vi } from 'vitest';
+import { cleanupTempDirSync } from '../../../helpers/test-db.js';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import type { RPackageConfig } from '../../../../src/core/ingestion/languages/r/package-config.js';
+import {
+  hidesUndiscoveredPackage,
+  loadRPackageConfig,
+} from '../../../../src/core/ingestion/languages/r/package-config.js';
+import {
+  parseRQualifier,
+  rQualifierLocality,
+  type RQualifierLocality,
+} from '../../../../src/core/ingestion/languages/r/qualified-call.js';
+import {
+  isRGlobalNameFallbackPlausible,
+  rRecordQualifiedDefinitionCounts,
+} from '../../../../src/core/ingestion/languages/r/namespace-imports.js';
+
+type Locality = RQualifierLocality;
+
+const FIXTURES = path.resolve(__dirname, '..', '..', '..', 'fixtures', 'lang-resolution');
+
+function config(packages: Record<string, string>, truncated?: boolean): RPackageConfig {
+  const cfg: RPackageConfig = {
+    packages: new Map(Object.entries(packages)),
+    namespaceInfoByPackageDir: new Map(),
+  };
+  return truncated === undefined ? cfg : { ...cfg, truncated };
+}
+
+describe('parseRQualifier', () => {
+  const cases: readonly (readonly [raw: string, expected: string | undefined])[] = [
+    ['pkg::f', 'pkg'],
+    ['pkg:::f', 'pkg'],
+    ['pkg ::: f', 'pkg'],
+    ['pkg  ::  f', 'pkg'],
+    ['"pkg"::f', 'pkg'],
+    ["'pkg'::f", 'pkg'],
+    ['`pkg`::f', 'pkg'],
+    ['my.pkg::f', 'my.pkg'],
+    ['not a qualifier', undefined],
+    ['::f', undefined],
+  ];
+
+  for (const [raw, expected] of cases) {
+    it(`${JSON.stringify(raw)} -> ${JSON.stringify(expected)}`, () => {
+      expect(parseRQualifier(raw)).toBe(expected);
+    });
+  }
+});
+
+describe('rQualifierLocality', () => {
+  const paths = (...p: string[]): ReadonlySet<string> => new Set(p);
+
+  const cases: readonly {
+    readonly title: string;
+    readonly pkg: string;
+    readonly cfg: RPackageConfig | null;
+    readonly files: ReadonlySet<string>;
+    readonly expected: Locality;
+  }[] = [
+    {
+      title: 'a package in the config is local',
+      pkg: 'renamed',
+      cfg: config({ renamed: 'renamed_impl' }),
+      files: paths('renamed_impl/R/a.R'),
+      expected: 'local',
+    },
+    {
+      title: 'a package in the config is local even when its discovery was truncated',
+      pkg: 'pkg',
+      cfg: config({ pkg: 'pkg' }, true),
+      files: paths('pkg/R/a.R'),
+      expected: 'local',
+    },
+    {
+      title: 'a root-level package is local through the config',
+      pkg: 'rootpkg',
+      cfg: config({ rootpkg: '' }),
+      files: paths('R/a.R'),
+      expected: 'local',
+    },
+    {
+      title: 'not in the config but a parsed file sits under <pkg>/R/ (no DESCRIPTION)',
+      pkg: 'pkgthird',
+      cfg: config({ pkgmain: 'pkgmain' }),
+      files: paths('pkgmain/R/a.R', 'pkgthird/R/t.R'),
+      expected: 'local',
+    },
+    {
+      title: 'the <pkg>/R/ segment may be nested below the repo root',
+      pkg: 'pathpkg',
+      cfg: config({ caller: 'caller' }, true),
+      files: paths('caller/R/a.R', 'deep/a/b/c/pathpkg/R/p.R'),
+      expected: 'local',
+    },
+    {
+      title: 'a path that merely contains the name is not a package directory',
+      pkg: 'path',
+      cfg: config({ caller: 'caller' }),
+      files: paths('caller/R/a.R', 'deep/pathpkg/R/p.R', 'x/path/scripts/s.R'),
+      expected: 'external',
+    },
+    {
+      title: 'not local and discovery completed: certainly external',
+      pkg: 'dplyr',
+      cfg: config({ caller: 'caller' }, false),
+      files: paths('caller/R/a.R'),
+      expected: 'external',
+    },
+    {
+      title: 'not local and the truncated flag is absent (complete discovery): external',
+      pkg: 'dplyr',
+      cfg: config({ caller: 'caller' }),
+      files: paths('caller/R/a.R'),
+      expected: 'external',
+    },
+    {
+      title: 'not local but discovery was truncated: unknown',
+      pkg: 'invisiblepkg',
+      cfg: config({ caller: 'caller' }, true),
+      files: paths('caller/R/a.R', 'deep/a/b/c/impl/R/x.R'),
+      expected: 'unknown',
+    },
+    {
+      title: 'no package config could be built: unknown',
+      pkg: 'dplyr',
+      cfg: null,
+      files: paths('R/a.R'),
+      expected: 'unknown',
+    },
+  ];
+
+  for (const c of cases) {
+    it(c.title, () => {
+      expect(rQualifierLocality(c.pkg, c.cfg, c.files)).toBe(c.expected);
+    });
+  }
+});
+
+describe('loadRPackageConfig: discovery completeness on the qualified-call fixtures', () => {
+  const load2 = (fixture: string) => loadRPackageConfig(path.join(FIXTURES, fixture));
+
+  // Permanent geometry checks: the fixtures really are shaped as the integration tests assume.
+  it('finds every package of r-qualified-calls, including a directory named differently', async () => {
+    const cfg = await load2('r-qualified-calls');
+    expect([...(cfg?.packages ?? [])].sort()).toEqual([
+      ['altlib', 'altlib'],
+      ['caller', 'caller'],
+      ['duplib', 'duplib'],
+      ['locallib', 'locallib'],
+      ['provlib', 'provlib'],
+      ['renamed', 'renamed_impl'],
+    ]);
+  });
+
+  it('does not find the packages nested below depth 3 in r-qualified-calls-truncated', async () => {
+    const cfg = await load2('r-qualified-calls-truncated');
+    expect([...(cfg?.packages ?? [])]).toEqual([['caller', 'caller']]);
+  });
+
+  it('truncated is false when the walk completed', async () => {
+    expect((await load2('r-qualified-calls'))?.truncated).toBe(false);
+  });
+
+  it('truncated is true when a skipped directory hides an undiscovered package', async () => {
+    // deep/a/b/c/impl holds `Package: invisiblepkg`, below the depth limit.
+    expect((await load2('r-qualified-calls-truncated'))?.truncated).toBe(true);
+  });
+
+  it('truncated is false when the skipped directories (tests/testthat/fixtures) hold no package', async () => {
+    const cfg = await load2('r-qualified-calls-deep-fixtures');
+    expect([...(cfg?.packages ?? [])]).toEqual([['deepcaller', 'caller']]);
+    expect(cfg?.truncated).toBe(false);
+  });
+});
+
+describe('loadRPackageConfig: zero packages found', () => {
+  async function withTree(build: (root: string) => Promise<void>) {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), 'r-no-description-'));
+    try {
+      await build(root);
+      return await loadRPackageConfig(root);
+    } finally {
+      cleanupTempDirSync(root);
+    }
+  }
+
+  it('returns a complete empty config when discovery finds no package', async () => {
+    const cfg = await loadRPackageConfig(path.join(FIXTURES, 'r-no-description'));
+    expect(cfg).not.toBeNull();
+    expect(cfg?.packages.size).toBe(0);
+    expect(cfg?.truncated).toBe(false);
+  });
+
+  it('keeps truncated set when no package is found but a skipped subtree hides one', async () => {
+    const cfg = await loadRPackageConfig(path.join(FIXTURES, 'r-no-description-truncated'));
+    expect(cfg?.packages.size).toBe(0);
+    expect(cfg?.truncated).toBe(true);
+  });
+
+  it('returns a complete empty config for an R-only temporary tree without DESCRIPTION', async () => {
+    const cfg = await withTree(async (root) => {
+      await fs.mkdir(path.join(root, 'R'));
+      await fs.writeFile(path.join(root, 'R', 'a.R'), 'f <- function() 1\n');
+    });
+    expect(cfg?.truncated).toBe(false);
+  });
+
+  it('rQualifierLocality: complete empty config proves external; truncated stays unknown', () => {
+    const empty = config({}, false);
+    expect(rQualifierLocality('dplyr', empty, new Set(['R/a.R']))).toBe('external');
+    expect(rQualifierLocality('dplyr', config({}, true), new Set(['R/a.R']))).toBe('unknown');
+    expect(rQualifierLocality('dplyr', null, new Set(['R/a.R']))).toBe('unknown');
+    // a <pkg>/R/ path still makes the package local without a DESCRIPTION
+    expect(rQualifierLocality('pathpkg', empty, new Set(['pathpkg/R/a.R']))).toBe('local');
+  });
+});
+
+describe('loadRPackageConfig: packageDirs', () => {
+  it('lists every directory with a Package: DESCRIPTION, including same-name copies and packages without a NAMESPACE', async () => {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), 'r-package-dirs-'));
+    try {
+      const write = async (rel: string, text: string): Promise<void> => {
+        await fs.mkdir(path.dirname(path.join(root, rel)), { recursive: true });
+        await fs.writeFile(path.join(root, rel), text);
+      };
+      await write('DESCRIPTION', 'Package: top\nVersion: 1.0\n');
+      await write('NAMESPACE', 'export(f)\n');
+      await write('a/dup/DESCRIPTION', 'Package: dup\nVersion: 1.0\n'); // wins the name, no NAMESPACE
+      await write('b/dup/DESCRIPTION', 'Package: dup\nVersion: 1.0\n'); // same-name copy that loses
+      await write('c/nodesc/README', 'not a package\n');
+      await write('d/nopkg/DESCRIPTION', 'Version: 1.0\n'); // no Package: line
+      const cfg = await loadRPackageConfig(root);
+      expect([...(cfg.packageDirs ?? [])].sort()).toEqual(['', 'a/dup', 'b/dup']);
+      expect([...cfg.packages].sort()).toEqual([
+        ['dup', 'a/dup'],
+        ['top', ''],
+      ]);
+    } finally {
+      cleanupTempDirSync(root);
+    }
+  });
+});
+
+describe('rQualifierLocality: a <name>/R/ directory is not evidence for a file a discovered package owns', () => {
+  it('does not make `foo` local from pkgs/foo/R/ when that directory is the package `bar`', () => {
+    const cfg = config({ bar: 'pkgs/foo' }, false);
+    expect(rQualifierLocality('foo', cfg, new Set(['pkgs/foo/R/x.R']))).toBe('external');
+    expect(rQualifierLocality('bar', cfg, new Set(['pkgs/foo/R/x.R']))).toBe('local');
+  });
+
+  it('applies to a same-name copy of a package that discovery did not register by name', () => {
+    const cfg: RPackageConfig = {
+      ...config({ bar: 'a/bar' }, false),
+      packageDirs: new Set(['a/bar', 'b/foo']),
+    };
+    expect(rQualifierLocality('foo', cfg, new Set(['b/foo/R/x.R']))).toBe('external');
+  });
+
+  it('still treats an undiscovered <name>/R/ directory as local', () => {
+    const cfg = config({ bar: 'pkgs/bar' }, false);
+    expect(rQualifierLocality('foo', cfg, new Set(['pkgs/foo/R/x.R', 'pkgs/bar/R/y.R']))).toBe(
+      'local',
+    );
+    expect(rQualifierLocality('foo', cfg, new Set(['pkgs\\foo\\R\\x.R']))).toBe('local');
+  });
+});
+
+describe('loadRPackageConfig: truncation only when a skipped subtree hides an undiscovered package', () => {
+  // Layout: root/DESCRIPTION (rootpkg). `skipDir` is the first directory below the depth-3
+  // limit: root(0) > a(1) > b(2) > c(3) lists d, which is skipped.
+  const SKIP = ['a', 'b', 'c', 'd'];
+
+  async function withRepo(
+    build: (root: string) => Promise<void>,
+  ): Promise<Awaited<ReturnType<typeof loadRPackageConfig>>> {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), 'r-truncated-hidden-'));
+    try {
+      await fs.writeFile(path.join(root, 'DESCRIPTION'), 'Package: rootpkg\n');
+      await build(root);
+      return await loadRPackageConfig(root);
+    } finally {
+      cleanupTempDirSync(root);
+    }
+  }
+
+  const writePkg = async (dir: string, name: string): Promise<void> => {
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(path.join(dir, 'DESCRIPTION'), `Package: ${name}\n`);
+  };
+
+  it('a skipped directory with no package inside is not truncated', async () => {
+    const cfg = await withRepo(async (root) => {
+      await fs.mkdir(path.join(root, ...SKIP, 'data', 'raw'), { recursive: true });
+      await fs.writeFile(path.join(root, ...SKIP, 'data', 'raw', 'x.csv'), 'a,b\n');
+    });
+    expect(cfg?.truncated).toBe(false);
+  });
+
+  it('a skipped subtree with a real package of an undiscovered name is truncated', async () => {
+    const cfg = await withRepo((root) => writePkg(path.join(root, ...SKIP, 'realpkg'), 'realpkg'));
+    expect(cfg?.truncated).toBe(true);
+  });
+
+  it('a skipped subtree with only a same-name copy of a discovered package is not truncated', async () => {
+    const cfg = await withRepo((root) => writePkg(path.join(root, ...SKIP, 'copy'), 'rootpkg'));
+    expect(cfg?.truncated).toBe(false);
+  });
+
+  it('a package at depth 5 (hidden below the skipped directory itself) is truncated', async () => {
+    const cfg = await withRepo((root) =>
+      writePkg(path.join(root, ...SKIP, 'e', 'deeppkg'), 'deeppkg'),
+    );
+    expect(cfg?.truncated).toBe(true);
+  });
+
+  it('a DESCRIPTION under node_modules, .git or .Rproj.user of a skipped subtree is ignored', async () => {
+    const cfg = await withRepo(async (root) => {
+      await writePkg(path.join(root, ...SKIP, 'node_modules', 'jspkg'), 'jspkg');
+      await writePkg(path.join(root, ...SKIP, '.git', 'gitpkg'), 'gitpkg');
+      await writePkg(path.join(root, ...SKIP, '.Rproj.user', 'rprojpkg'), 'rprojpkg');
+    });
+    expect(cfg?.truncated).toBe(false);
+  });
+
+  it('a package left in the queue when the 200-directory cap stops the walk is truncated', async () => {
+    const cfg = await withRepo(async (root) => {
+      for (let i = 0; i < 210; i++) await fs.mkdir(path.join(root, `filler${String(i)}`));
+      // Sorts last, so it is still queued when the cap is hit.
+      await writePkg(path.join(root, 'zz_hidden'), 'zzhidden');
+    });
+    expect(cfg?.truncated).toBe(true);
+  });
+
+  it('a skipped subtree larger than the 5000-directory budget is truncated', async () => {
+    const cfg = await withRepo(async (root) => {
+      const big = path.join(root, ...SKIP);
+      await fs.mkdir(big, { recursive: true });
+      await Promise.all(
+        Array.from({ length: 5001 }, (_, i) => fs.mkdir(path.join(big, `d${String(i)}`))),
+      );
+    });
+    expect(cfg?.truncated).toBe(true);
+  }, 30000);
+
+  // The read failure is injected rather than provoked with chmod(0o000): permission bits are a
+  // POSIX concept (Windows ignores them, root bypasses them), whereas the behaviour under test is
+  // "an I/O error while walking means the package set is incomplete".
+  function eacces(target: string): NodeJS.ErrnoException {
+    return Object.assign(new Error(`EACCES: permission denied, '${target}'`), { code: 'EACCES' });
+  }
+
+  it('an unreadable skipped directory is truncated', async () => {
+    const realReaddir = fs.readdir.bind(fs) as (...a: unknown[]) => Promise<unknown>;
+    const spy = vi
+      .spyOn(fs, 'readdir')
+      .mockImplementation(((dir: unknown, ...rest: unknown[]) =>
+        path.basename(String(dir)) === 'locked'
+          ? Promise.reject(eacces(String(dir)))
+          : realReaddir(dir, ...rest)) as unknown as typeof fs.readdir);
+    try {
+      const cfg = await withRepo(async (root) => {
+        await fs.mkdir(path.join(root, ...SKIP, 'locked'), { recursive: true });
+      });
+      expect(spy.mock.calls.some(([d]) => path.basename(String(d)) === 'locked')).toBe(true);
+      expect(cfg?.truncated).toBe(true);
+    } finally {
+      spy.mockRestore();
+    }
+  });
+
+  it('an unreadable DESCRIPTION is truncated, so its qualifier stays unknown', async () => {
+    const realReadFile = fs.readFile.bind(fs) as (...a: unknown[]) => Promise<unknown>;
+    const spy = vi
+      .spyOn(fs, 'readFile')
+      .mockImplementation(((file: unknown, ...rest: unknown[]) =>
+        path.basename(String(file)) === 'DESCRIPTION' &&
+        path.basename(path.dirname(String(file))) === 'sub'
+          ? Promise.reject(eacces(String(file)))
+          : realReadFile(file, ...rest)) as unknown as typeof fs.readFile);
+    try {
+      const cfg = await withRepo(async (root) => {
+        await writePkg(path.join(root, 'sub'), 'hiddenpkg');
+      });
+      expect(spy.mock.calls.some(([f]) => path.basename(String(f)) === 'DESCRIPTION')).toBe(true);
+      expect(cfg?.packages.has('hiddenpkg')).toBe(false);
+      expect(cfg?.truncated).toBe(true);
+      expect(rQualifierLocality('hiddenpkg', cfg as RPackageConfig, new Set())).toBe('unknown');
+    } finally {
+      spy.mockRestore();
+    }
+  });
+});
+
+describe('hidesUndiscoveredPackage', () => {
+  it('shares one budget across all roots (exceeded on the second root)', async () => {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), 'r-hidden-budget-'));
+    try {
+      const a = path.join(root, 'a');
+      const b = path.join(root, 'b');
+      for (const d of [a, b]) {
+        await fs.mkdir(path.join(d, 'x'), { recursive: true });
+      }
+      // Each root costs 2 directories (itself + x): 4 in total.
+      expect(await hidesUndiscoveredPackage([a, b], new Set(), 4)).toBe(false);
+      expect(await hidesUndiscoveredPackage([a, b], new Set(), 3)).toBe(true);
+    } finally {
+      cleanupTempDirSync(root);
+    }
+  });
+
+  it('a nonexistent root cannot be read: true', async () => {
+    expect(
+      await hidesUndiscoveredPackage([path.join(os.tmpdir(), 'r-no-such-dir-x9')], new Set()),
+    ).toBe(true);
+  });
+
+  it('no roots: false', async () => {
+    expect(await hidesUndiscoveredPackage([], new Set())).toBe(false);
+  });
+});
+
+describe('loadRPackageConfig: directory cap', () => {
+  it('truncated is false when the directories left queued by the 200-directory cap hold no package', async () => {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), 'r-cap-empty-'));
+    try {
+      await fs.writeFile(path.join(root, 'DESCRIPTION'), 'Package: rootpkg\n');
+      for (let i = 0; i < 210; i++) await fs.mkdir(path.join(root, `filler${String(i)}`));
+      const cfg = await loadRPackageConfig(root);
+      expect([...(cfg?.packages ?? [])]).toEqual([['rootpkg', '']]);
+      expect(cfg?.truncated).toBe(false);
+    } finally {
+      cleanupTempDirSync(root);
+    }
+  });
+});
+
+describe('isRGlobalNameFallbackPlausible: qualifier rule', () => {
+  const cfg: RPackageConfig = {
+    packages: new Map([
+      ['caller', 'caller'],
+      ['named', 'named'],
+      ['other', 'other'],
+    ]),
+    namespaceInfoByPackageDir: new Map([
+      [
+        'caller',
+        {
+          hasNamespaceFile: true,
+          namedExports: new Set(),
+          exportPatterns: [],
+          importFrom: [{ pkg: 'ext', name: 'mutate' }],
+        },
+      ],
+    ]),
+  };
+  const verdict = (qualified: string | undefined, candidate: string, config = cfg): boolean =>
+    isRGlobalNameFallbackPlausible({
+      callerParsed: { filePath: 'caller/R/a.R' },
+      candidate: { filePath: candidate },
+      resolutionConfig: config,
+      site: { name: 'mutate', rawQualifiedName: qualified },
+    });
+
+  it('allows a candidate inside the named local package (whatever importFrom says)', () => {
+    expect(verdict('named::mutate', 'named/R/m.R')).toBe(true);
+  });
+
+  it('vetoes a candidate elsewhere when the named package defines the name', () => {
+    rRecordQualifiedDefinitionCounts(cfg, new Map([['named', new Map([['mutate', 1]])]]));
+    expect(verdict('named::mutate', 'other/R/o.R')).toBe(false);
+  });
+
+  it('falls through to the NAMESPACE rules when the named package defines none (re-export)', () => {
+    rRecordQualifiedDefinitionCounts(cfg, new Map([['named', new Map()]]));
+    // importFrom(ext, mutate) + a candidate in a third package: today's importFrom veto.
+    expect(verdict('named::mutate', 'other/R/o.R')).toBe(false);
+    const noImportFrom: RPackageConfig = { ...cfg, namespaceInfoByPackageDir: new Map() };
+    rRecordQualifiedDefinitionCounts(noImportFrom, new Map([['named', new Map()]]));
+    expect(verdict('named::mutate', 'other/R/o.R', noImportFrom)).toBe(true);
+  });
+
+  it('falls through when no counts were recorded for the config', () => {
+    const fresh: RPackageConfig = { ...cfg };
+    expect(verdict('named::mutate', 'other/R/o.R', fresh)).toBe(false); // importFrom rule, as before
+  });
+
+  it('ignores a qualifier naming a package outside the config', () => {
+    expect(verdict('elsewhere::mutate', 'other/R/o.R')).toBe(false); // importFrom rule, as before
+  });
+
+  it('a site without a qualifier is judged by the NAMESPACE rules only', () => {
+    expect(verdict(undefined, 'other/R/o.R')).toBe(false);
+    expect(verdict(undefined, 'caller/R/c.R')).toBe(true);
+  });
+});
diff --git a/gitnexus/test/unit/scope-resolution/r/r-source-import-lookup.test.ts b/gitnexus/test/unit/scope-resolution/r/r-source-import-lookup.test.ts
new file mode 100644
index 000000000..9bb50c8d8
--- /dev/null
+++ b/gitnexus/test/unit/scope-resolution/r/r-source-import-lookup.test.ts
@@ -0,0 +1,117 @@
+/**
+ * R `source("file.R")` exact-path lookup. The live resolver answers it from the per-pass
+ * `normToRaw` map instead of `indexOf` over the whole file list for every `source()` call.
+ * The map must pick exactly the file `indexOf` picked (first in list order), so these cases
+ * compare both paths on the same corpus, including the duplicate-spelling and missing-file
+ * cases where an index could plausibly diverge, and pin that the hot path no longer scans.
+ */
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import {
+  resolveRImportInternal,
+  resolveRImportTarget,
+} from '../../../../src/core/ingestion/import-resolvers/r.js';
+import { getWorkspaceFileIndex } from '../../../../src/core/ingestion/import-resolvers/workspace-file-index.js';
+
+// Raw spellings: the Windows-style duplicate of 'pkg/R/dup.R' comes FIRST, so first-wins must
+// return the backslash spelling for both lookups.
+const FILES = [
+  'scripts\\win.R',
+  'pkg\\R\\dup.R',
+  'pkg/R/dup.R',
+  'pkg/R/a.R',
+  'pkg/R/b.R',
+  'scripts/run.R',
+  'scripts/helpers/util.R',
+  'util.R',
+  'vendor/other/util.R',
+  '/abs/root.R',
+];
+
+interface Case {
+  readonly title: string;
+  readonly from: string;
+  readonly raw: string;
+}
+
+const CASES: readonly Case[] = [
+  { title: 'relative, found beside the caller', from: 'pkg/R/a.R', raw: '"b.R"' },
+  { title: 'relative into a subdirectory', from: 'scripts/run.R', raw: '"helpers/util.R"' },
+  { title: 'relative with ../', from: 'scripts/helpers/x.R', raw: '"../run.R"' },
+  { title: 'duplicate spellings: first wins', from: 'pkg/R/a.R', raw: '"dup.R"' },
+  { title: 'backslash spelling of the file', from: 'scripts/x.R', raw: '"win.R"' },
+  { title: 'absolute, present', from: 'pkg/R/a.R', raw: '"/abs/root.R"' },
+  { title: 'absolute, absent', from: 'pkg/R/a.R', raw: '"/abs/missing.R"' },
+  { title: 'relative, absent: suffix fallback', from: 'pkg/R/a.R', raw: '"util.R"' },
+  { title: 'relative, absent everywhere', from: 'pkg/R/a.R', raw: '"nowhere.R"' },
+  { title: 'lowercase extension', from: 'pkg/R/a.R', raw: '"a.r"' },
+];
+
+const run = (c: Case, withMap: boolean): ReturnType<typeof resolveRImportInternal> => {
+  const { normalized, all, index, normToRaw } = getWorkspaceFileIndex(new Set(FILES));
+  return resolveRImportInternal(
+    c.from,
+    c.raw,
+    normalized,
+    all,
+    null,
+    index,
+    withMap ? normToRaw : undefined,
+  );
+};
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe('resolveRImportInternal: source() exact-path lookup', () => {
+  it.each(CASES)('$title: the index agrees with indexOf', (c) => {
+    expect(run(c, true)).toEqual(run(c, false));
+  });
+
+  it('positive controls: the corpus really exercises found, duplicate and missing files', () => {
+    const byTitle = (title: string) => run(CASES.find((c) => c.title === title)!, true);
+    expect(byTitle('relative, found beside the caller')).toBe('pkg/R/b.R');
+    expect(byTitle('duplicate spellings: first wins')).toBe('pkg\\R\\dup.R');
+    expect(byTitle('backslash spelling of the file')).toBe('scripts\\win.R');
+    expect(byTitle('absolute, present')).toBe('/abs/root.R');
+    expect(byTitle('absolute, absent')).toBeNull();
+    expect(byTitle('relative, absent everywhere')).toBeNull();
+  });
+
+  it('does not scan the file list for an exact hit when the index is supplied', () => {
+    const { normalized, all, index, normToRaw } = getWorkspaceFileIndex(new Set(FILES));
+    const indexOf = vi.spyOn(normalized, 'indexOf');
+    expect(
+      resolveRImportInternal('pkg/R/a.R', '"b.R"', normalized, all, null, index, normToRaw),
+    ).toBe('pkg/R/b.R');
+    expect(
+      resolveRImportInternal('pkg/R/a.R', '"/abs/root.R"', normalized, all, null, index, normToRaw),
+    ).toBe('/abs/root.R');
+    expect(indexOf).not.toHaveBeenCalled();
+  });
+
+  it('still scans (and agrees) when called without the index', () => {
+    const { normalized, all, index } = getWorkspaceFileIndex(new Set(FILES));
+    const indexOf = vi.spyOn(normalized, 'indexOf');
+    expect(resolveRImportInternal('pkg/R/a.R', '"b.R"', normalized, all, null, index)).toBe(
+      'pkg/R/b.R',
+    );
+    expect(indexOf).toHaveBeenCalled();
+  });
+});
+
+describe('resolveRImportTarget: source() through the live adapter', () => {
+  // `source()` carries no wildcard/named context, so the adapter takes the file-path branch.
+  it.each(CASES)('$title: matches the indexOf result', (c) => {
+    const viaAdapter = resolveRImportTarget(c.raw, c.from, new Set(FILES));
+    expect(viaAdapter).toEqual(run(c, false));
+  });
+
+  it('does not scan the file list on a repeat call for the same file set', () => {
+    const files = new Set(FILES);
+    resolveRImportTarget('"b.R"', 'pkg/R/a.R', files); // builds the per-set index
+    const indexOf = vi.spyOn(Array.prototype, 'indexOf');
+    expect(resolveRImportTarget('"b.R"', 'pkg/R/a.R', files)).toBe('pkg/R/b.R');
+    expect(indexOf.mock.calls.filter(([needle]) => needle === 'pkg/R/b.R')).toEqual([]);
+  });
+});
diff --git a/gitnexus/test/unit/scope-resolution/r/scope-function-anchors.test.ts b/gitnexus/test/unit/scope-resolution/r/scope-function-anchors.test.ts
new file mode 100644
index 000000000..22ed656af
--- /dev/null
+++ b/gitnexus/test/unit/scope-resolution/r/scope-function-anchors.test.ts
@@ -0,0 +1,429 @@
+/**
+ * R caller attribution: the R scope query must anchor
+ * `@scope.function` on the SAME AST node as `@declaration.function` (the whole
+ * `name <- function(...)` assignment) and `@declaration.method` (the
+ * `name = function(...)` argument), so a def is owned by its OWN Function scope.
+ * If the two anchors differ, the def is owned by the enclosing
+ * Module / outer-function / Class scope, and `resolveCallerGraphId` credits every
+ * call in a body to the FIRST callable that scope owns.
+ *
+ * Every `it` holds ONE assertion that compares a value, and the
+ * lookups never dereference a possibly-missing scope/def, so a failure is
+ * always a wrong VALUE, never a thrown TypeError.
+ *
+ * Positions: lines are 1-based, columns 0-based (the scope `Range` convention).
+ */
+import { describe, expect, it } from 'vitest';
+import type { ParsedFile, Range, Scope, SymbolDefinition } from 'gitnexus-shared';
+import { extractParsedFile } from '../../../../src/core/ingestion/scope-extractor-bridge.js';
+import { rProvider } from '../../../../src/core/ingestion/languages/r.js';
+import { populateClassOwnedMembers } from '../../../../src/core/ingestion/scope-resolution/scope/walkers.js';
+
+const FILE = 'R/x.R';
+
+/** Parse + run R's `populateOwners` (the generic `populateClassOwnedMembers`). */
+function parse(src: string): ParsedFile | undefined {
+  const parsed = extractParsedFile(rProvider, src, FILE);
+  if (parsed !== undefined) populateClassOwnedMembers(parsed);
+  return parsed;
+}
+
+const scopesOf = (src: string): readonly Scope[] => parse(src)?.scopes ?? [];
+
+const fmt = (r: Range): string => `${r.startLine}:${r.startCol}-${r.endLine}:${r.endCol}`;
+
+/**
+ * The range string of the single occurrence of `snippet` in `src`. Throws at
+ * describe time (never inside a test body) when the snippet is missing or
+ * ambiguous, so a typo cannot masquerade as an expected failure.
+ */
+function spanOf(src: string, snippet: string): string {
+  const start = src.indexOf(snippet);
+  if (start < 0 || src.indexOf(snippet, start + 1) >= 0) {
+    throw new Error(`snippet must occur exactly once: ${snippet}`);
+  }
+  const at = (offset: number): string => {
+    const before = src.slice(0, offset);
+    const line = before.split('\n').length;
+    const col = offset - (before.lastIndexOf('\n') + 1);
+    return `${line}:${col}`;
+  };
+  return `${at(start)}-${at(start + snippet.length)}`;
+}
+
+const allDefs = (scopes: readonly Scope[]): SymbolDefinition[] =>
+  scopes.flatMap((s) => [...s.ownedDefs]);
+
+const findDef = (
+  scopes: readonly Scope[],
+  type: string,
+  name: string,
+): SymbolDefinition | undefined =>
+  allDefs(scopes).find((d) => d.nodeId.endsWith(`:${type}:${name}`));
+
+const scopeByRange = (
+  scopes: readonly Scope[],
+  kind: Scope['kind'],
+  range: string,
+): Scope | undefined => scopes.find((s) => s.kind === kind && fmt(s.range) === range);
+
+const moduleOf = (scopes: readonly Scope[]): Scope | undefined =>
+  scopes.find((s) => s.kind === 'Module');
+
+/** Who owns the def, and where that scope sits. Always an object, so a wrong owner is a value diff. */
+function ownerInfo(
+  scopes: readonly Scope[],
+  type: string,
+  name: string,
+): { kind: string; parentKind: string | undefined; range: string } | undefined {
+  const owner = scopes.find((s) => s.ownedDefs.some((d) => d.nodeId.endsWith(`:${type}:${name}`)));
+  if (owner === undefined) return undefined;
+  return {
+    kind: owner.kind,
+    parentKind: scopes.find((s) => s.id === owner.parent)?.kind,
+    range: fmt(owner.range),
+  };
+}
+
+/** Ranges of every ancestor scope, nearest first. */
+function ancestorRanges(scopes: readonly Scope[], scope: Scope | undefined): string[] {
+  const out: string[] = [];
+  let cur = scope === undefined ? undefined : scopes.find((s) => s.id === scope.parent);
+  while (cur !== undefined) {
+    out.push(fmt(cur.range));
+    const parentId = cur.parent;
+    cur = scopes.find((s) => s.id === parentId);
+  }
+  return out;
+}
+
+const defNames = (defs: readonly SymbolDefinition[]): string[] =>
+  defs.map((d) => d.nodeId.split(':').slice(-1)[0]);
+
+// ─── Sources ────────────────────────────────────────────────────────────────
+
+const FORMS_SRC = [
+  'f <- function(x) g(x)',
+  'g = function(x) g2(x)',
+  'h <<- function(x) g3(x)',
+  'k <- \\(x) g4(x)',
+  'dotted.name <- function(x) g5(x)',
+  '`weird name` <- function(x) g6(x)',
+  '',
+].join('\n');
+
+const FORMS = [
+  { label: '<-', name: 'f', line: 'f <- function(x) g(x)', row: 1 },
+  { label: '=', name: 'g', line: 'g = function(x) g2(x)', row: 2 },
+  { label: '<<-', name: 'h', line: 'h <<- function(x) g3(x)', row: 3 },
+  { label: '\\(x) lambda', name: 'k', line: 'k <- \\(x) g4(x)', row: 4 },
+  { label: 'dotted name', name: 'dotted.name', line: 'dotted.name <- function(x) g5(x)', row: 5 },
+  {
+    label: 'backtick name',
+    name: '`weird name`',
+    line: '`weird name` <- function(x) g6(x)',
+    row: 6,
+  },
+] as const;
+
+const NESTED_SRC = [
+  'outer <- function(x) {',
+  '  inner <- function(y) g(y)',
+  '  inner(x)',
+  '  lapply(x, function(z) h(z))',
+  '  sapply(x, FUN = function(z) h2(z))',
+  '  tryCatch(e(), error = function(e) h3(e))',
+  '}',
+  '',
+].join('\n');
+const OUTER_FN = spanOf(NESTED_SRC, NESTED_SRC.slice(NESTED_SRC.indexOf('function(x) {'), -1));
+const INNER_ASSIGN = spanOf(NESTED_SRC, 'inner <- function(y) g(y)');
+
+const R6_SRC = [
+  'Acct <- R6::R6Class("Acct",',
+  '  public = list(',
+  '    cache = build_cache(),',
+  '    deposit = function(x) 1,',
+  '    run = function() {',
+  '      helper <- function() 1',
+  '      helper()',
+  '    }',
+  '  ),',
+  '  private = list(',
+  '    audit = function() 2',
+  '  ),',
+  '  active = list(',
+  '    balance = function() 3',
+  '  )',
+  ')',
+  '',
+].join('\n');
+
+const BARE_R6_SRC = 'Bare <- R6Class("Bare", public = list(get_value = function() 1))\n';
+const R5_SRC =
+  'Rc <- setRefClass("Rc", methods = list(process = function() 1, other = function() 2))\n';
+const FIELD_SRC = 'A <- R6Class("A", public = list(cache = build_cache(), m = function() 1))\n';
+const SOLO_SRC = 'solo <- function(x) g(x)';
+const MEMBER_SRC = 'obj$f <- function(x) g(x)\nx[["k"]] <- function(y) g(y)\n';
+
+describe('R scope function anchors', () => {
+  // ─── Sanity ───────────────────────────────────────────────────────────────
+  it('parses every source in this file', () => {
+    const parsed = [
+      FORMS_SRC,
+      NESTED_SRC,
+      R6_SRC,
+      BARE_R6_SRC,
+      R5_SRC,
+      FIELD_SRC,
+      SOLO_SRC,
+      MEMBER_SRC,
+    ].map((src) => parse(src) !== undefined);
+    expect(parsed).toEqual([true, true, true, true, true, true, true, true]);
+  });
+
+  // ─── named forms ─────────────────────────────────────
+  describe('named assignment forms', () => {
+    const scopes = scopesOf(FORMS_SRC);
+
+    // Assignment-anchored ownership: the def is owned by a Function scope whose range is
+    // the assignment (the def's anchor) and whose parent is the Module.
+    for (const form of FORMS) {
+      it(`${form.label}: the def is owned by its own assignment-anchored Function scope`, () => {
+        expect(ownerInfo(scopes, 'Function', form.name)).toEqual({
+          kind: 'Function',
+          parentKind: 'Module',
+          range: spanOf(FORMS_SRC, form.line),
+        });
+      });
+    }
+
+    // Assignment-anchored ownership: the Module scope no longer owns any callable.
+    it('the Module scope owns no callable def', () => {
+      const callables = (moduleOf(scopes)?.ownedDefs ?? []).filter((d) => d.type === 'Function');
+      expect(defNames(callables)).toEqual([]);
+    });
+
+    // Behaviour the anchoring leaves unchanged: the binding of each name is visible from the Module.
+    for (const form of FORMS) {
+      it(`binds ${form.label} name in the Module scope with origin local`, () => {
+        const refs = moduleOf(scopes)?.bindings.get(form.name) ?? [];
+        expect(refs.map((r) => r.origin)).toEqual(['local']);
+      });
+    }
+
+    // Behaviour the anchoring leaves unchanged: scope ids stay unique per file.
+    it('keeps scope ids unique', () => {
+      expect(new Set(scopes.map((s) => s.id)).size).toBe(scopes.length);
+    });
+
+    // Behaviour the anchoring leaves unchanged: the def id still encodes the assignment start.
+    it('keeps the def node ids anchored at the assignment start', () => {
+      const expected = FORMS.map((f) => `def:${FILE}#${f.row}:0:Function:${f.name}`).sort();
+      expect(
+        allDefs(scopes)
+          .map((d) => d.nodeId)
+          .sort(),
+      ).toEqual(expected);
+    });
+  });
+
+  // ─── nested functions ────────────────────────────────────
+  describe('nested functions', () => {
+    const scopes = scopesOf(NESTED_SRC);
+
+    // Assignment-anchored ownership.
+    it("the inner def is owned by inner's own assignment-anchored Function scope", () => {
+      expect(ownerInfo(scopes, 'Function', 'inner')).toEqual({
+        kind: 'Function',
+        parentKind: 'Function',
+        range: INNER_ASSIGN,
+      });
+    });
+
+    it("outer's function_definition scope owns nothing", () => {
+      expect(
+        defNames(
+          scopeByRange(scopes, 'Function', OUTER_FN)?.ownedDefs ?? [
+            { nodeId: 'missing-scope' } as SymbolDefinition,
+          ],
+        ),
+      ).toEqual([]);
+    });
+
+    // Behaviour the anchoring leaves unchanged: the inner binding lives in outer's function_definition scope.
+    it("binds the inner name in outer's function_definition scope", () => {
+      const refs = scopeByRange(scopes, 'Function', OUTER_FN)?.bindings.get('inner') ?? [];
+      expect(refs.map((r) => r.origin)).toEqual(['local']);
+    });
+
+    // Behaviour the anchoring leaves unchanged: anonymous / named-argument lambdas own nothing
+    // and hang (transitively) under outer's function_definition scope.
+    for (const snippet of ['function(z) h(z)', 'function(z) h2(z)', 'function(e) h3(e)']) {
+      const anonymous = scopeByRange(scopes, 'Function', spanOf(NESTED_SRC, snippet));
+      it(`anonymous "${snippet}" owns no def`, () => {
+        expect(
+          defNames(anonymous?.ownedDefs ?? [{ nodeId: 'missing-scope' } as SymbolDefinition]),
+        ).toEqual([]);
+      });
+      it(`anonymous "${snippet}" sits under outer's function_definition scope`, () => {
+        expect(ancestorRanges(scopes, anonymous).includes(OUTER_FN)).toBe(true);
+      });
+    }
+  });
+
+  // ─── R6 and R5 methods ───────────────────────────────
+  describe('R6 / R5 methods', () => {
+    const r6 = scopesOf(R6_SRC);
+    const bare = scopesOf(BARE_R6_SRC);
+    const r5 = scopesOf(R5_SRC);
+    const classOwns = (scopes: readonly Scope[]): string[] =>
+      (scopes.find((s) => s.kind === 'Class')?.ownedDefs ?? []).map((d) => d.type);
+
+    // Assignment-anchored ownership: one test each.
+    const cases = [
+      {
+        label: 'R6 public',
+        scopes: r6,
+        src: R6_SRC,
+        name: 'deposit',
+        snippet: 'deposit = function(x) 1',
+      },
+      {
+        label: 'R6 private',
+        scopes: r6,
+        src: R6_SRC,
+        name: 'audit',
+        snippet: 'audit = function() 2',
+      },
+      {
+        label: 'R6 active',
+        scopes: r6,
+        src: R6_SRC,
+        name: 'balance',
+        snippet: 'balance = function() 3',
+      },
+      {
+        label: 'bare R6Class',
+        scopes: bare,
+        src: BARE_R6_SRC,
+        name: 'get_value',
+        snippet: 'get_value = function() 1',
+      },
+      {
+        label: 'R5 methods',
+        scopes: r5,
+        src: R5_SRC,
+        name: 'process',
+        snippet: 'process = function() 1',
+      },
+    ];
+    for (const c of cases) {
+      it(`${c.label}: the method is owned by a Function scope under the Class, which owns only the class def`, () => {
+        expect({
+          owner: ownerInfo(c.scopes, 'Method', c.name),
+          classOwns: classOwns(c.scopes),
+        }).toEqual({
+          owner: { kind: 'Function', parentKind: 'Class', range: spanOf(c.src, c.snippet) },
+          classOwns: ['Class'],
+        });
+      });
+    }
+
+    // Behaviour the anchoring leaves unchanged: ownerId + qualifiedName after populateClassOwnedMembers.
+    // HEAD reaches this through branch 2 (defs owned by the Class scope); after
+    // the fix through branch 1 (Function scope under Class): the invariant must
+    // survive the mechanism swap.
+    it('stamps a method ownerId with the class def id', () => {
+      const classDef = findDef(r6, 'Class', 'Acct');
+      expect(findDef(r6, 'Method', 'deposit')?.ownerId).toBe(classDef?.nodeId);
+    });
+    it('qualifies a method as Class.method', () => {
+      expect(findDef(r6, 'Method', 'deposit')?.qualifiedName).toBe('Acct.deposit');
+    });
+    it('gives the class def a resolvable id (guards the two ownerId/qualifiedName assertions above)', () => {
+      expect(findDef(r6, 'Class', 'Acct')?.nodeId).toBe(`def:${FILE}#1:0:Class:Acct`);
+    });
+
+    // ─── nested named helper inside an R6 method ────────────
+    // HEAD stamps ownerId = class and qualifiedName `Acct.helper` on it (branch 1
+    // matches its method's Function scope, whose parent is the Class). After the
+    // fix its scope parent is a Function scope and nothing is stamped
+    // (walkers.ts depth invariant). Losing the class attribution for such a
+    // helper is an accepted trade-off: it is a local function inside a method,
+    // not a class member, and keeps a bare qualifiedName.
+    it('a nested helper in an R6 method gets no ownerId', () => {
+      expect(findDef(r6, 'Function', 'helper')?.ownerId).toBeUndefined();
+    });
+    it('a nested helper in an R6 method keeps a bare qualifiedName', () => {
+      expect(findDef(r6, 'Function', 'helper')?.qualifiedName).toBe('helper');
+    });
+    it('the method itself keeps ownerId = class and Class.method', () => {
+      const run = findDef(r6, 'Method', 'run');
+      expect({ ownerId: run?.ownerId, qualifiedName: run?.qualifiedName }).toEqual({
+        ownerId: `def:${FILE}#1:0:Class:Acct`,
+        qualifiedName: 'Acct.run',
+      });
+    });
+  });
+
+  // ─── class body outside any method ───────────────────────
+  describe('class-body field default', () => {
+    const scopes = scopesOf(FIELD_SRC);
+
+    // Assignment-anchored ownership: the Class scope owns ONLY the class def.
+    it('the Class scope owns only the class def', () => {
+      const owned = scopes.find((s) => s.kind === 'Class')?.ownedDefs ?? [];
+      expect(owned.map((d) => d.type)).toEqual(['Class']);
+    });
+
+    // Behaviour the anchoring leaves unchanged: no Function scope contains the field-default call, so the
+    // caller walk from it ends at the Class scope (the source is the Class node).
+    it('has no Function scope around the field-default call', () => {
+      const call = spanOf(FIELD_SRC, 'build_cache()');
+      const [start] = call.split('-');
+      const [line, col] = start.split(':').map(Number);
+      const containing = scopes.filter(
+        (s) =>
+          s.kind === 'Function' &&
+          (s.range.startLine < line || (s.range.startLine === line && s.range.startCol <= col)) &&
+          (s.range.endLine > line || (s.range.endLine === line && s.range.endCol >= col)),
+      );
+      expect(containing.map((s) => fmt(s.range))).toEqual([]);
+    });
+  });
+
+  // ─── single-function file, no trailing newline ───────────
+  describe('single-function file without a trailing newline', () => {
+    const scopes = scopesOf(SOLO_SRC);
+
+    it('keeps scope ids unique when the assignment range equals the program range', () => {
+      expect(new Set(scopes.map((s) => s.id)).size).toBe(scopes.length);
+    });
+
+    // Assignment-anchored ownership.
+    it('the def is owned by a Function scope whose parent is the Module', () => {
+      expect(ownerInfo(scopes, 'Function', 'solo')).toEqual({
+        kind: 'Function',
+        parentKind: 'Module',
+        range: spanOf(SOLO_SRC, SOLO_SRC),
+      });
+    });
+  });
+
+  // ─── Member-assigned functions ────────────────────────────────
+  describe('member-assigned functions', () => {
+    const scopes = scopesOf(MEMBER_SRC);
+
+    it('declares no def for obj$f <- function / x[["k"]] <- function', () => {
+      expect(defNames(allDefs(scopes))).toEqual([]);
+    });
+
+    it('creates only the function_definition scopes (no assignment-anchored scope)', () => {
+      const functionScopes = scopes.filter((s) => s.kind === 'Function').map((s) => fmt(s.range));
+      expect(functionScopes.sort()).toEqual(
+        [spanOf(MEMBER_SRC, 'function(x) g(x)'), spanOf(MEMBER_SRC, 'function(y) g(y)')].sort(),
+      );
+    });
+  });
+});
diff --git a/gitnexus/test/unit/type-env-r.test.ts b/gitnexus/test/unit/type-env-r.test.ts
new file mode 100644
index 000000000..8dddf03e8
--- /dev/null
+++ b/gitnexus/test/unit/type-env-r.test.ts
@@ -0,0 +1,533 @@
+import { describe, it, expect } from 'vitest';
+import { buildTypeEnv } from '../../src/core/ingestion/type-env.js';
+import Parser from 'tree-sitter';
+import R from '@eagleoutice/tree-sitter-r';
+import { SupportedLanguages } from 'gitnexus-shared';
+
+const parser = new Parser();
+
+const parse = (code: string) => {
+  parser.setLanguage(R);
+  return parser.parse(code);
+};
+
+function flatGet(typeEnv: ReturnType<typeof buildTypeEnv>, varName: string): string | undefined {
+  for (const [, scopeMap] of typeEnv.allScopes()) {
+    const val = scopeMap.get(varName);
+    if (val) return val;
+  }
+  return undefined;
+}
+
+function flatSize(typeEnv: ReturnType<typeof buildTypeEnv>): number {
+  let count = 0;
+  for (const [, scopeMap] of typeEnv.allScopes()) count += scopeMap.size;
+  return count;
+}
+
+/**
+ * Identifiers named `varName` in the body of the function assigned to `fnName`
+ * (not in its formals, and not inside a function nested in it): the nodes a
+ * receiver lookup starts from.
+ */
+function bodyIdentifiers(tree: ReturnType<typeof parse>, fnName: string, varName: string) {
+  const fnNode = tree.rootNode
+    .descendantsOfType('binary_operator')
+    .find((n) => n.childForFieldName('lhs')?.text === fnName)
+    ?.childForFieldName('rhs');
+  if (fnNode?.type !== 'function_definition') throw new Error(`no function ${fnName}`);
+  return fnNode.descendantsOfType('identifier').filter((id) => {
+    if (id.text !== varName) return false;
+    let current = id.parent;
+    while (current && current.id !== fnNode.id) {
+      if (current.type === 'parameters' || current.type === 'function_definition') return false;
+      current = current.parent;
+    }
+    return true;
+  });
+}
+
+function lookupIn(
+  tree: ReturnType<typeof parse>,
+  typeEnv: ReturnType<typeof buildTypeEnv>,
+  fnName: string,
+  varName: string,
+): string | undefined {
+  const [node] = bodyIdentifiers(tree, fnName, varName);
+  if (!node) throw new Error(`no ${varName} in ${fnName}`);
+  return typeEnv.lookup(varName, node);
+}
+
+describe('buildTypeEnv', () => {
+  describe('R roxygen2 annotations', () => {
+    it('extracts @param type bindings from roxygen2 comments', () => {
+      const tree = parse(`
+DataFrame <- R6::R6Class("DataFrame", public = list(rows = function() 1))
+
+#' @param data DataFrame
+#' @param outliers DataFrame
+AddOutlierStatuses <- function(data, outliers) {
+  data
+}
+`);
+      const typeEnv = buildTypeEnv(tree, SupportedLanguages.R);
+      expect(flatGet(typeEnv, 'data')).toBe('DataFrame');
+      expect(flatGet(typeEnv, 'outliers')).toBe('DataFrame');
+    });
+
+    it('binds nothing for a type the file does not define (primitive or capitalised)', () => {
+      const tree = parse(`
+#' @param x numeric
+#' @param name Character
+process <- function(x, name) {
+  x
+}
+`);
+      const typeEnv = buildTypeEnv(tree, SupportedLanguages.R);
+      expect(flatGet(typeEnv, 'x')).toBeUndefined();
+      expect(flatGet(typeEnv, 'name')).toBeUndefined();
+    });
+
+    it('extracts no types when no roxygen2 comments present', () => {
+      const tree = parse(`
+process <- function(x, y) {
+  x + y
+}
+`);
+      const typeEnv = buildTypeEnv(tree, SupportedLanguages.R);
+      expect(flatSize(typeEnv)).toBe(0);
+    });
+
+    it.each([
+      ['<-', 'helper <- function(repo) {\n  repo\n}'],
+      ['=', 'helper = function(repo) {\n  repo\n}'],
+      ['<<-', 'helper <<- function(repo) {\n  repo\n}'],
+    ])('extracts types from %s function definitions', (_op, definition) => {
+      const tree = parse(`
+UserRepo <- R6::R6Class("UserRepo", public = list(save = function() 1))
+
+#' @param repo UserRepo
+${definition}
+`);
+      const typeEnv = buildTypeEnv(tree, SupportedLanguages.R);
+      expect(flatGet(typeEnv, 'repo')).toBe('UserRepo');
+      expect(lookupIn(tree, typeEnv, 'helper', 'repo')).toBe('UserRepo');
+      expect(typeEnv.fileScope().get('repo')).toBeUndefined();
+    });
+
+    it('returns constructor binding for R6 obj <- ClassName$new()', () => {
+      const tree = parse(`
+rs <- ResultSet$new(items)
+`);
+      const { constructorBindings } = buildTypeEnv(tree, SupportedLanguages.R);
+      const binding = constructorBindings.find((b) => b.varName === 'rs');
+      expect(binding).toBeDefined();
+      expect(binding!.calleeName).toBe('ResultSet');
+    });
+
+    it('returns constructor binding for S4 obj <- new("ClassName")', () => {
+      const tree = parse(`
+model <- new("DataModel", name = "test")
+`);
+      const { constructorBindings } = buildTypeEnv(tree, SupportedLanguages.R);
+      const binding = constructorBindings.find((b) => b.varName === 'model');
+      expect(binding).toBeDefined();
+      expect(binding!.calleeName).toBe('DataModel');
+    });
+
+    it.each([
+      ['Class= after another argument', 'model <- new(name = "test", Class = "DataModel")'],
+      ['Class= first', 'model <- new(Class = "DataModel", name = "test")'],
+      ['a leading named argument', 'model <- new(name = "test", "DataModel")'],
+    ])('returns the S4 constructor binding for new() with %s', (_form, code) => {
+      const { constructorBindings } = buildTypeEnv(parse(code), SupportedLanguages.R);
+      expect(constructorBindings.find((b) => b.varName === 'model')?.calleeName).toBe('DataModel');
+    });
+
+    it('does not take a later string as the class of new() when Class= is another value', () => {
+      const { constructorBindings } = buildTypeEnv(
+        parse('model <- new(Class = base_class, "Other")'),
+        SupportedLanguages.R,
+      );
+      expect(constructorBindings.find((b) => b.varName === 'model')).toBeUndefined();
+    });
+
+    it('extracts @param types when @examples block is present', () => {
+      const tree = parse(`
+DataFrame <- R6::R6Class("DataFrame", public = list(rows = function() 1))
+Config <- R6::R6Class("Config", public = list(get = function() 1))
+
+#' @param data DataFrame
+#' @param config {Config} configuration object
+#' @return Result
+#' @examples
+#' result <- process(my_data, my_config)
+#' print(result)
+process <- function(data, config) {
+  data
+}
+`);
+      const typeEnv = buildTypeEnv(tree, SupportedLanguages.R);
+      expect(flatGet(typeEnv, 'data')).toBe('DataFrame');
+      expect(flatGet(typeEnv, 'config')).toBe('Config');
+    });
+
+    it('extracts @param types when regular comments appear before function', () => {
+      const tree = parse(`
+DataFrame <- R6::R6Class("DataFrame", public = list(rows = function() 1))
+
+#' @param x DataFrame
+# TODO: refactor this later
+compute <- function(x) { x }
+`);
+      const typeEnv = buildTypeEnv(tree, SupportedLanguages.R);
+      expect(flatGet(typeEnv, 'x')).toBe('DataFrame');
+    });
+
+    it('binds a parameter only when the tag names a class the file defines', () => {
+      const tree = parse(`
+#' @param data DataFrame
+#' @param name Character
+process <- function(data, name) {
+  data
+}
+`);
+      const typeEnv = buildTypeEnv(tree, SupportedLanguages.R);
+      expect(flatGet(typeEnv, 'data')).toBeUndefined();
+      expect(flatGet(typeEnv, 'name')).toBeUndefined();
+    });
+
+    it('does not bind a lowercase word even when the file defines a class of that name', () => {
+      const tree = parse(`
+setClass("repo", representation(name = "character"))
+
+#' @param r repo
+save <- function(r) { r }
+`);
+      const typeEnv = buildTypeEnv(tree, SupportedLanguages.R);
+      expect(flatGet(typeEnv, 'r')).toBeUndefined();
+    });
+
+    describe('description prose is not a type', () => {
+      it.each([
+        ['R6', 'Data', 'df', 'Data frame of observations', 'Data <- R6::R6Class("Data")'],
+        ['S4', 'Data', 'df', 'Data frame of observations', 'setClass("Data", representation())'],
+        ['R6', 'Config', 'cfg', 'Config object to read from', 'Config <- R6::R6Class("Config")'],
+        [
+          'S4',
+          'Config',
+          'cfg',
+          'Config object to read from',
+          'setClass("Config", representation())',
+        ],
+      ])(
+        'does not bind the first word of a description that names a %s class %s',
+        (_kind, _className, param, description, definition) => {
+          const tree = parse(`
+${definition}
+
+#' @param ${param} ${description}
+run <- function(${param}) {
+  ${param}
+}
+`);
+          const typeEnv = buildTypeEnv(tree, SupportedLanguages.R);
+          expect(flatGet(typeEnv, param)).toBeUndefined();
+        },
+      );
+
+      it('does not bind an article or determiner that happens to be a class name', () => {
+        const tree = parse(`
+A <- R6::R6Class("A", public = list(go = function() 1))
+
+#' @param x A numeric vector
+f <- function(x) { x }
+`);
+        const typeEnv = buildTypeEnv(tree, SupportedLanguages.R);
+        expect(flatGet(typeEnv, 'x')).toBeUndefined();
+      });
+
+      it('does not bind from the first line of a description that continues on the next line', () => {
+        const tree = parse(`
+Data <- R6::R6Class("Data", public = list(fit = function() 1))
+
+#' @param df Data
+#'   frame of observations
+run <- function(df) {
+  df$fit()
+}
+`);
+        const typeEnv = buildTypeEnv(tree, SupportedLanguages.R);
+        expect(flatGet(typeEnv, 'df')).toBeUndefined();
+      });
+
+      it('binds a braced type whose prose continues on the next line', () => {
+        const tree = parse(`
+Data <- R6::R6Class("Data", public = list(fit = function() 1))
+
+#' @param df {Data} the observations,
+#'   one row per case
+run <- function(df) {
+  df$fit()
+}
+`);
+        const typeEnv = buildTypeEnv(tree, SupportedLanguages.R);
+        expect(flatGet(typeEnv, 'df')).toBe('Data');
+      });
+    });
+
+    it('reads a tag only at the start of a roxygen line', () => {
+      const tree = parse(`
+UserRepo <- R6::R6Class("UserRepo", public = list(save = function() 1))
+
+#' Write the tag as #' @param repo UserRepo in your own comments.
+save <- function(repo) {
+  repo
+}
+`);
+      const typeEnv = buildTypeEnv(tree, SupportedLanguages.R);
+      expect(flatGet(typeEnv, 'repo')).toBeUndefined();
+    });
+
+    it('does not read a tag written mid-line, even when it names a defined class', () => {
+      const tree = parse(`
+UserRepo <- R6::R6Class("UserRepo", public = list(save = function() 1))
+
+#' Write the tag as @param repo UserRepo
+save <- function(repo) {
+  repo
+}
+`);
+      const typeEnv = buildTypeEnv(tree, SupportedLanguages.R);
+      expect(flatGet(typeEnv, 'repo')).toBeUndefined();
+    });
+
+    it('does not read a longer tag name that starts with param', () => {
+      const tree = parse(`
+UserRepo <- R6::R6Class("UserRepo", public = list(save = function() 1))
+
+#' @paramfoo repo UserRepo
+save <- function(repo) {
+  repo
+}
+`);
+      const typeEnv = buildTypeEnv(tree, SupportedLanguages.R);
+      expect(flatGet(typeEnv, 'repo')).toBeUndefined();
+    });
+
+    describe('the binding belongs to the documented function', () => {
+      const userRepo = 'UserRepo <- R6::R6Class("UserRepo", public = list(save = function() 1))';
+
+      it('does not bind a name that is not a formal of the documented function', () => {
+        const tree = parse(`
+${userRepo}
+
+#' @param repo UserRepo
+f <- function(x) { x }
+
+g <- function(repo) { repo$save() }
+
+h <- function() {
+  repo <- 1
+  repo$save()
+}
+`);
+        const typeEnv = buildTypeEnv(tree, SupportedLanguages.R);
+        expect(lookupIn(tree, typeEnv, 'f', 'x')).toBeUndefined();
+        expect(lookupIn(tree, typeEnv, 'g', 'repo')).toBeUndefined();
+        expect(lookupIn(tree, typeEnv, 'h', 'repo')).toBeUndefined();
+        expect(typeEnv.fileScope().get('repo')).toBeUndefined();
+        expect(flatGet(typeEnv, 'repo')).toBeUndefined();
+      });
+
+      it('binds a documented formal inside its function only', () => {
+        const tree = parse(`
+${userRepo}
+
+#' @param repo UserRepo
+f <- function(repo) { repo$save() }
+
+g <- function(repo) { repo$save() }
+
+h <- function() {
+  repo <- 1
+  repo$save()
+}
+`);
+        const typeEnv = buildTypeEnv(tree, SupportedLanguages.R);
+        expect(lookupIn(tree, typeEnv, 'f', 'repo')).toBe('UserRepo');
+        expect(lookupIn(tree, typeEnv, 'g', 'repo')).toBeUndefined();
+        expect(lookupIn(tree, typeEnv, 'h', 'repo')).toBeUndefined();
+        expect(typeEnv.fileScope().get('repo')).toBeUndefined();
+      });
+
+      it('binds a formal that has a default value', () => {
+        const tree = parse(`
+${userRepo}
+
+#' @param repo UserRepo
+f <- function(x, repo = NULL) { repo$save() }
+
+g <- function(repo) { repo$save() }
+`);
+        const typeEnv = buildTypeEnv(tree, SupportedLanguages.R);
+        expect(lookupIn(tree, typeEnv, 'f', 'repo')).toBe('UserRepo');
+        expect(lookupIn(tree, typeEnv, 'g', 'repo')).toBeUndefined();
+        expect(typeEnv.fileScope().get('repo')).toBeUndefined();
+      });
+
+      it('skips the dots formal and still binds a named formal beside it', () => {
+        const tree = parse(`
+${userRepo}
+
+#' @param ... UserRepo
+#' @param repo UserRepo
+f <- function(..., repo) { repo$save() }
+`);
+        const typeEnv = buildTypeEnv(tree, SupportedLanguages.R);
+        expect(lookupIn(tree, typeEnv, 'f', 'repo')).toBe('UserRepo');
+        expect(flatGet(typeEnv, '...')).toBeUndefined();
+        expect(typeEnv.fileScope().get('repo')).toBeUndefined();
+      });
+
+      it.each([
+        ['a plain value', 'repo <- 1'],
+        ['a call', 'setup()'],
+      ])('binds nothing when the block is followed by %s (guard)', (_label, statement) => {
+        const tree = parse(`
+${userRepo}
+
+#' @param repo UserRepo
+${statement}
+
+g <- function(repo) { repo$save() }
+`);
+        const typeEnv = buildTypeEnv(tree, SupportedLanguages.R);
+        expect(lookupIn(tree, typeEnv, 'g', 'repo')).toBeUndefined();
+        expect(typeEnv.fileScope().get('repo')).toBeUndefined();
+      });
+
+      it('does not carry an outer function documentation into a function nested in it', () => {
+        const tree = parse(`
+${userRepo}
+
+#' @param repo UserRepo
+outer <- function(repo) {
+  inner <- function(repo) { repo$save() }
+  repo$save()
+}
+`);
+        const typeEnv = buildTypeEnv(tree, SupportedLanguages.R);
+        expect(lookupIn(tree, typeEnv, 'outer', 'repo')).toBe('UserRepo');
+        expect(lookupIn(tree, typeEnv, 'inner', 'repo')).toBeUndefined();
+      });
+
+      it('binds a documented nested function only inside itself', () => {
+        const tree = parse(`
+Data <- R6::R6Class("Data", public = list(fit = function() 1))
+
+outer <- function(x) {
+  #' @param y Data
+  inner <- function(y) { y$fit() }
+  y
+}
+`);
+        const typeEnv = buildTypeEnv(tree, SupportedLanguages.R);
+        expect(lookupIn(tree, typeEnv, 'inner', 'y')).toBe('Data');
+        expect(lookupIn(tree, typeEnv, 'outer', 'y')).toBeUndefined();
+        expect(typeEnv.fileScope().get('y')).toBeUndefined();
+      });
+    });
+
+    describe('class definition forms', () => {
+      it.each([
+        ['bare R6Class', 'UserRepo <- R6Class("UserRepo", public = list(save = function() 1))'],
+        [
+          'namespaced R6::R6Class',
+          'UserRepo <- R6::R6Class("UserRepo", public = list(save = function() 1))',
+        ],
+        ['setClass', 'setClass("UserRepo", representation(name = "character"))'],
+        ['setRefClass', 'setRefClass("UserRepo", fields = list(name = "character"))'],
+      ])('binds a type defined with %s', (_form, definition) => {
+        const tree = parse(`
+#' @param repo UserRepo
+save <- function(repo) {
+  repo
+}
+
+${definition}
+`);
+        const typeEnv = buildTypeEnv(tree, SupportedLanguages.R);
+        expect(flatGet(typeEnv, 'repo')).toBe('UserRepo');
+      });
+
+      it.each([
+        ['setClass', 'setClass(contains = "Base", Class = "Derived")'],
+        ['setRefClass', 'setRefClass(fields = list(n = "numeric"), Class = "Derived")'],
+        ['a backticked Class', 'setClass(contains = "Base", `Class` = "Derived")'],
+      ])('names the class from Class= when %s puts it after another argument', (_form, call) => {
+        const tree = parse(`
+#' @param a Derived
+#' @param b Base
+save <- function(a, b) {
+  a
+}
+
+${call}
+`);
+        const typeEnv = buildTypeEnv(tree, SupportedLanguages.R);
+        expect(flatGet(typeEnv, 'a')).toBe('Derived');
+        // `Base` is only a parent named by contains=; the file does not define it.
+        expect(flatGet(typeEnv, 'b')).toBeUndefined();
+      });
+
+      it('still names the class from the first unnamed argument', () => {
+        const tree = parse(`
+#' @param a Derived
+save <- function(a) {
+  a
+}
+
+setClass(contains = "Base", "Derived")
+`);
+        expect(flatGet(buildTypeEnv(tree, SupportedLanguages.R), 'a')).toBe('Derived');
+      });
+
+      it('binds the braced form, with or without prose after it', () => {
+        const tree = parse(`
+UserRepo <- R6::R6Class("UserRepo", public = list(save = function() 1))
+
+#' @param repo {UserRepo} the repository
+#' @param backup {UserRepo}
+save <- function(repo, backup) {
+  repo
+}
+`);
+        const typeEnv = buildTypeEnv(tree, SupportedLanguages.R);
+        expect(flatGet(typeEnv, 'repo')).toBe('UserRepo');
+        expect(flatGet(typeEnv, 'backup')).toBe('UserRepo');
+      });
+    });
+
+    describe('forms that are not bound (guards)', () => {
+      it.each([
+        ['\\code{Data} markup', "#' @param df \\code{Data}", ['df']],
+        ['\\linkS4class{Data} markup', "#' @param df \\linkS4class{Data}", ['df']],
+        ['a comma-separated name list', "#' @param x,y Data", ['x', 'y']],
+        ['the dots parameter', "#' @param ... Data", ['...']],
+        ['a dotted parameter name', "#' @param na.rm Data", ['na.rm']],
+      ])('does not bind %s', (_label, tag, names) => {
+        const tree = parse(`
+Data <- R6::R6Class("Data", public = list(fit = function() 1))
+
+${tag}
+run <- function(x, y, df, ..., na.rm = FALSE) {
+  x
+}
+`);
+        const typeEnv = buildTypeEnv(tree, SupportedLanguages.R);
+        for (const name of names) expect(flatGet(typeEnv, name)).toBeUndefined();
+      });
+    });
+  });
+});
diff --git a/type-resolution-system.md b/type-resolution-system.md
index f1981486e..b94499415 100644
--- a/type-resolution-system.md
+++ b/type-resolution-system.md
@@ -377,27 +377,27 @@ So return-type-aware receiver inference already exists in a constrained downstre
 
 ## Language Feature Matrix
 
-| Feature | TS | JS | Java | Kotlin | C# | Go | Rust | Python | PHP | Ruby | Swift | C++ | C | Dart |
-|---------|:--:|:--:|:----:|:------:|:--:|:--:|:----:|:------:|:---:|:----:|:-----:|:---:|:-:|:----:|
-| Declarations | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes |
-| Parameters | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes |
-| Initializer / constructor inference | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes |
-| Constructor binding scan | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes |
-| For-loop element types | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes††† | Yes | Yes | Yes |
-| Pattern binding | Yes | Yes | Yes | Yes | No | Yes | Yes | No | No | No | Partial‡‡‡ | No | No | No |
-| Assignment chains | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | No | Yes | Yes | Yes | Yes |
-| Field/property type resolution | Yes | No† | Yes | Yes | Yes | Yes | Yes | Yes* | Yes | YARD | No | Yes | No‡ | No |
-| Comment-based types | JSDoc | JSDoc | No | No | No | No | No | No | PHPDoc | YARD | No | No | No | No |
-| Return type extraction | JSDoc | JSDoc | No | No | No | No | No | No | PHPDoc | YARD | No | No | No | No |
-| Call-result variable binding | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes¶ | Yes††† | Yes | No | Yes |
-| Field access binding | Yes | No† | Yes | Yes | Yes | Yes | Yes | No‖ | Yes | N/A | Yes††† | Yes | No | Yes |
-| Method-call-result binding | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes¶ | Yes††† | Yes | No | Yes |
-| Write access (ACCESSES write) | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes§ | Yes | Yes | Yes | No | Yes |
-| Parameter types extracted | Yes** | No | Yes | Yes | Yes | Yes | Yes | Partial†† | No | No | No | Yes | No | No |
-| Method overload disambiguation | Yes** | No | Yes | Yes | Yes | No | No | No | No | No | No | Yes | No | No |
-| Constructor-visible virtual dispatch | Yes | No | Yes | Yes‡‡ | Yes | No | No | No | No | No | No | Yes§§ | No | Yes |
-| Optional parameter arity resolution | Yes | No | No | Yes | Yes | No | No | Yes | Yes | Yes | No | Yes | No | No |
-| Cross-file binding propagation | Yes | Yes | Yes‖‖ | Yes | Yes¶¶ | Yes*** | Yes | Yes | Partial | Yes*** | Yes*** | Yes*** | Yes*** | Yes*** |
+| Feature | TS | JS | Java | Kotlin | C# | Go | Rust | Python | PHP | Ruby | Swift | C++ | C | Dart | R |
+|---------|:--:|:--:|:----:|:------:|:--:|:--:|:----:|:------:|:---:|:----:|:-----:|:---:|:-:|:----:|:-:|
+| Declarations | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes |
+| Parameters | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | No‖‖‖ |
+| Initializer / constructor inference | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes |
+| Constructor binding scan | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes |
+| For-loop element types | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes††† | Yes | Yes | Yes | No |
+| Pattern binding | Yes | Yes | Yes | Yes | No | Yes | Yes | No | No | No | Partial‡‡‡ | No | No | No | No |
+| Assignment chains | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | No | Yes | Yes | Yes | Yes | No |
+| Field/property type resolution | Yes | No† | Yes | Yes | Yes | Yes | Yes | Yes* | Yes | YARD | No | Yes | No‡ | No | Partial‖‖‖ |
+| Comment-based types | JSDoc | JSDoc | No | No | No | No | No | No | PHPDoc | YARD | No | No | No | No | Roxygen2 |
+| Return type extraction | JSDoc | JSDoc | No | No | No | No | No | No | PHPDoc | YARD | No | No | No | No | No |
+| Call-result variable binding | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes¶ | Yes††† | Yes | No | Yes | Yes |
+| Field access binding | Yes | No† | Yes | Yes | Yes | Yes | Yes | No‖ | Yes | N/A | Yes††† | Yes | No | Yes | No |
+| Method-call-result binding | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes¶ | Yes††† | Yes | No | Yes | Yes |
+| Write access (ACCESSES write) | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes§ | Yes | Yes | Yes | No | Yes | No |
+| Parameter types extracted | Yes** | No | Yes | Yes | Yes | Yes | Yes | Partial†† | No | No | No | Yes | No | No | Roxygen2 |
+| Method overload disambiguation | Yes** | No | Yes | Yes | Yes | No | No | No | No | No | No | Yes | No | No | No |
+| Constructor-visible virtual dispatch | Yes | No | Yes | Yes‡‡ | Yes | No | No | No | No | No | No | Yes§§ | No | Yes | No |
+| Optional parameter arity resolution | Yes | No | No | Yes | Yes | No | No | Yes | Yes | Yes | No | Yes | No | No | No |
+| Cross-file binding propagation | Yes | Yes | Yes‖‖ | Yes | Yes¶¶ | Yes*** | Yes | Yes | Partial | Yes*** | Yes*** | Yes*** | Yes*** | Yes*** | Yes*** |
 
 \* Python class-level annotated attributes (`address: Address`) now resolve `declaredType` correctly. The `self.x` instance attribute pattern is not yet supported.
 
@@ -429,7 +429,9 @@ So return-type-aware receiver inference already exists in a constrained downstre
 
 ‡‡‡ Swift: `if let` / `guard let` optional bindings supported. `while let`, `switch` / `case` pattern matching, and tuple destructuring not yet implemented.
 
-\*\*\* Whole-module-import languages (Go, Ruby, C/C++, Swift): namedImportMap entries synthesized from graph-exported symbols via `synthesizeWildcardImportBindings()`. Not from import AST node extraction.
+\*\*\* Whole-module-import languages (Go, Ruby, C/C++, Swift, R): namedImportMap entries synthesized from graph-exported symbols via `synthesizeWildcardImportBindings()`. Not from import AST node extraction.
+
+‖‖‖ R has no inline type annotations. Parameter types are extracted from roxygen2 `@param` tags only when the description is the type alone (`#' @param name Type`) or starts with it in braces (`#' @param name {Type} prose`), `Type` is an R6, S4 or RefClass class defined in the same file, and the name is a formal of the function the block documents (the type is bound inside that function only); prose that merely begins with a capitalised word binds nothing. Roxygen `@return` is not read. Field/property types for S4 slots come from `representation(name = "character")` string literals; R6 fields infer types from default values (`NULL`, `TRUE`, `0L`, `"str"`).
 
 ---