code-graph-rag 0.0.209__tar.gz → 0.0.245__tar.gz

{code_graph_rag-0.0.209/code_graph_rag.egg-info → code_graph_rag-0.0.245}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-graph-rag
-Version: 0.0.209
+Version: 0.0.245
 Summary: The ultimate RAG for your monorepo. Query, understand, and edit multi-language codebases with the power of AI and knowledge graphs
 License-Expression: MIT
 Keywords: rag,retrieval-augmented-generation,knowledge-graph,code-analysis,tree-sitter,mcp,mcp-server,llm,graph-database,semantic-search,codebase,memgraph,developer-tools,monorepo

{code_graph_rag-0.0.209 → code_graph_rag-0.0.245}/README.md

@@ -82,7 +82,8 @@ An accurate Retrieval-Augmented Generation (RAG) system that analyzes multi-lang
 | PHP | Fully Supported | .php | ✓ | ✓ | ✓ | - | Classes, interfaces, traits, enums, namespaces, PHP 8 attributes |
 | Python | Fully Supported | .py | ✓ | ✓ | ✓ | ✓ | Type inference, decorators, nested functions |
 | Rust | Fully Supported | .rs | ✓ | ✓ | ✓ | ✓ | impl blocks, associated functions |
-| TypeScript | Fully Supported | .ts, .tsx | ✓ | ✓ | ✓ | - | Interfaces, type aliases, enums, namespaces, ES6/CommonJS modules |
+| TypeScript (TSX) | Fully Supported | .tsx | ✓ | ✓ | ✓ | - | All TypeScript features plus JSX elements and components |
+| TypeScript | Fully Supported | .ts | ✓ | ✓ | ✓ | - | Interfaces, type aliases, enums, namespaces, ES6/CommonJS modules |
 | Go | In Development | .go | ✓ | ✓ | ✓ | - | Methods, type declarations |
 | Scala | In Development | .scala, .sc | ✓ | ✓ | ✓ | - | Case classes, objects |
 <!-- /SECTION:supported_languages -->
@@ -689,6 +690,7 @@ The knowledge graph uses the following node types and relationships:
 - **PHP**: `anonymous_function`, `arrow_function`, `class_declaration`, `enum_declaration`, `function_definition`, `interface_declaration`, `method_declaration`, `trait_declaration`
 - **Python**: `class_definition`, `function_definition`
 - **Rust**: `closure_expression`, `enum_item`, `function_item`, `function_signature_item`, `impl_item`, `struct_item`, `trait_item`, `type_item`, `union_item`
+- **TypeScript (TSX)**: `abstract_class_declaration`, `arrow_function`, `class`, `class_declaration`, `enum_declaration`, `function_declaration`, `function_expression`, `function_signature`, `generator_function_declaration`, `interface_declaration`, `internal_module`, `method_definition`, `type_alias_declaration`
 - **TypeScript**: `abstract_class_declaration`, `arrow_function`, `class`, `class_declaration`, `enum_declaration`, `function_declaration`, `function_expression`, `function_signature`, `generator_function_declaration`, `interface_declaration`, `internal_module`, `method_definition`, `type_alias_declaration`
 - **Go**: `function_declaration`, `method_declaration`, `type_alias`, `type_spec`
 - **Scala**: `class_definition`, `function_declaration`, `function_definition`, `object_definition`, `trait_definition`
@@ -715,7 +717,7 @@ The knowledge graph uses the following node types and relationships:
 | ModuleImplementation | IMPLEMENTS | ModuleInterface |
 | Project | DEPENDS_ON_EXTERNAL | ExternalPackage |
 | Function, Method | CALLS | Function, Method |
-| Module, Function, Method | REFERENCES | Function, Method |
+| Module, Function, Method | REFERENCES | Function, Method, Class |
 | Module, Function, Method | INSTANTIATES | Class |
 <!-- /SECTION:relationship_schemas -->
 

{code_graph_rag-0.0.209 → code_graph_rag-0.0.245/code_graph_rag.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-graph-rag
-Version: 0.0.209
+Version: 0.0.245
 Summary: The ultimate RAG for your monorepo. Query, understand, and edit multi-language codebases with the power of AI and knowledge graphs
 License-Expression: MIT
 Keywords: rag,retrieval-augmented-generation,knowledge-graph,code-analysis,tree-sitter,mcp,mcp-server,llm,graph-database,semantic-search,codebase,memgraph,developer-tools,monorepo

{code_graph_rag-0.0.209 → code_graph_rag-0.0.245}/code_graph_rag.egg-info/SOURCES.txt

@@ -70,6 +70,7 @@ codebase_rag/parsers/cpp_frontend/constants.py
 codebase_rag/parsers/cpp_frontend/frontend.py
 codebase_rag/parsers/cpp_frontend/qn.py
 codebase_rag/parsers/go/__init__.py
+codebase_rag/parsers/go/module_paths.py
 codebase_rag/parsers/go/type_inference.py
 codebase_rag/parsers/go/utils.py
 codebase_rag/parsers/handlers/__init__.py
@@ -104,6 +105,7 @@ codebase_rag/parsers/py/type_inference.py
 codebase_rag/parsers/py/utils.py
 codebase_rag/parsers/py/variable_analyzer.py
 codebase_rag/parsers/rs/__init__.py
+codebase_rag/parsers/rs/type_inference.py
 codebase_rag/parsers/rs/utils.py
 codebase_rag/providers/__init__.py
 codebase_rag/providers/base.py

{code_graph_rag-0.0.209 → code_graph_rag-0.0.245}/codebase_rag/cli.py

@@ -2,6 +2,7 @@ import asyncio
 import json
 import time
 from collections.abc import Callable
+from fnmatch import fnmatch
 from functools import partial
 from importlib.metadata import version as get_version
 from pathlib import Path
@@ -16,7 +17,7 @@ from . import cgr_state
 from . import cli_help as ch
 from . import constants as cs
 from . import logs as ls
-from .config import load_cgrignore_patterns, settings
+from .config import load_ignore_patterns, settings
 from .graph_updater import GraphUpdater
 from .main import (
     _create_configuration_table,
@@ -192,7 +193,7 @@ def _run_graph_sync(
     clean: bool = False,
     output: str | None = None,
 ) -> None:
-    cgrignore = load_cgrignore_patterns(repo)
+    cgrignore = load_ignore_patterns(repo)
     cli_excludes = frozenset(exclude) if exclude else frozenset()
     exclude_paths = cli_excludes | cgrignore.exclude or None
     unignore_paths: frozenset[str] | None
@@ -535,7 +536,7 @@ def index(
 
     _info(style(cs.CLI_MSG_OUTPUT_TO.format(path=output_proto_dir), cs.Color.CYAN))
 
-    cgrignore = load_cgrignore_patterns(repo_to_index)
+    cgrignore = load_ignore_patterns(repo_to_index)
     cli_excludes = frozenset(exclude) if exclude else frozenset()
     exclude_paths = cli_excludes | cgrignore.exclude or None
     unignore_paths: frozenset[str] | None = None
@@ -941,6 +942,22 @@ def _dead_code_params(
     }
 
 
+def _filter_excluded_rows(rows: list[ResultRow], exclude: list[str]) -> list[ResultRow]:
+    # (H) Drop candidates whose file path matches an exclude glob (generated dirs
+    # (H) like client/core or *.gen.* have no in-repo caller, so every symbol
+    # (H) reports as dead). fnmatch treats '*' as spanning '/', so '*client/core*'
+    # (H) matches at any depth.
+    if not exclude:
+        return rows
+    return [
+        row
+        for row in rows
+        if not any(
+            fnmatch(str(row.get(cs.KEY_PATH) or ""), pattern) for pattern in exclude
+        )
+    ]
+
+
 def _to_dead_code_row(row: ResultRow) -> DeadCodeRow:
     start = row.get(cs.KEY_START_LINE, 0)
     end = row.get(cs.KEY_END_LINE, 0)
@@ -1028,6 +1045,7 @@ def dead_code(
     decorator_root: list[str] = typer.Option(
         [], "--decorator-root", help=ch.HELP_DEADCODE_DECORATOR_ROOT
     ),
+    exclude: list[str] = typer.Option([], "--exclude", help=ch.HELP_DEADCODE_EXCLUDE),
     include_tests: bool = typer.Option(
         True,
         "--include-tests/--no-include-tests",
@@ -1083,7 +1101,9 @@ def dead_code(
         app_context.console.print(style(message, cs.Color.RED))
         raise typer.Exit(1)
 
-    candidates = [_to_dead_code_row(row) for row in rows]
+    candidates = [
+        _to_dead_code_row(row) for row in _filter_excluded_rows(rows, exclude)
+    ]
     _emit_dead_code(candidates, output_format, output, resolved)
 
     if fail_on_found and candidates:

{code_graph_rag-0.0.209 → code_graph_rag-0.0.245}/codebase_rag/cli_help.py

@@ -191,6 +191,11 @@ HELP_DEADCODE_DECORATOR_ROOT = (
     "Treat functions/methods carrying this decorator as reachable roots. "
     "Extends the built-in set (route, task, fixture, command, ...). Repeatable."
 )
+HELP_DEADCODE_EXCLUDE = (
+    "Glob matched against a symbol's file path to exclude from the report "
+    "(e.g. '*client/core*', '*.gen.*' for generated code). '*' spans '/'. "
+    "Repeatable."
+)
 HELP_DEADCODE_INCLUDE_TESTS = (
     "Treat test code as reachable roots so production code it exercises is "
     "not reported. On by default."

{code_graph_rag-0.0.209 → code_graph_rag-0.0.245}/codebase_rag/config.py

@@ -360,13 +360,13 @@ class AppConfig(BaseSettings):
 settings = AppConfig()
 
 CGRIGNORE_FILENAME = ".cgrignore"
+GITIGNORE_FILENAME = ".gitignore"
 
 
 EMPTY_CGRIGNORE = CgrignorePatterns(exclude=frozenset(), unignore=frozenset())
 
 
-def load_cgrignore_patterns(repo_path: Path) -> CgrignorePatterns:
-    ignore_file = repo_path / CGRIGNORE_FILENAME
+def _load_ignore_file(ignore_file: Path) -> CgrignorePatterns:
     if not ignore_file.is_file():
         return EMPTY_CGRIGNORE
 
@@ -394,11 +394,37 @@ def load_cgrignore_patterns(repo_path: Path) -> CgrignorePatterns:
             exclude=frozenset(exclude),
             unignore=frozenset(unignore),
         )
-    except OSError as e:
+    except (OSError, ValueError) as e:
         logger.warning(logs.CGRIGNORE_READ_FAILED.format(path=ignore_file, error=e))
         return EMPTY_CGRIGNORE
 
 
+def load_cgrignore_patterns(repo_path: Path) -> CgrignorePatterns:
+    return _load_ignore_file(repo_path / CGRIGNORE_FILENAME)
+
+
+def load_ignore_patterns(repo_path: Path) -> CgrignorePatterns:
+    # (H) Merged exclude/unignore set for indexing: root .gitignore (gitignored
+    # (H) paths are build artifacts / generated output whose symbols pollute the
+    # (H) graph and the dead-code report) plus .cgrignore, which stays the
+    # (H) authoritative cgr-specific channel. The runtime skip check gives
+    # (H) excludes precedence over unignores, so a negation can only override a
+    # (H) .gitignore exclude by CANCELLING the exact same pattern string here at
+    # (H) load time (`!generated/` drops `generated/`). .cgrignore excludes are
+    # (H) never cancelled by .gitignore negations.
+    # (H) ponytail: root .gitignore only, exact-string cancellation only; a
+    # (H) finer-grained negation (`!dist/keep.py` under excluded `dist/`) still
+    # (H) cannot rescue -- an ordered PathSpec soft layer in should_skip_path is
+    # (H) the upgrade path if real repos need it.
+    cgr = _load_ignore_file(repo_path / CGRIGNORE_FILENAME)
+    git = _load_ignore_file(repo_path / GITIGNORE_FILENAME)
+    negations = cgr.unignore | git.unignore
+    return CgrignorePatterns(
+        exclude=cgr.exclude | (git.exclude - negations),
+        unignore=negations,
+    )
+
+
 CGR_INSTRUCTIONS_FILENAME = ".cgr.md"
 GLOBAL_CGR_INSTRUCTIONS_PATH = Path.home() / CGR_INSTRUCTIONS_FILENAME
 

{code_graph_rag-0.0.209 → code_graph_rag-0.0.245}/codebase_rag/constants.py

@@ -101,7 +101,8 @@ EXT_LUA = ".lua"
 # (H) File extension tuples by language
 PY_EXTENSIONS = (EXT_PY,)
 JS_EXTENSIONS = (EXT_JS, EXT_JSX)
-TS_EXTENSIONS = (EXT_TS, EXT_TSX)
+TS_EXTENSIONS = (EXT_TS,)
+TSX_EXTENSIONS = (EXT_TSX,)
 RS_EXTENSIONS = (EXT_RS,)
 GO_EXTENSIONS = (EXT_GO,)
 SCALA_EXTENSIONS = (EXT_SCALA, EXT_SC)
@@ -122,6 +123,13 @@ CPP_EXTENSIONS = (
 PHP_EXTENSIONS = (EXT_PHP,)
 LUA_EXTENSIONS = (EXT_LUA,)
 
+# (H) A C++ operator overload / user-defined literal is defined with the reserved
+# (H) `operator` keyword heading the name (`operator==`, `operator[]`, `operator""_json`).
+# (H) It is invoked by operator/literal syntax, not a named call, so it is a dead-code
+# (H) reachability root; the keyword can only head such definitions, so this prefix on a
+# (H) C++ file uniquely identifies them (member or free function).
+CPP_OPERATOR_PREFIX = "operator"
+
 # (H) Package indicator files
 PKG_INIT_PY = "__init__.py"
 PKG_CARGO_TOML = "Cargo.toml"
@@ -414,6 +422,12 @@ TSCONFIG_FILENAMES: tuple[str, ...] = (
     "tsconfig.base.json",
     "jsconfig.json",
 )
+# (H) When searching subdirectories for tsconfig files (monorepo `frontend/`,
+# (H) `packages/*`), skip dependency/build/VCS trees: their tsconfigs carry
+# (H) unrelated aliases and there can be thousands of them under node_modules.
+TS_ALIAS_SKIP_DIRS: frozenset[str] = frozenset(
+    {"node_modules", "dist", "build", "out", ".git"}
+)
 JS_INDEX_STEM = "index"
 TS_COMPILER_OPTIONS_KEY = "compilerOptions"
 TS_PATHS_KEY = "paths"
@@ -472,10 +486,85 @@ DEFAULT_ROOT_DECORATORS: frozenset[str] = frozenset(
         "root_validator",
         "field_serializer",
         "model_serializer",
+        "computed_field",
         "abstractmethod",
     }
 )
 
+# (H) Go functions the runtime invokes with no explicit call site: `func init()`
+# (H) runs at package load (any number per package), `func main()` is the program
+# (H) entry. Both are reachability roots (like Python dunders), gated by the .go
+# (H) extension so same-named symbols in other languages are unaffected.
+GO_ROOT_FUNCTION_NAMES: frozenset[str] = frozenset({"init", "main"})
+
+# (H) Rust `fn main()` is the binary entry point, invoked by the runtime with no
+# (H) call site -- a reachability root (gated by .rs).
+RUST_ROOT_FUNCTION_NAMES: frozenset[str] = frozenset({"main"})
+
+# (H) Rust trait-impl methods the language/std dispatches implicitly (Display::fmt
+# (H) via format!, PartialEq::eq via ==, Iterator::next via for, operator traits,
+# (H) Drop::drop, serde, ...), never through an explicit call the graph can see.
+# (H) Rooting them by name (gated by .rs) mirrors the Python-dunder exemption: these
+# (H) names are conventionally reserved for trait impls, so a same-named user method
+# (H) that is genuinely dead is under-reported rather than mis-reported.
+RUST_TRAIT_METHOD_NAMES: frozenset[str] = frozenset(
+    {
+        "fmt",
+        "eq",
+        "ne",
+        "cmp",
+        "partial_cmp",
+        "hash",
+        "next",
+        "next_back",
+        "into_iter",
+        "size_hint",
+        "drop",
+        "clone",
+        "clone_from",
+        "default",
+        "from",
+        "from_str",
+        "try_from",
+        "into",
+        "try_into",
+        "deref",
+        "deref_mut",
+        "as_ref",
+        "as_mut",
+        "borrow",
+        "borrow_mut",
+        "poll",
+        "serialize",
+        "deserialize",
+        "source",
+        "add",
+        "add_assign",
+        "sub",
+        "sub_assign",
+        "mul",
+        "mul_assign",
+        "div",
+        "div_assign",
+        "rem",
+        "rem_assign",
+        "neg",
+        "not",
+        "bitand",
+        "bitand_assign",
+        "bitor",
+        "bitor_assign",
+        "bitxor",
+        "bitxor_assign",
+        "shl",
+        "shl_assign",
+        "shr",
+        "shr_assign",
+        "index",
+        "index_mut",
+    }
+)
+
 # (H) Base classes that mark a class as a structural interface: its method stubs
 # (H) are never call targets themselves (callers resolve to the implementations),
 # (H) so dead-code analysis roots every method the class defines.
@@ -623,6 +712,7 @@ class SupportedLanguage(StrEnum):
     PYTHON = "python"
     JS = "javascript"
     TS = "typescript"
+    TSX = "tsx"
     RUST = "rust"
     GO = "go"
     SCALA = "scala"
@@ -660,6 +750,11 @@ LANGUAGE_METADATA: dict[SupportedLanguage, LanguageMetadata] = {
         "Interfaces, type aliases, enums, namespaces, ES6/CommonJS modules",
         "TypeScript",
     ),
+    SupportedLanguage.TSX: LanguageMetadata(
+        LanguageStatus.FULL,
+        "All TypeScript features plus JSX elements and components",
+        "TypeScript (TSX)",
+    ),
     SupportedLanguage.C: LanguageMetadata(
         LanguageStatus.FULL,
         "Functions, structs, unions, enums, preprocessor includes",
@@ -754,7 +849,9 @@ JS_TS_FUNCTION_NODES = (
 )
 JS_TS_CLASS_NODES = ("class_declaration", "class")
 JS_TS_IMPORT_NODES = ("import_statement", "lexical_declaration", "export_statement")
-JS_TS_LANGUAGES = frozenset({SupportedLanguage.JS, SupportedLanguage.TS})
+JS_TS_LANGUAGES = frozenset(
+    {SupportedLanguage.JS, SupportedLanguage.TS, SupportedLanguage.TSX}
+)
 
 # (H) C++ import node types
 CPP_IMPORT_NODES = ("preproc_include", "template_function", "declaration")
@@ -781,6 +878,8 @@ FIELD_DECLARATOR = "declarator"
 FIELD_PARAMETERS = "parameters"
 FIELD_RECEIVER = "receiver"
 FIELD_TYPE = "type"
+# (H) The wrapped function/class inside a Python decorated_definition node.
+FIELD_DEFINITION = "definition"
 FIELD_RESULT = "result"
 # (H) Rust impl `trait`/`type` fields and a trait's supertrait `bounds`.
 FIELD_TRAIT = "trait"
@@ -790,6 +889,7 @@ FIELD_VALUE = "value"
 FIELD_LEFT = "left"
 FIELD_RIGHT = "right"
 FIELD_FIELD = "field"
+FIELD_SCOPE = "scope"
 FIELD_SUPERCLASS = "superclass"
 FIELD_SUPERCLASSES = "superclasses"
 FIELD_INTERFACES = "interfaces"
@@ -1008,6 +1108,7 @@ BUILD_EXT_CMD = "build_ext"
 INPLACE_FLAG = "--inplace"
 LANG_ATTR_PREFIX = "language_"
 LANG_ATTR_TYPESCRIPT = "language_typescript"
+LANG_ATTR_TSX = "language_tsx"
 LANG_ATTR_PHP = "language_php"
 
 
@@ -1655,6 +1756,13 @@ JS_FUNCTION_PROTOTYPE_SUFFIXES: dict[str, str] = {
     JS_SUFFIX_CALL: JS_METHOD_CALL,
     JS_SUFFIX_APPLY: JS_METHOD_APPLY,
 }
+# (H) `fn.bind(ctx)` / `fn.call(...)` / `fn.apply(...)` all use `fn`; when such a
+# (H) call sits in a value position (`onError: handleError.bind(toast)`) the `.bind`
+# (H) resolves to the Function.prototype builtin, so `fn` itself must be referenced
+# (H) separately or it reports as dead.
+JS_FUNCTION_PROTOTYPE_METHODS = frozenset(
+    {JS_METHOD_BIND, JS_METHOD_CALL, JS_METHOD_APPLY}
+)
 
 # (H) C++ operator mappings
 CPP_OPERATORS: dict[str, str] = {
@@ -2003,6 +2111,11 @@ DEP_FILE_REQUIREMENTS = "requirements.txt"
 DEP_FILE_PACKAGE_JSON = "package.json"
 DEP_FILE_CARGO = "cargo.toml"
 DEP_FILE_GOMOD = "go.mod"
+# (H) The go.mod directive naming the module path that prefixes every import of
+# (H) the module's packages; a same-line comment (incl. the official
+# (H) `// Deprecated:` form) may trail it.
+GO_KEYWORD_MODULE = "module"
+GO_MOD_COMMENT_PREFIX = "//"
 DEP_FILE_GEMFILE = "gemfile"
 DEP_FILE_COMPOSER = "composer.json"
 
@@ -2126,6 +2239,10 @@ TS_GO_TYPE_DECLARATION = "type_declaration"
 TS_GO_TYPE_SPEC = "type_spec"
 TS_GO_TYPE_ALIAS = "type_alias"
 TS_GO_STRUCT_TYPE = "struct_type"
+TS_GO_SELECTOR_EXPRESSION = "selector_expression"
+TS_GO_FIELD_DECLARATION_LIST = "field_declaration_list"
+TS_GO_FIELD_DECLARATION = "field_declaration"
+TS_GO_FIELD_IDENTIFIER = "field_identifier"
 TS_GO_INTERFACE_TYPE = "interface_type"
 TS_GO_PARAMETER_DECLARATION = "parameter_declaration"
 TS_GO_FUNC_LITERAL = "func_literal"
@@ -2138,8 +2255,12 @@ TS_GO_PARAMETER_LIST = "parameter_list"
 TS_GO_VAR_DECLARATION = "var_declaration"
 TS_GO_VAR_SPEC = "var_spec"
 TS_GO_SHORT_VAR_DECLARATION = "short_var_declaration"
+TS_GO_ASSIGNMENT_STATEMENT = "assignment_statement"
 TS_GO_EXPRESSION_LIST = "expression_list"
 TS_GO_COMPOSITE_LITERAL = "composite_literal"
+TS_GO_LITERAL_VALUE = "literal_value"
+TS_GO_KEYED_ELEMENT = "keyed_element"
+TS_GO_LITERAL_ELEMENT = "literal_element"
 TS_GO_UNARY_EXPRESSION = "unary_expression"
 TS_GO_POINTER_TYPE = "pointer_type"
 # (H) Go composite types a method may return; a chained call lands on the CONTAINER,
@@ -2214,6 +2335,18 @@ TS_CPP_FUNCTION_DEFINITION = "function_definition"
 TS_CPP_DECLARATION = "declaration"
 TS_CPP_FIELD_DECLARATION = "field_declaration"
 TS_CPP_TEMPLATE_DECLARATION = "template_declaration"
+TS_CPP_TEMPLATE_PARAMETER_LIST = "template_parameter_list"
+# (H) The template TYPE-parameter declaration node types. A value/non-type param
+# (H) (`parameter_declaration`, e.g. `int N` / `MyEnum E`) and a template-template param
+# (H) are deliberately excluded: their type name is a concrete type, not a stand-in that
+# (H) a call receiver could be instantiated as, so it must not enter the template-param set.
+CPP_TYPE_PARAMETER_DECL_TYPES = frozenset(
+    {
+        "type_parameter_declaration",
+        "optional_type_parameter_declaration",
+        "variadic_type_parameter_declaration",
+    }
+)
 TS_CPP_LAMBDA_EXPRESSION = "lambda_expression"
 TS_CPP_TRANSLATION_UNIT = "translation_unit"
 TS_CPP_LINKAGE_SPECIFICATION = "linkage_specification"
@@ -2275,6 +2408,15 @@ CPP_NESTED_SCOPE_NODE_TYPES = frozenset(
     )
 )
 JS_TS_PARENT_REF_TYPES = (TS_IDENTIFIER, TS_MEMBER_EXPRESSION)
+# (H) JSX element nodes that carry a component name (javascript and tsx
+# (H) grammars share these); the closing element repeats the name and must not
+# (H) double-emit.
+TS_JSX_SELF_CLOSING_ELEMENT = "jsx_self_closing_element"
+TS_JSX_OPENING_ELEMENT = "jsx_opening_element"
+# (H) The `{...}` wrapper around an expression in a JSX attribute value or child
+# (H) (`onClick={handleLogout}`, `onClick={() => x()}`); its inner expression can
+# (H) hand a function to the element as a prop.
+TS_JSX_EXPRESSION = "jsx_expression"
 
 # (H) Import processor function names
 IMPORT_REQUIRE = "require"
@@ -2422,6 +2564,16 @@ TS_SPREAD_PARAMETER = "spread_parameter"
 TS_LOCAL_VARIABLE_DECLARATION = "local_variable_declaration"
 TS_FIELD_DECLARATION = "field_declaration"
 TS_ASSIGNMENT_EXPRESSION = "assignment_expression"
+# (H) TS "cast" wrappers that are transparent for reference resolution: `x as T`,
+# (H) `x satisfies T`, and the non-null assertion `x!`. Their first named child is
+# (H) the wrapped value, so unwrapping reaches the real referenced expression
+# (H) (`export const persist = persistImpl as unknown as Persist`).
+TS_AS_EXPRESSION = "as_expression"
+TS_SATISFIES_EXPRESSION = "satisfies_expression"
+TS_NON_NULL_EXPRESSION = "non_null_expression"
+TS_CAST_WRAPPER_TYPES = frozenset(
+    {TS_AS_EXPRESSION, TS_SATISFIES_EXPRESSION, TS_NON_NULL_EXPRESSION}
+)
 TS_OBJECT_CREATION_EXPRESSION = "object_creation_expression"
 TS_METHOD_INVOCATION = "method_invocation"
 TS_FIELD_ACCESS = "field_access"
@@ -2732,6 +2884,13 @@ GUARD_INHERITED_METHOD = "_inherited_method_guard"
 TS_PAIR = "pair"
 TS_OBJECT = "object"
 TS_ARRAY = "array"
+
+# (H) When a variable_declarator's value is one of these, the variable binds the
+# (H) call/construction RESULT, not a function -- so an arrow found inside its
+# (H) arguments (`const m = useMutation({fn: () => {}})`) must not inherit the
+# (H) variable's name. Object-literal / arrow values are not here, so arrows nested
+# (H) directly under an object bound to a const still take the object's name.
+JS_CALL_RESULT_VALUE_TYPES = frozenset({TS_CALL_EXPRESSION, TS_NEW_EXPRESSION})
 TS_FUNCTION_EXPRESSION = "function_expression"
 TS_ARROW_FUNCTION = "arrow_function"
 TS_REQUIRED_PARAMETER = "required_parameter"
@@ -2928,6 +3087,89 @@ TS_RS_MACRO_INVOCATION = "macro_invocation"
 TS_RS_ATTRIBUTE_ITEM = "attribute_item"
 TS_RS_INNER_ATTRIBUTE_ITEM = "inner_attribute_item"
 
+# (H) Rust node types for local-variable type inference (receiver-dispatch)
+TS_RS_LET_DECLARATION = "let_declaration"
+TS_RS_PARAMETER = "parameter"
+TS_RS_SELF_PARAMETER = "self_parameter"
+TS_RS_STRUCT_EXPRESSION = "struct_expression"
+TS_RS_FIELD_DECLARATION_LIST = "field_declaration_list"
+TS_RS_FIELD_DECLARATION = "field_declaration"
+TS_RS_FIELD_IDENTIFIER = "field_identifier"
+TS_RS_MATCH_EXPRESSION = "match_expression"
+TS_RS_MATCH_ARM = "match_arm"
+# (H) A Rust call node whose callee is descended for chain flattening: a plain call
+# (H) or a turbofish generic_function (`f::<T>()`).
+RS_CALL_OR_GENERIC_FN = (TS_RS_CALL_EXPRESSION, TS_GENERIC_FUNCTION)
+TS_RS_TUPLE_STRUCT_PATTERN = "tuple_struct_pattern"
+TS_RS_TYPE_ARGUMENTS = "type_arguments"
+TS_RS_TRY_EXPRESSION = "try_expression"
+TS_RS_FIELD_EXPRESSION = "field_expression"
+TS_RS_FIELD_PATH = "path"
+TS_RS_TOKEN_DOT = "."
+# (H) Nodes that can be a receiver token preceding `.method` in a macro token
+# (H) stream: a plain identifier or the `self` keyword.
+# (H) A receiver/chain base that is a plain identifier or the `self` keyword (used
+# (H) both for macro-token receiver reconstruction and value-chain base flattening).
+RS_IDENT_OR_SELF = (TS_IDENTIFIER, KEYWORD_SELF)
+RS_MACRO_RECEIVER_TYPES = RS_IDENT_OR_SELF
+# (H) Rust `Self` return type resolves to the enclosing impl target.
+RS_SELF_TYPE = "Self"
+# (H) Transparent smart pointers that auto-deref (Rust deref coercion) to their
+# (H) inner type: a method call on the pointer dispatches to the inner type's method,
+# (H) so strip them from any type name (receiver OR return) to reach the real type.
+RS_DEREF_WRAPPERS = frozenset({"Arc", "Rc", "Box", "Pin"})
+# (H) Guard containers that do NOT deref-coerce: the inner value is only reachable
+# (H) through a lock/borrow guard accessor. Stripped to the inner type ONLY in field
+# (H) extraction (where the field is virtually always accessed via a lock chain, e.g.
+# (H) `self.shared.state.lock().unwrap()`); a bare local/param/return of a guard type
+# (H) is preserved so a direct wrapper-method call (`m.is_poisoned()`) is not
+# (H) mis-resolved to an inner-type method.
+RS_GUARD_WRAPPERS = frozenset({"Mutex", "RwLock", "RefCell", "Cell"})
+# (H) Result<T>/Option<T>: stripped to their inner T only for a RETURN type (the
+# (H) value a `?`/`.unwrap()` yields). NOT stripped for a receiver type, where a
+# (H) method call `opt.map(..)` dispatches to Option itself.
+RS_RESULT_WRAPPERS = frozenset({"Result", "Option"})
+# (H) Full strip set for return types (deref pointers + Result/Option unwrap).
+RS_RETURN_STRIP_WRAPPERS = RS_DEREF_WRAPPERS | RS_RESULT_WRAPPERS
+TS_RS_REFERENCE_TYPE = "reference_type"
+TS_RS_POINTER_TYPE = "pointer_type"
+# (H) Node types that can stand for a Rust return/field type. Reference/pointer
+# (H) wrappers (`&Frame`, `*const T`) are included so a generic inner argument
+# (H) (`Result<&Frame>`) and a bare `-> &Frame` return descend to the referent.
+RS_RETURN_TYPE_NODE_TYPES = (
+    TS_TYPE_IDENTIFIER,
+    TS_RS_PRIMITIVE_TYPE,
+    TS_GENERIC_TYPE,
+    TS_RS_SCOPED_TYPE_IDENTIFIER,
+    TS_RS_REFERENCE_TYPE,
+    TS_RS_POINTER_TYPE,
+)
+# (H) Wrapper-passthrough methods: they return the receiver's own (inner) type, so
+# (H) a call-bound local keeps its type across them (`Type::mk().unwrap().m()`).
+RS_IDENTITY_METHODS = frozenset(
+    {
+        "unwrap",
+        "expect",
+        "clone",
+        "unwrap_or_default",
+        "to_owned",
+        "borrow",
+        "borrow_mut",
+        "as_ref",
+        "as_mut",
+        "as_deref",
+        "as_deref_mut",
+    }
+)
+# (H) Guard accessors: called on a guard container (Mutex/RwLock/RefCell) to obtain a
+# (H) guard that derefs to the inner type. In a receiver chain, one of these
+# (H) immediately after a guard-wrapped field unwraps the wrapper to its inner type
+# (H) (recorded in class_field_guard_inner) -- the only sound unwrap point, since
+# (H) guard containers do not deref-coerce.
+RS_GUARD_ACCESSORS = frozenset(
+    {"lock", "read", "write", "try_lock", "borrow", "borrow_mut"}
+)
+
 # (H) Rust identifier tuples
 RS_IDENTIFIER_TYPES = (TS_IDENTIFIER, TS_TYPE_IDENTIFIER)
 RS_SCOPED_TYPES = (TS_SCOPED_IDENTIFIER, TS_RS_SCOPED_TYPE_IDENTIFIER)
@@ -3096,6 +3338,25 @@ FQN_TS_FUNCTION_TYPES = (
     TS_FUNCTION_SIGNATURE,
 )
 
+# (H) When climbing a nameless arrow's ancestors to find its binding declarator,
+# (H) crossing one of these means the arrow lives INSIDE another function's body
+# (H) (a JSX event handler, a `.map()` callback), not directly bound to the outer
+# (H) const -- so it must not inherit that const's name. Without this stop the inner
+# (H) arrow becomes `Component.Component`/`utils.getInitials.getInitials`, a
+# (H) double-segment phantom with no incoming edge (dead-code false positive) that
+# (H) also steals the enclosing scope from the real inline handler nodes.
+JS_ARROW_NAME_CLIMB_BOUNDARY = frozenset(
+    {
+        TS_STATEMENT_BLOCK,
+        TS_ARROW_FUNCTION,
+        TS_FUNCTION_DECLARATION,
+        TS_FUNCTION_EXPRESSION,
+        TS_METHOD_DEFINITION,
+        TS_GENERATOR_FUNCTION_DECLARATION,
+        TS_CLASS_BODY,
+    }
+)
+
 # (H) FQN node type tuples for Rust
 FQN_RS_SCOPE_TYPES = (
     TS_RS_STRUCT_ITEM,