diff --git a/graphify/extract.py b/graphify/extract.py
index c8a4f0bbff..bd237c07a6 100644
--- a/graphify/extract.py
+++ b/graphify/extract.py
@@ -147,6 +147,27 @@
 from graphify.extractors.objc import _objc_local_var_types, extract_objc  # noqa: E402,F401
 
 from graphify.extractors.julia import extract_julia  # noqa: E402,F401
+from graphify.extractors.lazarus_package import extract_lazarus_package  # noqa: E402,F401
+from graphify.extractors.slnx import extract_slnx  # noqa: E402,F401
+from graphify.extractors.csproj import extract_csproj  # noqa: E402,F401
+from graphify.extractors.base import _shorten_rationale_label  # noqa: E402,F401
+from graphify.extractors.xaml import extract_xaml  # noqa: E402,F401
+from graphify.extractors.python import _PYTHON_CONFIG, _RATIONALE_PREFIXES, _import_python, _is_autogenerated_python, _extract_python_rationale, extract_python  # noqa: E402,F401
+from graphify.extractors.js import _JS_CONFIG, _TS_CONFIG, _TSX_CONFIG, _import_js, _rescue_js_dynamic_imports, _JS_RATIONALE_PREFIXES, _JS_DOC_REF_RE, _JS_COMMENT_LINE_RE, _extract_js_rationale, _resolve_rescued_specifier, _emit_rescued_import, extract_js  # noqa: E402,F401
+from graphify.extractors.svelte import extract_svelte  # noqa: E402,F401
+from graphify.extractors.astro import extract_astro  # noqa: E402,F401
+from graphify.extractors.vue import extract_vue  # noqa: E402,F401
+from graphify.extractors.java import _JAVA_CONFIG, _import_java, extract_java  # noqa: E402,F401
+from graphify.extractors.groovy import _GROOVY_CONFIG, _is_spock_file, _extract_spock_fallback, extract_groovy  # noqa: E402,F401
+from graphify.extractors.c import _C_CONFIG, _get_c_func_name, _import_c, extract_c  # noqa: E402,F401
+from graphify.extractors.cpp import _CPP_CONFIG, extract_cpp  # noqa: E402,F401
+from graphify.extractors.ruby import _RUBY_CONFIG, extract_ruby  # noqa: E402,F401
+from graphify.extractors.csharp import _CSHARP_CONFIG, _import_csharp, extract_csharp  # noqa: E402,F401
+from graphify.extractors.kotlin import _KOTLIN_CONFIG, _import_kotlin, extract_kotlin  # noqa: E402,F401
+from graphify.extractors.scala import _SCALA_CONFIG, _import_scala, extract_scala  # noqa: E402,F401
+from graphify.extractors.php import _PHP_CONFIG, _import_php, extract_php  # noqa: E402,F401
+from graphify.extractors.lua import _LUA_CONFIG, _import_lua, extract_lua  # noqa: E402,F401
+from graphify.extractors.swift import _SWIFT_CONFIG, _import_swift, extract_swift  # noqa: E402,F401
 
 _RECURSION_LIMIT = 10_000
 
@@ -310,1590 +331,6 @@ def _resolve_name(node, source: bytes, config: LanguageConfig) -> str | None:
     return None
 
 
-# ── Import handlers ───────────────────────────────────────────────────────────
-
-def _import_python(node, source: bytes, file_nid: str, stem: str, edges: list, str_path: str, scope_stack: list[str] | None = None) -> None:
-    t = node.type
-    if t == "import_statement":
-        for child in node.children:
-            if child.type in ("dotted_name", "aliased_import"):
-                raw = _read_text(child, source)
-                raw_module, _, raw_alias = raw.partition(" as ")
-                module_name = raw_module.strip().lstrip(".")
-                tgt_nid = _make_id(module_name)
-                edge = {
-                    "source": file_nid,
-                    "target": tgt_nid,
-                    "relation": "imports",
-                    "context": "import",
-                    "confidence": "EXTRACTED",
-                    "source_file": str_path,
-                    "source_location": f"L{node.start_point[0] + 1}",
-                    "weight": 1.0,
-                }
-                if raw_alias:
-                    # `import pkg.mod as alias` binds the local name `alias`, not
-                    # `mod`'s own stem, to the module -- stash it so the cross-file
-                    # member-call resolver can match `alias.func()` against this
-                    # edge instead of dropping it (#2082).
-                    edge["local_alias"] = raw_alias.strip()
-                edges.append(edge)
-    elif t == "import_from_statement":
-        module_node = node.child_by_field_name("module_name")
-        if module_node:
-            raw = _read_text(module_node, source)
-            target_path: "Path | None" = None
-            if raw.startswith("."):
-                # Relative import - resolve to full path so IDs match file node IDs
-                dots = len(raw) - len(raw.lstrip("."))
-                module_name = raw.lstrip(".")
-                base = Path(str_path).parent
-                for _ in range(dots - 1):
-                    base = base.parent
-                rel = (module_name.replace(".", "/") + ".py") if module_name else "__init__.py"
-                target_path = base / rel
-                tgt_nid = _make_id(str(target_path))
-            else:
-                tgt_nid = _make_id(raw)
-            edge = {
-                "source": file_nid,
-                "target": tgt_nid,
-                "relation": "imports_from",
-                "context": "import",
-                "confidence": "EXTRACTED",
-                "source_file": str_path,
-                "source_location": f"L{node.start_point[0] + 1}",
-                "weight": 1.0,
-            }
-            # Stamp the resolved target file (mirroring _import_js, #1814) so
-            # the #2169 remap pass can canonicalize this edge's target on an
-            # incremental run where the target file itself is not in the
-            # batch — without it the target keeps an absolute-path-derived id
-            # that matches no node in the merged graph and dangles (#2213).
-            # Existence-gated: a speculative import of a nonexistent sibling
-            # must stay dangling, exactly as before. The stamp is transient
-            # and popped before graph.json ships.
-            if target_path is not None:
-                try:
-                    if target_path.is_file():
-                        edge["target_file"] = str(target_path)
-                except OSError:
-                    pass
-            edges.append(edge)
-
-
-def _import_js(node, source: bytes, file_nid: str, stem: str, edges: list, str_path: str, scope_stack: list[str] | None = None) -> None:
-    is_reexport = node.type == "export_statement"
-    # Only handle export_statement if it has a `from` clause (re-export).
-    # Pure exports like `export const x = 1` or `export { localVar }` have no source module.
-    if is_reexport:
-        has_from = any(child.type == "from" or (_read_text(child, source) == "from") for child in node.children if child.type in ("from", "identifier"))
-        if not has_from:
-            # Check for string child (source path) as a more reliable indicator
-            has_from = any(child.type == "string" for child in node.children)
-            if not has_from:
-                return
-
-    resolved_path: "Path | None" = None
-    module_string = None
-    for child in node.children:
-        if child.type == "string":
-            module_string = child
-            break
-        if child.type == "import_require_clause":
-            # TS import-equals form: `import x = require("./m")`. The module
-            # string sits inside the clause, not on the import_statement
-            # itself, so the direct-child scan above never sees it.
-            module_string = next(
-                (sub for sub in child.children if sub.type == "string"), None
-            )
-            break
-    if module_string is not None:
-        raw = _read_text(module_string, source).strip("'\"` ")
-        resolved = _resolve_js_import_target(raw, str_path)
-        if resolved is not None:
-            tgt_nid, resolved_path = resolved
-            # `_resolve_js_import_path` returns the attempted path when no
-            # local file exists. Static ES imports must treat that as unresolved
-            # rather than minting a checkout-specific target ID (#2457).
-            if resolved_path is not None and not resolved_path.is_file():
-                tgt_nid = _make_id("ref", raw)
-                resolved_path = None
-            edge = {
-                "source": file_nid,
-                "target": tgt_nid,
-                "relation": "imports_from",
-                "context": "re-export" if is_reexport else "import",
-                "confidence": "EXTRACTED",
-                "source_file": str_path,
-                "source_location": f"L{node.start_point[0] + 1}",
-                "weight": 1.0,
-            }
-            # Stamp the resolved target file so a same-basename cross-extension
-            # sibling (foo.ts importing/re-exporting ./foo.mjs) keys its target salt
-            # by the TARGET's file rather than the importer's. Both files collapse to
-            # the base id `foo`; without this the salted lookup mis-points the target
-            # back onto the importer's own variant, a phantom self-loop (#1814).
-            if resolved_path is not None:
-                edge["target_file"] = str(resolved_path)
-            edges.append(edge)
-
-    # Emit symbol-level edges for named imports/re-exports from local/aliased files.
-    # e.g. `import { Foo, type Bar } from './bar'` → file → Foo, file → Bar (EXTRACTED)
-    # e.g. `export { Foo } from './bar'` → file → Foo (re_exports edge)
-    # Uses the same _make_id(target_stem, name) key that _extract_generic emits when
-    # defining the symbol, so these edges wire importers directly to existing symbol nodes.
-    if resolved_path is not None:
-        target_stem = _file_stem(resolved_path)
-        line = node.start_point[0] + 1
-
-        if is_reexport:
-            # Handle: export { foo, bar } from './module'
-            #         export { default as baz } from './module'
-            for child in node.children:
-                if child.type == "export_clause":
-                    for spec in child.children:
-                        if spec.type == "export_specifier":
-                            # The exported name is the local name from the source module
-                            name_node = spec.child_by_field_name("name")
-                            if name_node:
-                                sym = _read_text(name_node, source)
-                                if sym == "default":
-                                    continue  # skip default re-exports for ID matching
-                                edges.append({
-                                    "source": file_nid,
-                                    "target": _make_id(target_stem, sym),
-                                    "relation": "re_exports",
-                                    "context": "re-export",
-                                    "confidence": "EXTRACTED",
-                                    "source_file": str_path,
-                                    "source_location": f"L{line}",
-                                    "weight": 1.0,
-                                    # Which file this symbol target was synthesized
-                                    # from, so the id-remap post-pass can repoint a
-                                    # target the candidates rewrite never learns —
-                                    # a barrel defines no symbols (#1983). Transient,
-                                    # stripped at build like the #1814 stamp.
-                                    "target_file": str(resolved_path),
-                                })
-        else:
-            # Handle: import { Foo, type Bar } from './bar'
-            for child in node.children:
-                if child.type == "import_clause":
-                    for sub in child.children:
-                        if sub.type == "named_imports":
-                            for spec in sub.children:
-                                if spec.type == "import_specifier":
-                                    name_node = spec.child_by_field_name("name")
-                                    if name_node:
-                                        sym = _read_text(name_node, source)
-                                        edges.append({
-                                            "source": file_nid,
-                                            "target": _make_id(target_stem, sym),
-                                            "relation": "imports",
-                                            "context": "import",
-                                            "confidence": "EXTRACTED",
-                                            "source_file": str_path,
-                                            "source_location": f"L{line}",
-                                            "weight": 1.0,
-                                            # See the re_exports stamp above (#1983).
-                                            "target_file": str(resolved_path),
-                                        })
-
-
-def _import_java(node, source: bytes, file_nid: str, stem: str, edges: list, str_path: str, scope_stack: list[str] | None = None) -> None:
-    def _walk_scoped(n) -> str:
-        parts: list[str] = []
-        cur = n
-        while cur:
-            if cur.type == "scoped_identifier":
-                name_node = cur.child_by_field_name("name")
-                if name_node:
-                    parts.append(_read_text(name_node, source))
-                cur = cur.child_by_field_name("scope")
-            elif cur.type == "identifier":
-                parts.append(_read_text(cur, source))
-                break
-            else:
-                break
-        parts.reverse()
-        return ".".join(parts)
-
-    for child in node.children:
-        if child.type in ("scoped_identifier", "identifier"):
-            path_str = _walk_scoped(child)
-            module_name = path_str.split(".")[-1].strip("*").strip(".") or (
-                path_str.split(".")[-2] if len(path_str.split(".")) > 1 else path_str
-            )
-            if module_name:
-                tgt_nid = _make_id(module_name)
-                edges.append({
-                    "source": file_nid,
-                    "target": tgt_nid,
-                    "relation": "imports",
-                    "context": "import",
-                    "confidence": "EXTRACTED",
-                    "source_file": str_path,
-                    "source_location": f"L{node.start_point[0] + 1}",
-                    "weight": 1.0,
-                })
-            break
-
-
-def _import_c(node, source: bytes, file_nid: str, stem: str, edges: list, str_path: str, scope_stack: list[str] | None = None) -> None:
-    for child in node.children:
-        if child.type in ("string_literal", "system_lib_string", "string"):
-            raw = _read_text(child, source).strip('"<> ')
-            # Quoted includes: try to resolve to a real file so the target ID
-            # matches the node ID _extract_generic creates for that file.
-            if child.type != "system_lib_string":
-                resolved = _resolve_c_include_path(raw, str_path)
-                if resolved is not None:
-                    tgt_nid = _make_id(str(resolved))
-                    edges.append({
-                        "source": file_nid,
-                        "target": tgt_nid,
-                        "relation": "imports",
-                        "context": "import",
-                        "confidence": "EXTRACTED",
-                        "source_file": str_path,
-                        "source_location": f"L{node.start_point[0] + 1}",
-                        "weight": 1.0,
-                        # Stamp the resolved target, mirroring _import_python (#1814):
-                        # without it, an include whose header lives outside this
-                        # batch's paths keeps the raw absolute-path id no later pass
-                        # ever learns to relativize (#2243).
-                        "target_file": str(resolved),
-                    })
-                    break
-            module_name = raw.split("/")[-1].split(".")[0]
-            if module_name:
-                tgt_nid = _make_id(module_name)
-                edges.append({
-                    "source": file_nid,
-                    "target": tgt_nid,
-                    "relation": "imports",
-                    "context": "import",
-                    "confidence": "EXTRACTED",
-                    "source_file": str_path,
-                    "source_location": f"L{node.start_point[0] + 1}",
-                    "weight": 1.0,
-                })
-            break
-
-
-def _import_csharp(node, source: bytes, file_nid: str, stem: str, edges: list, str_path: str, scope_stack: list[str] | None = None) -> None:
-    text = _read_text(node, source).strip().rstrip(";")
-    if text.startswith("global "):
-        text = text[len("global "):].strip()
-    if not text.startswith("using"):
-        return
-    body = text[len("using"):].strip()
-    using_kind, alias, target_fqn = "namespace", None, body
-    if body.startswith("static "):
-        using_kind, target_fqn = "static", body[len("static "):].strip()
-    elif "=" in body:
-        lhs, rhs = body.split("=", 1)
-        using_kind, alias, target_fqn = "alias", lhs.strip(), rhs.strip()
-    if not target_fqn:
-        return
-    edges.append({
-        "source": file_nid,
-        "target": _make_id(target_fqn),
-        "relation": "imports",
-        "context": "import",
-        "confidence": "EXTRACTED",
-        "source_file": str_path,
-        "source_location": f"L{node.start_point[0] + 1}",
-        "weight": 1.0,
-        "metadata": sanitize_metadata({k: v for k, v in
-            {"using_kind": using_kind, "alias": alias, "target_fqn": target_fqn,
-             "scope_kind": "namespace" if scope_stack else "file",
-             "scope_id": scope_stack[-1] if scope_stack else None}.items() if v is not None}),
-    })
-
-
-def _import_kotlin(node, source: bytes, file_nid: str, stem: str, edges: list, str_path: str, scope_stack: list[str] | None = None) -> None:
-    # Grammar 1.1.0 (PyPI tree_sitter_kotlin) emits an `import` node whose
-    # children are the `import` keyword and a `qualified_identifier` (the dotted
-    # path), optionally followed by `.` `*` (wildcard) or `as` + `identifier`
-    # (alias). There is no `path` field. Older forks emit `import_header` with a
-    # `path` field or a bare `identifier` child; keep those branches so the
-    # extractor works across grammar generations (#2526, adapted from PR #2531
-    # by @Mustaqeem66).
-    path_node = node.child_by_field_name("path")
-    if path_node is None:
-        path_node = next(
-            (c for c in node.children if c.type == "qualified_identifier"), None
-        )
-    if path_node is not None:
-        raw = _read_text(path_node, source).strip()
-    else:
-        raw = next(
-            (_read_text(c, source).strip() for c in node.children
-             if c.type == "identifier"),
-            "",
-        )
-    if not raw:
-        return
-    # Wildcard (`import a.b.*`): imports a whole package, not a symbol. The last
-    # path segment is a PACKAGE name, so a symbol-level edge would dangle on (or
-    # collide with) an unrelated node that happens to share the package's name.
-    if raw.endswith(".*") or raw == "*" or any(c.type == "*" for c in node.children):
-        return
-    # Alias (`import a.b.C as D`): the alias is the identifier child after `as`.
-    alias = None
-    saw_as = False
-    for child in node.children:
-        if not saw_as:
-            saw_as = child.type == "as"
-        elif child.type in ("identifier", "simple_identifier"):
-            alias = _read_text(child, source).strip() or None
-            break
-    module_name = raw.split(".")[-1].strip()
-    if not module_name:
-        return
-    # Target is the bare last segment for now; _resolve_kotlin_import_targets
-    # rewrites it to the real node id via the target_fqn stamped here, once the
-    # per-file package index exists. Unresolved targets stay dangling like other
-    # languages' external imports.
-    edges.append({
-        "source": file_nid,
-        "target": _make_id(module_name),
-        "relation": "imports",
-        "context": "import",
-        "confidence": "EXTRACTED",
-        "source_file": str_path,
-        "source_location": f"L{node.start_point[0] + 1}",
-        "weight": 1.0,
-        "metadata": sanitize_metadata({k: v for k, v in
-            {"target_fqn": raw, "alias": alias}.items() if v is not None}),
-    })
-
-
-def _import_scala(node, source: bytes, file_nid: str, stem: str, edges: list, str_path: str, scope_stack: list[str] | None = None) -> None:
-    for child in node.children:
-        if child.type in ("stable_id", "identifier"):
-            raw = _read_text(child, source)
-            module_name = raw.split(".")[-1].strip("{} ")
-            if module_name and module_name != "_":
-                tgt_nid = _make_id(module_name)
-                edges.append({
-                    "source": file_nid,
-                    "target": tgt_nid,
-                    "relation": "imports",
-                    "context": "import",
-                    "confidence": "EXTRACTED",
-                    "source_file": str_path,
-                    "source_location": f"L{node.start_point[0] + 1}",
-                    "weight": 1.0,
-                })
-            break
-
-
-def _import_php(node, source: bytes, file_nid: str, stem: str, edges: list, str_path: str, scope_stack: list[str] | None = None) -> None:
-    for child in node.children:
-        if child.type in ("qualified_name", "name", "identifier"):
-            raw = _read_text(child, source)
-            module_name = raw.split("\\")[-1].strip()
-            if module_name:
-                tgt_nid = _make_id(module_name)
-                edges.append({
-                    "source": file_nid,
-                    "target": tgt_nid,
-                    "relation": "imports",
-                    "context": "import",
-                    "confidence": "EXTRACTED",
-                    "source_file": str_path,
-                    "source_location": f"L{node.start_point[0] + 1}",
-                    "weight": 1.0,
-                })
-            break
-
-
-# ── C/C++ function name helpers ───────────────────────────────────────────────
-
-def _get_c_func_name(node, source: bytes) -> str | None:
-    """Recursively unwrap declarator to find the innermost identifier (C)."""
-    if node.type == "identifier":
-        return _read_text(node, source)
-    decl = node.child_by_field_name("declarator")
-    if decl:
-        return _get_c_func_name(decl, source)
-    for child in node.children:
-        if child.type == "identifier":
-            return _read_text(child, source)
-    return None
-
-
-# ── JS/TS extra walk for arrow functions ──────────────────────────────────────
-
-
-# Node types whose value is a callable, for the JS/TS assignment / class-field
-# / function-expression forms below. Older tree-sitter-javascript grammars
-# label a function expression `function`; current ones use `function_expression`.
-
-
-# ── TS extra walk for namespace / module declarations ─────────────────────────
-
-
-# ── C# extra walk for namespace declarations ──────────────────────────────────
-
-
-# ── Swift extra walk for enum cases ──────────────────────────────────────────
-
-
-# ── Java extra walk for enum constants ───────────────────────────────────────
-
-
-# ── Language configs ──────────────────────────────────────────────────────────
-
-_PYTHON_CONFIG = LanguageConfig(
-    ts_module="tree_sitter_python",
-    class_types=frozenset({"class_definition"}),
-    function_types=frozenset({"function_definition"}),
-    import_types=frozenset({"import_statement", "import_from_statement"}),
-    call_types=frozenset({"call"}),
-    call_function_field="function",
-    call_accessor_node_types=frozenset({"attribute"}),
-    call_accessor_field="attribute",
-    call_accessor_object_field="object",
-    function_boundary_types=frozenset({"function_definition"}),
-    import_handler=_import_python,
-)
-
-_JS_CONFIG = LanguageConfig(
-    ts_module="tree_sitter_javascript",
-    class_types=frozenset({"class_declaration"}),
-    function_types=frozenset({"function_declaration", "generator_function_declaration", "method_definition"}),
-    import_types=frozenset({"import_statement", "export_statement"}),
-    call_types=frozenset({"call_expression", "new_expression"}),
-    call_function_field="function",
-    call_accessor_node_types=frozenset({"member_expression"}),
-    call_accessor_field="property",
-    call_accessor_object_field="object",
-    function_boundary_types=frozenset({"function_declaration", "generator_function_declaration", "arrow_function", "method_definition"}),
-    import_handler=_import_js,
-)
-
-_TS_CONFIG = LanguageConfig(
-    ts_module="tree_sitter_typescript",
-    ts_language_fn="language_typescript",
-    class_types=frozenset({
-        "class_declaration",
-        "abstract_class_declaration",  # TS abstract class
-        "interface_declaration",   # parity with Java/C#
-        "enum_declaration",        # named enums
-        "type_alias_declaration",  # named type aliases
-    }),
-    function_types=frozenset({"function_declaration", "generator_function_declaration", "method_definition", "method_signature"}),
-    import_types=frozenset({"import_statement", "export_statement"}),
-    call_types=frozenset({"call_expression", "new_expression"}),
-    call_function_field="function",
-    call_accessor_node_types=frozenset({"member_expression"}),
-    call_accessor_field="property",
-    call_accessor_object_field="object",
-    function_boundary_types=frozenset({"function_declaration", "generator_function_declaration", "arrow_function", "method_definition"}),
-    import_handler=_import_js,
-)
-
-# .tsx files must use the TSX grammar (JSX-aware), not the plain TypeScript grammar.
-# tree-sitter-typescript ships two languages: language_typescript (for .ts) and
-# language_tsx (for .tsx). Parsing .tsx with language_typescript silently fails on
-# JSX expressions, dropping any call_expression nested inside JSX (e.g. {fmtDate(x)}).
-_TSX_CONFIG = LanguageConfig(
-    ts_module="tree_sitter_typescript",
-    ts_language_fn="language_tsx",
-    class_types=_TS_CONFIG.class_types,
-    function_types=_TS_CONFIG.function_types,
-    import_types=_TS_CONFIG.import_types,
-    call_types=_TS_CONFIG.call_types,
-    call_function_field=_TS_CONFIG.call_function_field,
-    call_accessor_node_types=_TS_CONFIG.call_accessor_node_types,
-    call_accessor_field=_TS_CONFIG.call_accessor_field,
-    call_accessor_object_field=_TS_CONFIG.call_accessor_object_field,
-    function_boundary_types=_TS_CONFIG.function_boundary_types,
-    import_handler=_TS_CONFIG.import_handler,
-)
-
-_JAVA_CONFIG = LanguageConfig(
-    ts_module="tree_sitter_java",
-    # record_declaration shares class_declaration's name/body/interfaces fields,
-    # so it becomes a first-class type node instead of an isolated file (#1373).
-    # Enums and annotation declarations use the same name/body contract.
-    class_types=frozenset({
-        "class_declaration", "interface_declaration", "record_declaration",
-        "enum_declaration", "annotation_type_declaration",
-    }),
-    function_types=frozenset({"method_declaration", "constructor_declaration"}),
-    import_types=frozenset({"import_declaration"}),
-    # object_creation_expression (`new Foo(...)`) is handled by a dedicated Java
-    # branch in walk_calls below — its callee is in the `type` field, not `name`.
-    call_types=frozenset({"method_invocation", "object_creation_expression"}),
-    call_function_field="name",
-    call_accessor_node_types=frozenset(),
-    function_boundary_types=frozenset({"method_declaration", "constructor_declaration"}),
-    import_handler=_import_java,
-)
-
-_GROOVY_CONFIG = LanguageConfig(
-    ts_module="tree_sitter_groovy",
-    class_types=frozenset({"class_declaration", "interface_declaration"}),
-    function_types=frozenset({"method_declaration", "constructor_declaration"}),
-    import_types=frozenset({"import_declaration"}),
-    call_types=frozenset({"method_invocation"}),
-    call_function_field="name",
-    call_accessor_node_types=frozenset(),
-    function_boundary_types=frozenset({"method_declaration", "constructor_declaration"}),
-    import_handler=_import_java,
-)
-
-_C_CONFIG = LanguageConfig(
-    ts_module="tree_sitter_c",
-    class_types=frozenset(),
-    function_types=frozenset({"function_definition"}),
-    import_types=frozenset({"preproc_include"}),
-    call_types=frozenset({"call_expression"}),
-    call_function_field="function",
-    call_accessor_node_types=frozenset({"field_expression"}),
-    call_accessor_field="field",
-    function_boundary_types=frozenset({"function_definition"}),
-    import_handler=_import_c,
-    resolve_function_name_fn=_get_c_func_name,
-)
-
-_CPP_CONFIG = LanguageConfig(
-    ts_module="tree_sitter_cpp",
-    class_types=frozenset({"class_specifier", "struct_specifier"}),
-    function_types=frozenset({"function_definition"}),
-    import_types=frozenset({"preproc_include"}),
-    call_types=frozenset({"call_expression"}),
-    call_function_field="function",
-    call_accessor_node_types=frozenset({"field_expression", "qualified_identifier"}),
-    call_accessor_field="field",
-    function_boundary_types=frozenset({"function_definition"}),
-    import_handler=_import_c,
-    resolve_function_name_fn=_get_cpp_func_name,
-)
-
-_RUBY_CONFIG = LanguageConfig(
-    ts_module="tree_sitter_ruby",
-    # `module Foo` is a container node just like `class Foo` in tree-sitter's
-    # Ruby grammar (name in a `constant` child, body in `body_statement`), so it
-    # gets a node and its methods attach via `method` (#1640). Without it, plain
-    # utility/`module_function` modules produced no node and their methods hung
-    # off the file via `contains` with dot-less labels.
-    class_types=frozenset({"class", "module"}),
-    function_types=frozenset({"method", "singleton_method"}),
-    import_types=frozenset(),
-    call_types=frozenset({"call"}),
-    call_function_field="method",
-    call_accessor_node_types=frozenset(),
-    name_fallback_child_types=("constant", "scope_resolution", "identifier"),
-    body_fallback_child_types=("body_statement",),
-    function_boundary_types=frozenset({"method", "singleton_method"}),
-)
-
-_CSHARP_CONFIG = LanguageConfig(
-    ts_module="tree_sitter_c_sharp",
-    class_types=frozenset({
-        "class_declaration",
-        "interface_declaration",
-        "enum_declaration",
-        "struct_declaration",
-        "record_declaration",
-    }),
-    function_types=frozenset({"method_declaration"}),
-    import_types=frozenset({"using_directive"}),
-    call_types=frozenset({"invocation_expression"}),
-    call_function_field="function",
-    call_accessor_node_types=frozenset({"member_access_expression"}),
-    call_accessor_field="name",
-    body_fallback_child_types=("declaration_list",),
-    function_boundary_types=frozenset({"method_declaration"}),
-    import_handler=_import_csharp,
-)
-
-_KOTLIN_CONFIG = LanguageConfig(
-    ts_module="tree_sitter_kotlin",
-    class_types=frozenset({"class_declaration", "object_declaration"}),
-    function_types=frozenset({"function_declaration"}),
-    # Grammar 1.1.0 (PyPI tree_sitter_kotlin) names the import node `import`;
-    # older forks use `import_header`. Accept both (#2526).
-    import_types=frozenset({"import_header", "import"}),
-    call_types=frozenset({"call_expression"}),
-    call_function_field="",
-    call_accessor_node_types=frozenset({"navigation_expression"}),
-    call_accessor_field="",
-    # Different tree-sitter-kotlin grammar versions name plain identifier
-    # nodes differently: PyPI's `tree_sitter_kotlin` uses `identifier`,
-    # older forks use `simple_identifier`. Accept both so the extractor
-    # works across grammar generations.
-    name_fallback_child_types=("simple_identifier", "identifier"),
-    body_fallback_child_types=("function_body", "class_body", "enum_class_body"),
-    function_boundary_types=frozenset({"function_declaration"}),
-    import_handler=_import_kotlin,
-)
-
-_SCALA_CONFIG = LanguageConfig(
-    ts_module="tree_sitter_scala",
-    class_types=frozenset({"class_definition", "object_definition"}),
-    function_types=frozenset({"function_definition"}),
-    import_types=frozenset({"import_declaration"}),
-    call_types=frozenset({"call_expression"}),
-    call_function_field="",
-    call_accessor_node_types=frozenset({"field_expression"}),
-    call_accessor_field="field",
-    name_fallback_child_types=("identifier",),
-    body_fallback_child_types=("template_body",),
-    function_boundary_types=frozenset({"function_definition"}),
-    import_handler=_import_scala,
-)
-
-_PHP_CONFIG = LanguageConfig(
-    ts_module="tree_sitter_php",
-    ts_language_fn="language_php",
-    class_types=frozenset({"class_declaration"}),
-    function_types=frozenset({"function_definition", "method_declaration"}),
-    import_types=frozenset({"namespace_use_clause"}),
-    call_types=frozenset({"function_call_expression", "member_call_expression", "scoped_call_expression", "class_constant_access_expression"}),
-    static_prop_types=frozenset({"scoped_property_access_expression"}),
-    helper_fn_names=frozenset({"config"}),
-    container_bind_methods=frozenset({"bind", "singleton", "scoped", "instance"}),
-    event_listener_properties=frozenset({"listen", "subscribe"}),
-    call_function_field="function",
-    call_accessor_node_types=frozenset({"member_call_expression"}),
-    call_accessor_field="name",
-    name_fallback_child_types=("name",),
-    body_fallback_child_types=("declaration_list", "compound_statement"),
-    function_boundary_types=frozenset({"function_definition", "method_declaration"}),
-    import_handler=_import_php,
-)
-
-
-def _import_lua(node, source: bytes, file_nid: str, stem: str, edges: list, str_path: str, scope_stack: list[str] | None = None) -> None:
-    """Extract require('module') from Lua variable_declaration nodes."""
-    text = _read_text(node, source)
-    import re
-    m = re.search(r"""require\s*[\('"]\s*['"]?([^'")\s]+)""", text)
-    if m:
-        raw_module = m.group(1)
-        if raw_module:
-            tgt_nid = _resolve_lua_import_target(raw_module, str_path)
-            if tgt_nid:
-                edges.append({
-                    "source": file_nid,
-                    "target": tgt_nid,
-                    "relation": "imports",
-                    "context": "import",
-                    "confidence": "EXTRACTED",
-                    "confidence_score": 1.0,
-                    "source_file": str_path,
-                    "source_location": str(node.start_point[0] + 1),
-                    "weight": 1.0,
-                })
-
-
-_LUA_CONFIG = LanguageConfig(
-    ts_module="tree_sitter_lua",
-    ts_language_fn="language",
-    class_types=frozenset(),
-    function_types=frozenset({"function_declaration"}),
-    import_types=frozenset({"variable_declaration"}),
-    call_types=frozenset({"function_call"}),
-    call_function_field="name",
-    call_accessor_node_types=frozenset({"method_index_expression"}),
-    call_accessor_field="name",
-    name_fallback_child_types=("identifier", "method_index_expression"),
-    body_fallback_child_types=("block",),
-    function_boundary_types=frozenset({"function_declaration"}),
-    import_handler=_import_lua,
-)
-
-
-def _import_swift(node, source: bytes, file_nid: str, stem: str, edges: list, str_path: str, scope_stack: list[str] | None = None) -> list[tuple[str, str]]:
-    """Emit module-level ``imports`` edges and report the imported modules.
-
-    A Swift ``import CoreKit`` names a module, not a file path, so — unlike the
-    file-resolving JS/TS handlers — there is no existing node for the edge to
-    point at. The returned ``(id, label)`` pairs let the extractor materialize a
-    ``type=module`` anchor node so the edge survives; without it ``build_from_json``
-    prunes every Swift import edge as a dangling/external reference (#1327).
-    """
-    modules: list[tuple[str, str]] = []
-    for child in node.children:
-        if child.type == "identifier":
-            raw = _read_text(child, source)
-            tgt_nid = _make_id(raw)
-            edges.append({
-                "source": file_nid,
-                "target": tgt_nid,
-                "relation": "imports",
-                "context": "import",
-                "confidence": "EXTRACTED",
-                "source_file": str_path,
-                "source_location": f"L{node.start_point[0] + 1}",
-                "weight": 1.0,
-            })
-            modules.append((tgt_nid, raw))
-            break
-    return modules
-
-
-_SWIFT_CONFIG = LanguageConfig(
-    ts_module="tree_sitter_swift",
-    class_types=frozenset({"class_declaration", "protocol_declaration"}),
-    function_types=frozenset({"function_declaration", "init_declaration", "deinit_declaration", "subscript_declaration"}),
-    import_types=frozenset({"import_declaration"}),
-    call_types=frozenset({"call_expression"}),
-    call_function_field="",
-    call_accessor_node_types=frozenset({"navigation_expression"}),
-    call_accessor_field="",
-    name_fallback_child_types=("simple_identifier", "type_identifier", "user_type"),
-    body_fallback_child_types=("class_body", "protocol_body", "function_body", "enum_class_body"),
-    function_boundary_types=frozenset({"function_declaration", "init_declaration", "deinit_declaration", "subscript_declaration"}),
-    import_handler=_import_swift,
-)
-
-# ── Ruby local type inference (for member-call resolution) ─────────────────────
-
-
-# `Const = <factory>(...)` shapes that define a lightweight class named after the
-# constant. tree-sitter parses each as an `assignment`, not a `class`, so the
-# generic class branch never saw them (#1640).
-
-
-# ── Generic extractor ─────────────────────────────────────────────────────────
-
-
-# ── Python rationale extraction ───────────────────────────────────────────────
-
-_RATIONALE_PREFIXES = ("# NOTE:", "# IMPORTANT:", "# HACK:", "# WHY:", "# RATIONALE:", "# TODO:", "# FIXME:")
-
-
-def _shorten_rationale_label(text: str, width: int = 80) -> str:
-    """Collapse whitespace and truncate ``text`` to ``width`` chars for a
-    rationale node label, cutting on a word boundary rather than mid-word.
-    Shared by the Python and JS/TS rationale extractors (#2206).
-
-    ``textwrap.shorten`` collapses to just the placeholder when the first
-    "word" alone exceeds ``width`` (e.g. a docstring/comment that opens with
-    an unbroken URL) -- that would emit a content-free label, so fall back to
-    a plain character truncation of the normalized text in that case.
-    """
-    label = textwrap.shorten(text, width=width, placeholder="…")
-    if label in ("", "…"):
-        flat = " ".join(text.split())
-        label = flat if len(flat) <= width else flat[: width - 1] + "…"
-    return label
-
-
-def _is_autogenerated_python(source: bytes) -> bool:
-    """Return True if this Python file is auto-generated and its module docstring is noise.
-
-    Covers: Alembic/Flask-Migrate revisions, Django migrations, protobuf/gRPC/OpenAPI stubs.
-    Module docstrings in these files are change annotations or boilerplate, not rationale.
-    """
-    head = source[:2048].decode("utf-8", errors="replace")
-    # Generic generated-file markers (protobuf, gRPC, OpenAPI codegen, etc.)
-    if any(m in head for m in ("DO NOT EDIT", "@generated", "Generated by the protocol buffer")):
-        return True
-    # Alembic / Flask-Migrate revision files
-    if (re.search(r"^revision\s*[:=]", head, re.MULTILINE)
-            and "def upgrade(" in head
-            and "down_revision" in head):
-        return True
-    # Django migrations
-    if "class Migration(migrations.Migration)" in head and "operations" in head:
-        return True
-    return False
-
-
-def _extract_python_rationale(path: Path, result: dict) -> None:
-    """Post-pass: extract docstrings and rationale comments from Python source.
-    Mutates result in-place by appending to result['nodes'] and result['edges'].
-    """
-    try:
-        import tree_sitter_python as tspython
-        from tree_sitter import Language, Parser
-        language = Language(tspython.language())
-        parser = Parser(language)
-        source = path.read_bytes()
-        tree = parser.parse(source)
-        root = tree.root_node
-    except Exception:
-        return
-
-    stem = _file_stem(path)
-    str_path = str(path)
-    nodes = result["nodes"]
-    edges = result["edges"]
-    seen_ids = {n["id"] for n in nodes}
-    file_nid = _make_id(str(path))
-
-    def _get_docstring(body_node) -> tuple[str, int] | None:
-        if not body_node:
-            return None
-        for child in body_node.children:
-            if child.type == "expression_statement":
-                for sub in child.children:
-                    if sub.type in ("string", "concatenated_string"):
-                        text = source[sub.start_byte:sub.end_byte].decode("utf-8", errors="replace")
-                        text = text.strip("\"'").strip('"""').strip("'''").strip()
-                        if len(text) > 20:
-                            return text, child.start_point[0] + 1
-            break
-        return None
-
-    def _add_rationale(text: str, line: int, parent_nid: str) -> None:
-        # Normalize whitespace before truncating, not after: slicing raw text
-        # first can land mid-word, leave a run of literal spaces where a
-        # newline + indentation used to be, or end on a "." that turns into
-        # an Obsidian "..md" filename once export.py appends the extension.
-        label = _shorten_rationale_label(text)
-        rid = _make_id(stem, "rationale", str(line))
-        if rid not in seen_ids:
-            seen_ids.add(rid)
-            nodes.append({
-                "id": rid,
-                "label": label,
-                "file_type": "rationale",
-                "source_file": str_path,
-                "source_location": f"L{line}",
-            })
-        edges.append({
-            "source": rid,
-            "target": parent_nid,
-            "relation": "rationale_for",
-            "confidence": "EXTRACTED",
-            "source_file": str_path,
-            "source_location": f"L{line}",
-            "weight": 1.0,
-        })
-
-    # Module-level docstring — skip for auto-generated files (Alembic, Django
-    # migrations, protobuf stubs, etc.) whose module docstrings are revision
-    # annotations, not architectural rationale.
-    if not _is_autogenerated_python(source):
-        ds = _get_docstring(root)
-        if ds:
-            _add_rationale(ds[0], ds[1], file_nid)
-
-    # Class and function docstrings
-    def walk_docstrings(node, parent_nid: str) -> None:
-        t = node.type
-        if t == "class_definition":
-            name_node = node.child_by_field_name("name")
-            body = node.child_by_field_name("body")
-            if name_node and body:
-                class_name = source[name_node.start_byte:name_node.end_byte].decode("utf-8", errors="replace")
-                nid = _make_id(stem, class_name)
-                ds = _get_docstring(body)
-                if ds:
-                    _add_rationale(ds[0], ds[1], nid)
-                for child in body.children:
-                    walk_docstrings(child, nid)
-            return
-        if t == "function_definition":
-            name_node = node.child_by_field_name("name")
-            body = node.child_by_field_name("body")
-            if name_node and body:
-                func_name = source[name_node.start_byte:name_node.end_byte].decode("utf-8", errors="replace")
-                nid = _make_id(parent_nid, func_name) if parent_nid != file_nid else _make_id(stem, func_name)
-                ds = _get_docstring(body)
-                if ds:
-                    _add_rationale(ds[0], ds[1], nid)
-            return
-        for child in node.children:
-            walk_docstrings(child, parent_nid)
-
-    walk_docstrings(root, file_nid)
-
-    # Rationale comments (# NOTE:, # IMPORTANT:, etc.)
-    source_text = source.decode("utf-8", errors="replace")
-    for lineno, line_text in enumerate(source_text.splitlines(), start=1):
-        stripped = line_text.strip()
-        if any(stripped.startswith(p) for p in _RATIONALE_PREFIXES):
-            _add_rationale(stripped, lineno, file_nid)
-
-
-# ── Public API ────────────────────────────────────────────────────────────────
-
-def extract_python(path: Path) -> dict:
-    """Extract classes, functions, and imports from a .py file via tree-sitter AST."""
-    result = _extract_generic(path, _PYTHON_CONFIG)
-    if "error" not in result:
-        _extract_python_rationale(path, result)
-    return result
-
-
-def extract_js(path: Path) -> dict:
-    """Extract classes, functions, arrow functions, and imports from a .js/.ts/.tsx/.mts/.cts file."""
-    suffix = path.suffix.lower()
-    if suffix == ".tsx":
-        config = _TSX_CONFIG
-    elif suffix in (".ts", ".mts", ".cts"):
-        config = _TS_CONFIG
-    else:
-        config = _JS_CONFIG
-    result = _extract_generic(path, config)
-    if "error" not in result:
-        _extract_js_rationale(path, result)
-        _rescue_js_dynamic_imports(path, result)
-    return result
-
-
-def _rescue_js_dynamic_imports(path: Path, result: dict) -> None:
-    """Recover ``import('…')`` edges the AST pass does not emit for plain JS/TS.
-
-    tree-sitter models ``await import('x')`` as a ``call_expression``, not an
-    ``import_statement``, so the specifier only reaches the graph when
-    ``walk_calls`` visits that call — which it never does at module scope
-    (only function bodies are walked for calls). The Svelte/Astro/Vue
-    extractors already patch the same gap by regex because their AST pass
-    fails wholesale; plain ``.ts``/``.js`` was left out on the reasoning that
-    its AST pass "works". It works for STATIC imports; dynamic ones outside a
-    walked body fell through silently (#2575), and because they cluster under
-    hub modules the loss compounds with ``affected`` traversal depth.
-
-    Dedupe: a dynamic import the AST pass DID capture is already in the graph
-    as an ``imports_from`` edge marked ``deferred`` (``_dynamic_import_js``).
-    Re-emitting it here as a second ``dynamic_import`` edge would state the
-    same fact twice, so a match whose resolved target already has a deferred
-    edge FROM THIS FILE'S NODE is skipped. The source check matters: the AST
-    pass anchors the edge on the enclosing function when the ``import()`` is
-    written inside one, and that is a different fact from "this file depends on
-    that module" — the only one file-level traversal can use (#2584).
-
-    Regex false positives in comments/strings are the precedented trade of
-    the Svelte/Vue rescues; a ``//``-prefix guard covers the common case.
-    """
-    try:
-        import re as _re
-        src = path.read_text(encoding="utf-8", errors="replace")
-        if "import(" not in src:  # cheap bail — most files have none
-            return
-        existing_ids = {n["id"] for n in result.get("nodes", [])}
-        file_node_id = _make_id(str(path))
-        aliases = _load_tsconfig_aliases(path.parent)
-        base_url = _load_tsconfig_base_url(path.parent)
-        deferred_ids: set[str] = set()
-        deferred_files: set[str] = set()
-        rescued_targets: set[str] = set()
-        for e in result.get("edges", []):
-            # Only a FILE-level deferred edge makes the rescue redundant (#2584).
-            #
-            # `_dynamic_import_js` emits `caller_nid -> target`, and `caller_nid` is this
-            # file's node only when the `import()` sits at module scope. Written inside a
-            # function it is that function's node — a different fact, at a granularity
-            # `affected` does not walk. Matching on target alone treated the two as one and
-            # skipped the rescue, so a dynamic import inside a function ended up with no
-            # file-level edge at all. The reverse walk then reached the enclosing function
-            # and stopped: the only edge pointing at it is `contains`, deliberately kept out
-            # of DEFAULT_AFFECTED_RELATIONS.
-            #
-            # Measured on a ~700-file TS repo: `affected --depth 3` returned 39 of 49 truly
-            # affected files (recall 0.80, precision 1.00) and deeper traversal did not help,
-            # which is a dead end rather than a depth limit. It stayed hidden because the
-            # usual case still resolves — when the next importer imports that exact symbol
-            # by name there IS an edge into the function. Switch that importer to
-            # `import * as ns` or a side-effect `import './dyn'` and the same graph goes
-            # silent.
-            if (e.get("deferred") and e.get("relation") == "imports_from"
-                    and e.get("source") == file_node_id):
-                deferred_ids.add(e.get("target"))
-                tf = e.get("target_file")
-                if tf:
-                    try:
-                        deferred_files.add(str(Path(tf).resolve()))
-                    except OSError:
-                        deferred_files.add(str(tf))
-        # `(?<!\w)` so `fooimport('x')` and `_import('x')` do not match. The
-        # backtick alternative mirrors _dynamic_import_js's template-string
-        # handling: a literal `import(`./x`)` resolves, `${`-substituted ones
-        # are excluded (no `$` in the class) as statically unresolvable.
-        for m in _re.finditer(
-            r"""(?<!\w)import\(\s*(?:'([^'\n]+)'|"([^"\n]+)"|`([^`$\n]+)`)\s*\)""",
-            src,
-        ):
-            raw = m.group(1) or m.group(2) or m.group(3)
-            if not raw:
-                continue
-            line_start = src.rfind("\n", 0, m.start()) + 1
-            if "//" in src[line_start:m.start()]:
-                continue  # line-commented-out import
-            resolution = _resolve_rescued_specifier(path, raw, aliases, base_url)
-            if resolution is None:
-                continue
-            node_id, _stub_sf, resolved_file = resolution
-            # AST-captured already: same resolved target id, same resolved
-            # on-disk file, or the engine's ref-namespaced external id.
-            if node_id in deferred_ids or _make_id("ref", raw) in deferred_ids:
-                continue
-            if resolved_file is not None:
-                try:
-                    if str(resolved_file.resolve()) in deferred_files:
-                        continue
-                except OSError:
-                    pass
-            # One file depending on one module is one file-level fact, however many
-            # call sites defer it. Pre-existing (two module-scope `import('./x')` in one
-            # file already emitted two identical edges on v8), but #2584 routes every
-            # in-function dynamic import through here too, which would turn an edge case
-            # into the common one — a hub module deferred from eight functions of the same
-            # file would carry eight identical arrows.
-            emit_key = str(resolved_file.resolve()) if resolved_file is not None else raw
-            if emit_key in rescued_targets:
-                continue
-            rescued_targets.add(emit_key)
-            _emit_rescued_import(
-                result, existing_ids, file_node_id, path, raw,
-                "dynamic_import", aliases, base_url,
-            )
-    except Exception:
-        pass
-
-
-# ── JS/TS rationale + doc-reference extraction ────────────────────────────────
-#
-# Parity with _extract_python_rationale: Python files get rationale nodes from
-# docstrings and `# NOTE:`-style comments, but JS/TS comments were discarded
-# entirely. That silently drops two high-value signals in mixed corpora:
-#   1. rationale comments (`// NOTE:`, `// WHY:`, ...) — same as Python;
-#   2. architecture-decision references (`ADR-0011`, `RFC 793`) that teams
-#      conventionally cite in file/function headers. These are the natural
-#      join points between code and design docs in the same graph — without
-#      them, code<->ADR edges never form even when the code cites the ADR.
-
-_JS_RATIONALE_PREFIXES = (
-    "// NOTE:", "// IMPORTANT:", "// HACK:", "// WHY:", "// RATIONALE:",
-    "// TODO:", "// FIXME:",
-    "* NOTE:", "* IMPORTANT:", "* HACK:", "* WHY:", "* RATIONALE:",
-    "* TODO:", "* FIXME:",
-)
-
-# Doc-reference tokens worth first-classing as graph nodes. Deliberately
-# conservative: ADR-NNNN (Architecture Decision Records, any zero padding)
-# and RFC NNNN / RFC-NNNN.
-_JS_DOC_REF_RE = re.compile(r"\b(ADR[- ]?\d{1,5}|RFC[- ]?\d{1,5})\b", re.IGNORECASE)
-
-# Only look for doc references inside comments, not string literals or code.
-_JS_COMMENT_LINE_RE = re.compile(r"^\s*(//|/\*|\*)")
-
-
-def _extract_js_rationale(path: Path, result: dict) -> None:
-    """Post-pass: extract rationale comments and doc references from JS/TS source.
-    Mutates result in-place by appending to result['nodes'] and result['edges'].
-    """
-    try:
-        source_text = path.read_text(encoding="utf-8", errors="replace")
-    except Exception:
-        return
-
-    stem = _file_stem(path)
-    str_path = str(path)
-    nodes = result["nodes"]
-    edges = result["edges"]
-    seen_ids = {n["id"] for n in nodes}
-    file_nid = _make_id(str(path))
-    seen_doc_refs: set[str] = set()
-
-    def _add_rationale(text: str, line: int) -> None:
-        # Normalize whitespace before truncating, not after: slicing raw text
-        # first can land mid-word, leave a run of literal spaces where a
-        # newline + indentation used to be, or end on a "." that turns into
-        # an Obsidian "..md" filename once export.py appends the extension.
-        label = _shorten_rationale_label(text)
-        rid = _make_id(stem, "rationale", str(line))
-        if rid not in seen_ids:
-            seen_ids.add(rid)
-            nodes.append({
-                "id": rid,
-                "label": label,
-                "file_type": "rationale",
-                "source_file": str_path,
-                "source_location": f"L{line}",
-            })
-        edges.append({
-            "source": rid,
-            "target": file_nid,
-            "relation": "rationale_for",
-            "confidence": "EXTRACTED",
-            "source_file": str_path,
-            "source_location": f"L{line}",
-            "weight": 1.0,
-        })
-
-    def _add_doc_ref(token: str, line: int) -> None:
-        # Normalize "adr 11" / "ADR-0011" spellings to a canonical "ADR-0011"
-        # style label so references to the same document collapse to one node.
-        kind, num = re.match(r"([A-Za-z]+)[- ]?(\d+)", token).groups()
-        kind = kind.upper()
-        label = f"{kind}-{num.zfill(4)}" if kind == "ADR" else f"{kind}-{num}"
-        if label in seen_doc_refs:
-            return
-        seen_doc_refs.add(label)
-        rid = _make_id("docref", label)
-        if rid not in seen_ids:
-            seen_ids.add(rid)
-            nodes.append({
-                "id": rid,
-                "label": label,
-                "file_type": "doc_ref",
-                "source_file": str_path,
-                "source_location": f"L{line}",
-            })
-        edges.append({
-            "source": file_nid,
-            "target": rid,
-            "relation": "cites",
-            "confidence": "EXTRACTED",
-            "source_file": str_path,
-            "source_location": f"L{line}",
-            "weight": 1.0,
-        })
-
-    for lineno, line_text in enumerate(source_text.splitlines(), start=1):
-        stripped = line_text.strip()
-        if any(stripped.startswith(p) for p in _JS_RATIONALE_PREFIXES):
-            _add_rationale(stripped.lstrip("/* "), lineno)
-        if _JS_COMMENT_LINE_RE.match(line_text):
-            for m in _JS_DOC_REF_RE.finditer(stripped):
-                _add_doc_ref(m.group(1), lineno)
-
-
-def _resolve_rescued_specifier(
-    path: Path,
-    raw: str,
-    aliases,
-    base_url,
-) -> "tuple[str, str, Path | None] | None":
-    """Resolve a regex-rescued import specifier the way ``_import_js`` does.
-
-    Returns ``(node_id, stub_source_file, resolved_file)`` — ``resolved_file``
-    is the target as a real on-disk file, or None when the specifier is
-    external or dangling. Returns None when no target can be minted at all
-    (empty bare-import segment). Split out of :func:`_emit_rescued_import` so
-    :func:`_rescue_js_dynamic_imports` can resolve a match FIRST and skip
-    specifiers the AST pass already emitted, without duplicating the
-    resolution rules.
-    """
-    if raw.startswith("."):
-        resolved = _resolve_js_module_path(
-            Path(os.path.normpath(path.parent / raw))
-        )
-        resolved_file = resolved if resolved is not None and resolved.is_file() else None
-        return _make_id(str(resolved)), str(resolved), resolved_file
-    # Check tsconfig.json path aliases (e.g. "$lib/" -> "src/lib/",
-    # "@/" -> "src/") before treating as external. Mirrors _import_js
-    # logic so alias imports resolve to the same file node IDs the
-    # extractor creates (#701).
-    resolved_alias = _resolve_tsconfig_alias(raw, aliases, base_url=base_url)
-    if resolved_alias is not None:
-        resolved_alias = _resolve_js_module_path(resolved_alias)
-        resolved_file = (resolved_alias if resolved_alias is not None
-                         and resolved_alias.is_file() else None)
-        return _make_id(str(resolved_alias)), str(resolved_alias), resolved_file
-    # Bare/scoped import (node_modules) - use last segment;
-    # build_from_json drops as external if no matching node exists.
-    module_name = raw.split("/")[-1]
-    if not module_name:
-        return None
-    return _make_id(module_name), raw, None
-
-
-def _emit_rescued_import(
-    result: dict,
-    existing_ids: set,
-    file_node_id: str,
-    path: Path,
-    raw: str,
-    relation: str,
-    aliases,
-    base_url,
-) -> None:
-    """Shared edge/stub emit for the Svelte/Astro/Vue regex-rescue import passes.
-
-    Resolves the specifier the same way ``_import_js`` does — relative paths and
-    tsconfig aliases both go through :func:`_resolve_js_module_path` so
-    extensionless specifiers probe real on-disk extensions (``../lib/content``
-    -> ``content.ts``) instead of a naive ``.js``->``.ts`` suffix swap.
-
-    When the resolved target is a real file on disk, mirror ``_import_js``:
-    emit ONLY the edge, stamped with ``target_file``, and mint no stub node.
-    The #2169 canonicalization loop in :func:`extract` reads the stamp and
-    repoints the edge at the real file node's canonical id. Minting a stub
-    here would carry an absolute-path-derived id when the input path is
-    absolute — a ghost node (e.g. ``private_tmp_..._src_lib_content``)
-    duplicating the real ``src_lib_content`` node and clobbering its label on
-    dedupe (#2195). Stub nodes are still minted for unresolved specifiers
-    (externals, not-yet-created files) so prior behavior is preserved.
-    """
-    resolution = _resolve_rescued_specifier(path, raw, aliases, base_url)
-    if resolution is None:
-        return
-    node_id, stub_source_file, resolved_file = resolution
-    edge = {
-        "source": file_node_id, "target": node_id,
-        "relation": relation, "confidence": "EXTRACTED",
-        "source_file": str(path),
-    }
-    if resolved_file is not None:
-        # Real file on disk: edge only (no stub node), stamped so the #2169
-        # canonicalization pass repoints it at the real node (#2195).
-        edge["target_file"] = str(resolved_file)
-        result.setdefault("edges", []).append(edge)
-        return
-    if node_id in existing_ids:
-        # Edge target already a real node - just add the edge, don't add a node.
-        result.setdefault("edges", []).append(edge)
-        return
-    result.setdefault("nodes", []).append({
-        "id": node_id, "label": raw,
-        "file_type": "code", "source_file": stub_source_file,
-        "confidence": "EXTRACTED",
-    })
-    result.setdefault("edges", []).append(edge)
-    existing_ids.add(node_id)
-
-
-def extract_svelte(path: Path) -> dict:
-    """Extract imports from .svelte files: script-block via JS AST + template regex fallback.
-
-    Tree-sitter only sees the <script> block. Svelte template syntax like
-    {#await import('./X.svelte')} lives in the markup layer and is invisible
-    to the JS parser, so a regex pass covers those dynamic imports.
-    """
-    result = _extract_generic(path, _JS_CONFIG)
-    try:
-        import re as _re
-        src = path.read_text(encoding="utf-8", errors="replace")
-        existing_ids = {n["id"] for n in result.get("nodes", [])}
-        # Source file node ID must match the one _extract_generic creates:
-        # _make_id(str(path)) - single arg, no stem prefix. Otherwise the source
-        # endpoint is a phantom node and build_from_json drops the edge (#701).
-        file_node_id = _make_id(str(path))
-        aliases = _load_tsconfig_aliases(path.parent)
-        base_url = _load_tsconfig_base_url(path.parent)
-        for m in _re.finditer(r"""import\(\s*['"]([^'"]+)['"]\s*\)""", src):
-            raw = m.group(1)
-            if not raw:
-                continue
-            # Resolution + emit shared with the static pass below: relative
-            # paths and tsconfig aliases probe real on-disk extensions (#716,
-            # #701), and a target that IS a real file emits an edge stamped
-            # with target_file instead of an absolute-id ghost stub (#2195).
-            _emit_rescued_import(
-                result, existing_ids, file_node_id, path, raw,
-                "dynamic_import", aliases, base_url,
-            )
-        # Static imports inside <script> blocks. The JS tree-sitter parser fed
-        # the full .svelte file produces a top-level ERROR node (HTML markup
-        # is not valid JS), so import_statement nodes are never reached and
-        # static imports are silently dropped (#713). Regex over each script
-        # body recovers them.
-        script_re = _re.compile(
-            r"<script\b[^>]*>([\s\S]*?)</script\s*>", _re.IGNORECASE
-        )
-        static_import_re = _re.compile(
-            r"""import\s+(?:[^'"`;]+?\s+from\s+)?['"]([^'"]+)['"]"""
-        )
-        for script_match in script_re.finditer(src):
-            script_body = script_match.group(1)
-            for m in static_import_re.finditer(script_body):
-                raw = m.group(1)
-                if not raw:
-                    continue
-                _emit_rescued_import(
-                    result, existing_ids, file_node_id, path, raw,
-                    "imports_from", aliases, base_url,
-                )
-    except Exception:
-        pass
-    return result
-
-
-def extract_astro(path: Path) -> dict:
-    """Extract imports from .astro files: frontmatter (TS) + template regex fallback.
-
-    Astro files start with a ``---\\n...\\n---`` frontmatter block of TypeScript
-    setup code (where almost all imports live), followed by an HTML-with-expressions
-    template body, and optionally ``<script>`` blocks for client-side JS. Tree-sitter
-    only sees the file usefully through the frontmatter — feeding the whole file to
-    the JS parser produces a top-level ERROR node because the template is not valid
-    JS, so ``import_statement`` nodes are never reached and static imports are
-    silently dropped (#850). Mirrors :func:`extract_svelte` — same regex-rescue
-    approach, scanning the frontmatter block and any client-side ``<script>`` blocks
-    for static and dynamic imports.
-    """
-    result = _extract_generic(path, _JS_CONFIG)
-    try:
-        import re as _re
-        src = path.read_text(encoding="utf-8", errors="replace")
-        existing_ids = {n["id"] for n in result.get("nodes", [])}
-        file_node_id = _make_id(str(path))
-        aliases = _load_tsconfig_aliases(path.parent)
-        base_url = _load_tsconfig_base_url(path.parent)
-        # Dynamic imports anywhere in the file: `import('./X.astro')` is legal in
-        # frontmatter setup code and inside expression slots.
-        for m in _re.finditer(r"""import\(\s*['"]([^'"]+)['"]\s*\)""", src):
-            raw = m.group(1)
-            if not raw:
-                continue
-            _emit_rescued_import(
-                result, existing_ids, file_node_id, path, raw,
-                "dynamic_import", aliases, base_url,
-            )
-        # Static imports: scan the `---...---` frontmatter at the file head plus any
-        # client-side <script> blocks. Both are TS/JS regions but live inside a file
-        # the JS tree-sitter parser cannot validate as a whole.
-        frontmatter_re = _re.compile(
-            r"\A\s*---\s*\r?\n([\s\S]*?)\r?\n---\s*(?:\r?\n|\Z)"
-        )
-        script_re = _re.compile(
-            r"<script\b[^>]*>([\s\S]*?)</script\s*>", _re.IGNORECASE
-        )
-        static_import_re = _re.compile(
-            r"""import\s+(?:[^'"`;]+?\s+from\s+)?['"]([^'"]+)['"]"""
-        )
-        regions: list[str] = []
-        fm = frontmatter_re.search(src)
-        if fm:
-            regions.append(fm.group(1))
-        for script_match in script_re.finditer(src):
-            regions.append(script_match.group(1))
-        for region in regions:
-            for m in static_import_re.finditer(region):
-                raw = m.group(1)
-                if not raw:
-                    continue
-                _emit_rescued_import(
-                    result, existing_ids, file_node_id, path, raw,
-                    "imports_from", aliases, base_url,
-                )
-    except Exception:
-        pass
-    return result
-
-
-# The open-tag matcher skips over quoted attribute values so a `>` inside one
-# (e.g. Vue 3.3+ generic components: `<script setup lang="ts"
-# generic="T extends Record<string, unknown>">`) doesn't prematurely end the tag.
-
-
-def extract_vue(path: Path) -> dict:
-    """Extract imports, symbols, and type refs from a ``.vue`` SFC.
-
-    Masks the non-``<script>`` regions and parses the script with the grammar
-    its ``lang`` implies (``tsx``→TSX, ``js``/``jsx``→JS, ``ts`` or unset→TS;
-    TS is a superset of JS so it is a safe default). A regex pass then recovers
-    ``import('…')`` dynamic imports the AST does not edge.
-    """
-    try:
-        src = path.read_text(encoding="utf-8", errors="replace")
-    except OSError:
-        return {"nodes": [], "edges": []}
-
-    masked, lang = _vue_mask_non_script(src)
-    if lang == "tsx":
-        config = _TSX_CONFIG
-    elif lang in ("js", "jsx"):
-        config = _JS_CONFIG
-    else:  # "ts" or unspecified — default to the TS grammar (superset of JS)
-        config = _TS_CONFIG
-
-    result = _extract_generic(path, config, source_override=masked.encode("utf-8"))
-
-    # Dynamic `import('…')` calls aren't edged by the AST pass; recover by regex,
-    # mirroring extract_svelte/extract_astro.
-    try:
-        existing_ids = {n["id"] for n in result.get("nodes", [])}
-        file_node_id = _make_id(str(path))
-        aliases = _load_tsconfig_aliases(path.parent)
-        base_url = _load_tsconfig_base_url(path.parent)
-        for m in re.finditer(r"""import\(\s*['"]([^'"]+)['"]\s*\)""", src):
-            raw = m.group(1)
-            if not raw:
-                continue
-            _emit_rescued_import(
-                result, existing_ids, file_node_id, path, raw,
-                "dynamic_import", aliases, base_url,
-            )
-    except Exception:
-        pass
-    return result
-
-
-def extract_java(path: Path) -> dict:
-    """Extract classes, interfaces, methods, constructors, and imports from a .java file."""
-    return _extract_generic(path, _JAVA_CONFIG)
-
-
-def _is_spock_file(path: Path, ts_result: dict) -> bool:
-    """Return True when the file contains Spock-style ``def "feature"()`` methods
-    that tree-sitter-groovy cannot parse, detected by checking the raw source."""
-    import re as _re
-    _SPOCK_FEATURE_RE = _re.compile(r"""^\s*def\s+[\"']""", _re.MULTILINE)
-    try:
-        return bool(_SPOCK_FEATURE_RE.search(path.read_text(errors="replace")))
-    except OSError:
-        return False
-
-
-def _extract_spock_fallback(path: Path, ts_result: dict) -> dict:
-    """Regex-based fallback for Spock spec files where tree-sitter-groovy cannot parse
-    ``def "feature name"()`` methods. Merges import edges from the tree-sitter pass
-    (which survive reliably) with class and feature-method nodes extracted via regex.
-    """
-    import re as _re
-    source = path.read_text(errors="replace")
-    str_path = str(path)
-    stem = _file_stem(path)
-
-    # Only keep the file node from the tree-sitter pass (guaranteed present and
-    # correctly IDed) plus all import edges.  All other ts nodes are discarded to
-    # avoid orphaned method/constructor nodes whose parent edges were dropped.
-    file_node = next((n for n in ts_result.get("nodes", []) if n.get("label") == path.name), None)
-    nodes: list[dict] = [file_node] if file_node else []
-    edges: list[dict] = [e for e in ts_result.get("edges", []) if e.get("context") == "import"]
-    seen_ids: set[str] = {n["id"] for n in nodes}
-
-    def _add_node(nid: str, label: str, line: int) -> None:
-        if nid not in seen_ids:
-            seen_ids.add(nid)
-            nodes.append({
-                "id": nid,
-                "label": label,
-                "file_type": "code",
-                "source_file": str_path,
-                "source_location": f"L{line}",
-            })
-
-    def _add_edge(src: str, tgt: str, relation: str, line: int,
-                  confidence: str = "EXTRACTED") -> None:
-        edges.append({
-            "source": src,
-            "target": tgt,
-            "relation": relation,
-            "confidence": confidence,
-            "source_file": str_path,
-            "source_location": f"L{line}",
-            "weight": 1.0,
-        })
-
-    lines_text = source.splitlines()
-
-    # Extract class declarations
-    class_re = _re.compile(r"^\s*(?:[\w@]+\s+)*class\s+(\w+)")
-    # Extract Spock feature methods: def "..." () or def '...' ()
-    # Two separate capture groups per quote style so apostrophes inside
-    # double-quoted names (e.g. "shouldn't") are captured correctly.
-    feature_re = _re.compile(r"""^\s*def\s+(?:\"([^\"]+)\"|'([^']+)')\s*\(""")
-    # Extract plain def methods (non-string names) as well
-    plain_method_re = _re.compile(r"""^\s*def\s+(\w+)\s*\(""")
-
-    current_class_nid: str | None = None
-    file_nid = _make_id(str_path)
-
-    # Ensure the file node exists (tree-sitter pass may have emitted it)
-    if file_nid not in seen_ids:
-        _add_node(file_nid, path.name, 1)
-
-    for lineno, line_text in enumerate(lines_text, start=1):
-        cm = class_re.match(line_text)
-        if cm:
-            class_name = cm.group(1)
-            class_nid = _make_id(stem, class_name)
-            _add_node(class_nid, class_name, lineno)
-            _add_edge(file_nid, class_nid, "contains", lineno)
-            current_class_nid = class_nid
-            continue
-
-        if current_class_nid is None:
-            continue
-
-        fm = feature_re.match(line_text)
-        if fm:
-            method_name = fm.group(1) or fm.group(2)
-            method_label = f'"{method_name}"'
-            method_nid = _make_id(current_class_nid, method_name)
-            _add_node(method_nid, method_label, lineno)
-            _add_edge(current_class_nid, method_nid, "method", lineno)
-            continue
-
-        pm = plain_method_re.match(line_text)
-        if pm:
-            method_name = pm.group(1)
-            if method_name not in ("if", "while", "for", "switch", "catch"):
-                method_label = f".{method_name}()"
-                method_nid = _make_id(current_class_nid, method_name)
-                _add_node(method_nid, method_label, lineno)
-                _add_edge(current_class_nid, method_nid, "method", lineno)
-
-    return {"nodes": nodes, "edges": edges}
-
-
-def extract_groovy(path: Path) -> dict:
-    """Extract classes, methods, constructors, and imports from a .groovy/.gradle file.
-
-    Falls back to a regex-based Spock extractor when tree-sitter-groovy cannot parse
-    ``def "feature name"()`` methods (common in Spock specification classes).
-    """
-    result = _extract_generic(path, _GROOVY_CONFIG)
-    if _is_spock_file(path, result):
-        result = _extract_spock_fallback(path, result)
-    return result
-
-
-def extract_c(path: Path) -> dict:
-    """Extract functions and includes from a .c/.h file."""
-    return _extract_generic(path, _C_CONFIG)
-
-
-def extract_cpp(path: Path) -> dict:
-    """Extract functions, classes, and includes from a .cpp/.cc/.cxx/.hpp file."""
-    return _extract_generic(path, _CPP_CONFIG)
-
-
-def extract_ruby(path: Path) -> dict:
-    """Extract classes, methods, singleton methods, and calls from a .rb file."""
-    return _extract_generic(path, _RUBY_CONFIG)
-
-
-def extract_csharp(path: Path) -> dict:
-    """Extract C# type declarations, methods, namespaces, and usings from a .cs file."""
-    return _extract_generic(path, _CSHARP_CONFIG)
-
-
-def extract_kotlin(path: Path) -> dict:
-    """Extract classes, objects, functions, and imports from a .kt/.kts file."""
-    return _extract_generic(path, _KOTLIN_CONFIG)
-
-
-def extract_scala(path: Path) -> dict:
-    """Extract classes, objects, functions, and imports from a .scala file."""
-    return _extract_generic(path, _SCALA_CONFIG)
-
-
-def extract_php(path: Path) -> dict:
-    """Extract classes, functions, methods, namespace uses, and calls from a .php file."""
-    return _extract_generic(path, _PHP_CONFIG)
-
-
-# One level of balanced parens (e.g. `Foo #(Bar #(int))`) — bounded so malformed
-# input cannot trigger pathological backtracking.
-
-
-def extract_lua(path: Path) -> dict:
-    """Extract functions, methods, require() imports, and calls from a .lua file."""
-    return _extract_generic(path, _LUA_CONFIG)
-
-
-def extract_swift(path: Path) -> dict:
-    """Extract classes, structs, protocols, functions, imports, and calls from a .swift file."""
-    return _extract_generic(path, _SWIFT_CONFIG)
-
-
 # ── Julia extractor (custom walk) ────────────────────────────────────────────
 
 
@@ -3759,120 +2196,6 @@ def _resolve_kotlin_qualified_calls(
 # ── Pascal / Delphi extractor ─────────────────────────────────────────────────
 
 
-# Size cap for project XML files we parse with stdlib ElementTree.
-# Real .csproj/.fsproj/.vbproj/.lpk files are well under 2 MiB; anything
-# larger is either malformed or hostile.
-_PROJECT_XML_MAX_BYTES = 2 * 1024 * 1024
-
-
-def _project_xml_is_safe(src: bytes) -> bool:
-    """Reject XML that declares DTDs or entities.
-
-    Stdlib ``xml.etree.ElementTree`` does not cap entity expansion, so a
-    crafted project file could trigger a billion-laughs style DoS. External
-    entity resolution is already disabled by pyexpat defaults, but rejecting
-    ``<!DOCTYPE`` / ``<!ENTITY`` outright is defense in depth.
-
-    Legitimate MSBuild and Lazarus package files never contain a DOCTYPE
-    or ENTITY declaration, so this is a zero-false-positive screen.
-    """
-    # Only the prolog can hold a DTD/internal subset, but be conservative
-    # and scan the full byte range -- these formats use ASCII tags so a
-    # case-insensitive substring match is sufficient.
-    lowered = src.lower()
-    return b"<!doctype" not in lowered and b"<!entity" not in lowered
-
-
-def extract_lazarus_package(path: Path) -> dict:
-    """Extract package metadata from Lazarus .lpk package files (XML format).
-
-    .lpk is an XML file listing the package name, required dependencies,
-    and the Pascal units that belong to the package.
-
-    Produces nodes for:
-    - The package file itself
-    - The package (by name)
-    - Each required package (dependency)
-    - Each listed unit file (resolved to path-based IDs where possible)
-
-    Produces edges for:
-    - file --contains--> package
-    - package --imports--> required dependency (context: "import")
-    - package --contains--> listed unit
-    """
-    try:
-        import xml.etree.ElementTree as ET
-        src = path.read_bytes()
-    except OSError as e:
-        return {"nodes": [], "edges": [], "error": str(e)}
-
-    if len(src) > _PROJECT_XML_MAX_BYTES:
-        return {"nodes": [], "edges": [], "error": "package file too large"}
-    if not _project_xml_is_safe(src):
-        return {"nodes": [], "edges": [],
-                "error": "refusing XML with DOCTYPE/ENTITY declaration"}
-
-    try:
-        xml_root = ET.fromstring(src)
-    except Exception as e:
-        return {"nodes": [], "edges": [], "error": str(e)}
-
-    str_path = str(path)
-    stem = _file_stem(path)
-    nodes: list[dict] = []
-    edges: list[dict] = []
-    seen_ids: set[str] = set()
-
-    def add_node(nid: str, label: str) -> None:
-        if nid not in seen_ids:
-            seen_ids.add(nid)
-            nodes.append({
-                "id": nid, "label": label, "file_type": "code",
-                "source_file": str_path, "source_location": "L1",
-            })
-
-    def add_edge(src: str, tgt: str, relation: str, context: str | None = None) -> None:
-        edge: dict[str, Any] = {
-            "source": src, "target": tgt, "relation": relation,
-            "confidence": "EXTRACTED", "source_file": str_path,
-            "source_location": "L1", "weight": 1.0,
-        }
-        if context:
-            edge["context"] = context
-        edges.append(edge)
-
-    file_nid = _make_id(str(path))
-    add_node(file_nid, path.name)
-
-    name_elem = xml_root.find(".//Package/Name")
-    pkg_name = name_elem.get("Value") if name_elem is not None else path.stem
-    pkg_nid = _make_id(stem, pkg_name)
-    add_node(pkg_nid, pkg_name)
-    add_edge(file_nid, pkg_nid, "contains")
-
-    # Required packages → imports edges
-    for item in xml_root.findall(".//RequiredPkgs/"):
-        dep_elem = item.find("PackageName")
-        if dep_elem is not None:
-            dep_name = dep_elem.get("Value", "")
-            if dep_name:
-                dep_nid = _make_id(dep_name)
-                add_node(dep_nid, dep_name)
-                add_edge(pkg_nid, dep_nid, "imports", context="import")
-
-    # Listed units → contains edges, resolved to path-based IDs where possible
-    for item in xml_root.findall(".//Files/"):
-        unit_elem = item.find("UnitName")
-        if unit_elem is not None:
-            unit_name = unit_elem.get("Value", "")
-            if unit_name:
-                unit_nid = _pascal_resolve_unit(path, unit_name)
-                add_node(unit_nid, unit_name)
-                add_edge(pkg_nid, unit_nid, "contains")
-
-    return {"nodes": nodes, "edges": edges, "input_tokens": 0, "output_tokens": 0}
-
-
 # ── Main extract and collect_files ────────────────────────────────────────────
 
 
@@ -3897,826 +2220,6 @@ def _check_tree_sitter_version() -> None:
 # ── .NET project files (.sln, .slnx, .csproj, .razor) ───────────────────────
 
 
-def extract_slnx(path: Path) -> dict:
-    """Extract projects and inter-project dependencies from a .slnx file.
-
-    .slnx is the XML-based replacement for the legacy .sln format. Projects
-    are listed as ``<Project Path="..."/>`` elements (optionally nested inside
-    ``<Folder>`` elements) and build-order dependencies as ``<BuildDependency
-    Project="..."/>`` children. Unlike .sln there are no GUIDs -- projects are
-    identified by their path.
-    """
-    import xml.etree.ElementTree as ET
-
-    try:
-        src = path.read_bytes()
-    except OSError:
-        return {"nodes": [], "edges": [], "error": f"cannot read {path}"}
-
-    if len(src) > _PROJECT_XML_MAX_BYTES:
-        return {"nodes": [], "edges": [], "error": "project file too large"}
-    if not _project_xml_is_safe(src):
-        return {"nodes": [], "edges": [],
-                "error": "refusing XML with DOCTYPE/ENTITY declaration"}
-
-    try:
-        tree = ET.fromstring(src)
-    except ET.ParseError as e:
-        return {"nodes": [], "edges": [], "error": f"XML parse error: {e}"}
-
-    file_nid = _make_id(str(path))
-    str_path = str(path)
-    nodes: list[dict] = [{"id": file_nid, "label": path.name, "file_type": "code",
-                          "source_file": str_path, "source_location": None}]
-    edges: list[dict] = []
-    seen_ids: set[str] = set()
-    seen_ids.add(file_nid)
-
-    ns = ""
-    if tree.tag.startswith("{"):
-        ns = tree.tag.split("}")[0] + "}"
-
-    def _resolve(proj_path: str) -> str:
-        proj_path = proj_path.replace("\\", "/")
-        try:
-            return str((path.parent / proj_path).resolve())
-        except Exception:
-            return proj_path
-
-    # First pass: collect projects (anywhere in the tree, incl. <Folder>).
-    project_nids: set[str] = set()
-    for proj in tree.iter(f"{ns}Project"):
-        proj_path = proj.get("Path")
-        if not proj_path:
-            continue
-        abs_proj = _resolve(proj_path)
-        proj_nid = _make_id(abs_proj)
-        if proj_nid and proj_nid not in seen_ids:
-            seen_ids.add(proj_nid)
-            label = Path(proj_path).stem
-            nodes.append({"id": proj_nid, "label": label,
-                          "file_type": "code", "source_file": abs_proj,
-                          "source_location": None})
-            edges.append({"source": file_nid, "target": proj_nid,
-                          "relation": "contains", "confidence": "EXTRACTED",
-                          "source_file": str_path, "weight": 1.0})
-        if proj_nid:
-            project_nids.add(proj_nid)
-
-    # Second pass: build-order dependencies between known projects.
-    for proj in tree.iter(f"{ns}Project"):
-        proj_path = proj.get("Path")
-        if not proj_path:
-            continue
-        from_nid = _make_id(_resolve(proj_path))
-        for dep in proj.iter(f"{ns}BuildDependency"):
-            dep_path = dep.get("Project")
-            if not dep_path:
-                continue
-            to_nid = _make_id(_resolve(dep_path))
-            if (from_nid and to_nid and from_nid != to_nid
-                    and to_nid in project_nids):
-                edges.append({"source": from_nid, "target": to_nid,
-                              "relation": "imports", "confidence": "EXTRACTED",
-                              "source_file": str_path, "weight": 1.0})
-
-    return {"nodes": nodes, "edges": edges}
-
-
-def extract_csproj(path: Path) -> dict:
-    """Extract packages, project refs, and target framework from a .csproj/.fsproj/.vbproj."""
-    import xml.etree.ElementTree as ET
-
-    try:
-        src = path.read_bytes()
-    except OSError:
-        return {"nodes": [], "edges": [], "error": f"cannot read {path}"}
-
-    if len(src) > _PROJECT_XML_MAX_BYTES:
-        return {"nodes": [], "edges": [], "error": "project file too large"}
-    if not _project_xml_is_safe(src):
-        return {"nodes": [], "edges": [],
-                "error": "refusing XML with DOCTYPE/ENTITY declaration"}
-
-    try:
-        tree = ET.fromstring(src)
-    except ET.ParseError as e:
-        return {"nodes": [], "edges": [], "error": f"XML parse error: {e}"}
-
-    file_nid = _make_id(str(path))
-    str_path = str(path)
-    nodes: list[dict] = [{"id": file_nid, "label": path.name, "file_type": "code",
-                          "source_file": str_path, "source_location": None}]
-    edges: list[dict] = []
-    seen_ids: set[str] = set()
-    seen_ids.add(file_nid)
-
-    ns = ""
-    root_tag = tree.tag
-    if root_tag.startswith("{"):
-        ns = root_tag.split("}")[0] + "}"
-
-    def find_all(tag: str):
-        return tree.iter(f"{ns}{tag}")
-
-    for tf in find_all("TargetFramework"):
-        if tf.text:
-            fw_nid = _make_id("framework", tf.text.strip())
-            if fw_nid and fw_nid not in seen_ids:
-                seen_ids.add(fw_nid)
-                nodes.append({"id": fw_nid, "label": tf.text.strip(),
-                              "file_type": "concept", "source_file": str_path,
-                              "source_location": None})
-                edges.append({"source": file_nid, "target": fw_nid,
-                              "relation": "references", "confidence": "EXTRACTED",
-                              "source_file": str_path, "weight": 1.0})
-
-    for tf in find_all("TargetFrameworks"):
-        if tf.text:
-            for fw in tf.text.strip().split(";"):
-                fw = fw.strip()
-                if fw:
-                    fw_nid = _make_id("framework", fw)
-                    if fw_nid and fw_nid not in seen_ids:
-                        seen_ids.add(fw_nid)
-                        nodes.append({"id": fw_nid, "label": fw,
-                                      "file_type": "concept", "source_file": str_path,
-                                      "source_location": None})
-                        edges.append({"source": file_nid, "target": fw_nid,
-                                      "relation": "references", "confidence": "EXTRACTED",
-                                      "source_file": str_path, "weight": 1.0})
-
-    for pkg in find_all("PackageReference"):
-        name = pkg.get("Include") or pkg.get("include") or ""
-        version = pkg.get("Version") or pkg.get("version") or ""
-        if not name:
-            continue
-        pkg_nid = _make_id("nuget", name)
-        label = f"{name} ({version})" if version else name
-        if pkg_nid and pkg_nid not in seen_ids:
-            seen_ids.add(pkg_nid)
-            nodes.append({"id": pkg_nid, "label": label,
-                          "file_type": "code", "source_file": str_path,
-                          "source_location": None})
-        edges.append({"source": file_nid, "target": pkg_nid,
-                      "relation": "imports", "confidence": "EXTRACTED",
-                      "source_file": str_path, "weight": 1.0})
-
-    for proj in find_all("ProjectReference"):
-        ref_path = proj.get("Include") or proj.get("include") or ""
-        if not ref_path:
-            continue
-        ref_path_norm = ref_path.replace("\\", "/")
-        try:
-            abs_ref = str((path.parent / ref_path_norm).resolve())
-        except Exception:
-            abs_ref = ref_path_norm
-        proj_nid = _make_id(abs_ref)
-        if proj_nid and proj_nid not in seen_ids:
-            seen_ids.add(proj_nid)
-            proj_label = Path(ref_path_norm).name
-            nodes.append({"id": proj_nid, "label": proj_label,
-                          "file_type": "code", "source_file": abs_ref,
-                          "source_location": None})
-        edges.append({"source": file_nid, "target": proj_nid,
-                      "relation": "imports", "confidence": "EXTRACTED",
-                      "source_file": str_path, "weight": 1.0})
-
-    sdk = tree.get("Sdk") or ""
-    if sdk:
-        sdk_nid = _make_id("sdk", sdk)
-        if sdk_nid and sdk_nid not in seen_ids:
-            seen_ids.add(sdk_nid)
-            nodes.append({"id": sdk_nid, "label": sdk,
-                          "file_type": "concept", "source_file": str_path,
-                          "source_location": None})
-            edges.append({"source": file_nid, "target": sdk_nid,
-                          "relation": "references", "confidence": "EXTRACTED",
-                          "source_file": str_path, "weight": 1.0})
-
-    return {"nodes": nodes, "edges": edges}
-
-
-def _xml_local_name(name: str) -> str:
-    return name.rsplit("}", 1)[-1] if name.startswith("{") else name
-
-
-# A .NET event handler has the signature `(object sender, <T>EventArgs e)`. Used
-# to tell a real event handler in the code-behind apart from an ordinary method
-# whose name a XAML attribute value happens to match. Tolerates `object?`, a
-# namespace-qualified args type, and a generic `EventArgs<T>`.
-_EVENT_HANDLER_SIGNATURE_RE = re.compile(
-    r"\(\s*object\??\s+\w+\s*,\s*[\w.]*EventArgs(?:<[^>]*>)?\s+\w+\s*\)"
-)
-
-# XAML attribute names that carry free-form strings or identifiers and never name
-# an event handler. They are skipped when matching attribute values to code-behind
-# methods so e.g. Content="Save" or Tag="Refresh" can't fabricate an event edge.
-_XAML_NON_EVENT_ATTRS = frozenset({
-    "Name", "Content", "Text", "Title", "Tag", "ToolTip", "Header",
-    "Class", "Key", "Uid", "DataContext", "Style", "Source",
-})
-
-# A handler attribute value is a bare method name (e.g. Click="Save_Click"), not
-# markup, a path, or a sentence. Used to skip values like "{Binding ...}" or
-# free-form content before looking them up as code-behind methods.
-_XAML_IDENT_RE = re.compile(r"[A-Za-z_]\w*")
-_XAML_DESIGN_INSTANCE_TYPE_RE = re.compile(
-    r"\bType\s*=\s*(?:\{x:Type\s+)?(?P<type>[\w.:+]+)"
-)
-
-
-def _xaml_markup_extension(value: str) -> tuple[str, str] | None:
-    value = value.strip()
-    if not (value.startswith("{") and value.endswith("}")):
-        return None
-    inner = value[1:-1].strip()
-    if not inner or inner.startswith("}"):
-        return None
-    name, _, args = inner.partition(" ")
-    return name, args.strip()
-
-
-def _xaml_split_markup_args(args: str) -> list[str]:
-    parts: list[str] = []
-    start = 0
-    depth = 0
-    for idx, ch in enumerate(args):
-        if ch == "{":
-            depth += 1
-        elif ch == "}" and depth:
-            depth -= 1
-        elif ch == "," and depth == 0:
-            parts.append(args[start:idx].strip())
-            start = idx + 1
-    tail = args[start:].strip()
-    if tail:
-        parts.append(tail)
-    return parts
-
-
-def _xaml_static_resource_key(value: str) -> str | None:
-    markup = _xaml_markup_extension(value)
-    if not markup:
-        return None
-    name, args = markup
-    if name != "StaticResource":
-        return None
-    for part in _xaml_split_markup_args(args):
-        if "=" not in part:
-            return part.strip() or None
-        key, resource = part.split("=", 1)
-        if key.strip() == "ResourceKey":
-            return resource.strip() or None
-    return None
-
-
-def _xaml_binding_refs(value: str) -> tuple[str | None, str | None]:
-    markup = _xaml_markup_extension(value)
-    if not markup:
-        return None, None
-    name, args = markup
-    if name != "Binding":
-        return None, None
-
-    path_ref = None
-    converter_ref = None
-    for part in _xaml_split_markup_args(args):
-        if not part:
-            continue
-        if "=" not in part:
-            if path_ref is None:
-                path_ref = part.strip()
-            continue
-        key, raw_value = part.split("=", 1)
-        key = key.strip()
-        raw_value = raw_value.strip()
-        if key == "Path":
-            path_ref = raw_value
-        elif key == "Converter":
-            converter_ref = _xaml_static_resource_key(raw_value)
-
-    if path_ref and ("{" in path_ref or "}" in path_ref):
-        path_ref = None
-    return path_ref or None, converter_ref or None
-
-
-def _xaml_codebehind_path(path: Path) -> Path | None:
-    expected = path.with_suffix(path.suffix + ".cs")
-    if expected.exists():
-        return expected
-    try:
-        for sibling in path.parent.iterdir():
-            if sibling.name.casefold() == expected.name.casefold():
-                return sibling
-    except OSError:
-        return None
-    return None
-
-
-def _xaml_codebehind_symbols(
-    path: Path,
-    class_name: str | None,
-) -> tuple[dict | None, dict[str, dict], list[dict]]:
-    codebehind = _xaml_codebehind_path(path)
-    if not codebehind:
-        return None, {}, []
-    result = extract_csharp(codebehind)
-    if result.get("error"):
-        return None, {}, []
-
-    class_simple = class_name.rsplit(".", 1)[-1] if class_name else None
-    class_node = None
-    if class_simple:
-        for node in result.get("nodes", []):
-            if node.get("label") == class_simple:
-                class_node = node
-                break
-
-    class_method_edges: list[dict] = []
-    if class_node:
-        class_id = class_node.get("id")
-        for edge in result.get("edges", []):
-            if edge.get("source") == class_id and edge.get("relation") == "method":
-                class_method_edges.append(edge)
-    method_ids = {edge.get("target") for edge in class_method_edges} if class_node else None
-
-    # Only methods with a .NET event-handler signature -- (object sender,
-    # <T>EventArgs e) -- are eligible to be wired to a XAML attribute as an
-    # event. Without this gate, any attribute whose value happens to match a
-    # method name (e.g. Content="Save" next to a business method Save()) would
-    # produce a spurious "event" edge. The C# extractor does not record the
-    # parameter list on method nodes, so we read it from the code-behind source
-    # at the method's recorded line.
-    try:
-        cb_lines = codebehind.read_text(encoding="utf-8", errors="replace").splitlines()
-    except OSError:
-        cb_lines = []
-
-    def _has_event_handler_signature(node: dict) -> bool:
-        loc = str(node.get("source_location") or "")
-        m = re.match(r"L(\d+)", loc)
-        if not m or not cb_lines:
-            return False
-        start = int(m.group(1)) - 1
-        # Join a few lines so a signature split across lines still matches.
-        snippet = " ".join(cb_lines[start:start + 3])
-        return _EVENT_HANDLER_SIGNATURE_RE.search(snippet) is not None
-
-    methods: dict[str, dict] = {}
-    for node in result.get("nodes", []):
-        if method_ids is not None and node.get("id") not in method_ids:
-            continue
-        label = str(node.get("label", ""))
-        if label.startswith(".") and label.endswith("()") and _has_event_handler_signature(node):
-            methods[label.strip("()").lstrip(".")] = node
-    return class_node, methods, class_method_edges
-
-
-def _xaml_type_simple_name(type_ref: str) -> str | None:
-    type_ref = type_ref.strip().strip("{}")
-    if not type_ref:
-        return None
-    type_ref = type_ref.split(",", 1)[0].strip()
-    if type_ref.startswith("x:Type "):
-        type_ref = type_ref[len("x:Type "):].strip()
-    if ":" in type_ref:
-        type_ref = type_ref.rsplit(":", 1)[-1]
-    if "." in type_ref:
-        type_ref = type_ref.rsplit(".", 1)[-1]
-    if "+" in type_ref:
-        type_ref = type_ref.rsplit("+", 1)[-1]
-    return type_ref if _XAML_IDENT_RE.fullmatch(type_ref) else None
-
-
-def _xaml_explicit_viewmodel_names(tree) -> tuple[bool, list[str]]:
-    has_data_context = False
-    names: list[str] = []
-    for elem in tree.iter():
-        elem_type = _xml_local_name(elem.tag)
-        if elem_type.endswith(".DataContext") or elem_type == "DataContext":
-            has_data_context = True
-            for child in list(elem):
-                vm_name = _xaml_type_simple_name(_xml_local_name(child.tag))
-                if vm_name and vm_name not in names:
-                    names.append(vm_name)
-        for key, value in elem.attrib.items():
-            if _xml_local_name(key) != "DataContext" or not value:
-                continue
-            has_data_context = True
-            match = _XAML_DESIGN_INSTANCE_TYPE_RE.search(value)
-            if match:
-                vm_name = _xaml_type_simple_name(match.group("type"))
-                if vm_name and vm_name not in names:
-                    names.append(vm_name)
-    return has_data_context, names
-
-
-def _xaml_prism_autowire_viewmodel(tree) -> bool:
-    for elem in tree.iter():
-        for key, value in elem.attrib.items():
-            if (
-                _xml_local_name(key).endswith("ViewModelLocator.AutoWireViewModel")
-                and value.strip().lower() == "true"
-            ):
-                return True
-    return False
-
-
-def _xaml_inferred_viewmodel_names(view_name: str | None) -> list[str]:
-    if not view_name:
-        return []
-    names: list[str] = []
-
-    def add(name: str) -> None:
-        if name.endswith("ViewModel") and name not in names:
-            names.append(name)
-
-    if view_name == "MainWindow":
-        add("MainWindowViewModel")
-        add("MainViewModel")
-    for suffix in ("UserControl", "View", "Page", "Control"):
-        if view_name.endswith(suffix) and len(view_name) > len(suffix):
-            add(view_name[:-len(suffix)] + "ViewModel")
-            break
-    return names
-
-
-def _xaml_project_root(path: Path) -> Path:
-    project_markers = (".csproj", ".fsproj", ".vbproj", ".sln", ".slnx")
-    root = path.parent
-    for directory in (path.parent, *path.parent.parents):
-        try:
-            if any(child.suffix in project_markers for child in directory.iterdir()):
-                root = directory
-                break
-        except OSError:
-            continue
-    if _XAML_ACTIVE_EXTRACT_ROOT is None:
-        return root
-    boundary = _XAML_ACTIVE_EXTRACT_ROOT.resolve()
-    try:
-        root.resolve().relative_to(boundary)
-        return root
-    except ValueError:
-        return boundary
-
-
-def _xaml_csharp_class_nodes(path: Path) -> dict[str, list[dict]]:
-    from graphify.detect import _is_ignored, _is_noise_dir, _load_graphifyignore
-    root = _xaml_project_root(path)
-    cache_key = str(root.resolve()) if _XAML_ACTIVE_EXTRACT_ROOT is not None else None
-    if cache_key and cache_key in _XAML_CSHARP_CLASS_CACHE:
-        return _XAML_CSHARP_CLASS_CACHE[cache_key]
-    classes: dict[str, list[dict]] = {}
-    patterns = _load_graphifyignore(root)
-    ignore_cache: dict[Path, bool] = {}
-    # Prune noise/hidden dirs DURING traversal (not after) so the scan never
-    # descends into node_modules/.venv/.git/build/..., and CAP the number of
-    # directories visited. rglob("*.cs") used to walk the entire tree first,
-    # which on a mis-resolved or huge root (e.g. a .xaml under a shared temp dir
-    # or a giant monorepo, where _xaml_project_root climbs to a broad ancestor)
-    # scanned millions of paths and effectively hung. A real .NET project sits
-    # well under the cap; a runaway root is bounded to a fast, partial scan
-    # instead of hanging.
-    import os as _os
-    _DIR_CAP = 20000
-    cs_files: list[Path] = []
-    visited = 0
-    try:
-        for dirpath, dirnames, filenames in _os.walk(root):
-            dirnames[:] = [
-                d for d in dirnames if not d.startswith(".") and not _is_noise_dir(d)
-            ]
-            for fn in filenames:
-                if fn.endswith(".cs"):
-                    cs_files.append(Path(dirpath) / fn)
-            visited += 1
-            if visited >= _DIR_CAP:
-                break
-    except OSError:
-        return classes
-    cs_files.sort()
-    for cs_path in cs_files:
-        if patterns and _is_ignored(cs_path, root, patterns, _cache=ignore_cache):
-            continue
-        result = extract_csharp(cs_path)
-        if result.get("error"):
-            continue
-        for node in result.get("nodes", []):
-            label = str(node.get("label", ""))
-            if not label.endswith("ViewModel") or not _XAML_IDENT_RE.fullmatch(label):
-                continue
-            if node.get("source_file"):
-                classes.setdefault(label, []).append(node)
-    if cache_key:
-        _XAML_CSHARP_CLASS_CACHE[cache_key] = classes
-    return classes
-
-
-def _xaml_pascal_name(name: str) -> str | None:
-    name = name.strip().lstrip("_")
-    if name.startswith("m_"):
-        name = name[2:]
-    return name[:1].upper() + name[1:] if _XAML_IDENT_RE.fullmatch(name) else None
-
-
-_XAML_TOOLKIT_FIELD_RE = re.compile(r"\b(?P<name>_?m?_?[A-Za-z_]\w*)\s*(?:=.*)?;")
-_XAML_TOOLKIT_METHOD_RE = re.compile(r"\b(?P<name>[A-Za-z_]\w*)\s*\(")
-_XAML_ACTIVE_EXTRACT_ROOT: Path | None = None
-_XAML_CSHARP_CLASS_CACHE: dict[str, dict[str, list[dict]]] = {}
-
-
-def _xaml_communitytoolkit_members(vm_node: dict) -> tuple[dict[str, dict], list[dict]]:
-    source_file = vm_node.get("source_file")
-    vm_id = vm_node.get("id")
-    if not source_file or not vm_id:
-        return {}, []
-    try:
-        # errors="replace" so a non-UTF8 code-behind can't raise UnicodeDecodeError
-        # and abort the whole extract_xaml (matches every other reader here).
-        lines = Path(source_file).read_text(encoding="utf-8", errors="replace").splitlines()
-    except OSError:
-        return {}, []
-
-    members: dict[str, dict] = {}
-    edges: list[dict] = []
-
-    def add_member(label: str, line_no: int, context: str) -> None:
-        nid = _make_id(vm_id, label)
-        members[label] = {
-            "id": nid,
-            "label": label,
-            "file_type": "code",
-            "source_file": source_file,
-            "source_location": f"L{line_no}",
-        }
-        edges.append({
-            "source": vm_id,
-            "target": nid,
-            "relation": "defines",
-            "confidence": "INFERRED",
-            "source_file": source_file,
-            "source_location": f"L{line_no}",
-            "weight": 1.0,
-            "context": context,
-        })
-
-    pending: tuple[str, int] | None = None
-    for line_no, line in enumerate(lines, 1):
-        remainder = line.split("]", 1)[1].strip() if "]" in line else ""
-        if "[" in line and "ObservableProperty" in line:
-            pending = ("property", line_no)
-            if not remainder:
-                continue
-            line = remainder
-        if "[" in line and "RelayCommand" in line:
-            pending = ("command", line_no)
-            if not remainder:
-                continue
-            line = remainder
-        if not pending or not line.strip() or line.lstrip().startswith("["):
-            continue
-
-        kind, attr_line = pending
-        pending = None
-        if kind == "property":
-            match = _XAML_TOOLKIT_FIELD_RE.search(line)
-            label = _xaml_pascal_name(match.group("name")) if match else None
-            if label:
-                add_member(label, attr_line, "communitytoolkit_observable_property")
-        else:
-            match = _XAML_TOOLKIT_METHOD_RE.search(line)
-            if match:
-                method = match.group("name").removesuffix("Async")
-                add_member(f"{method}Command", attr_line, "communitytoolkit_relay_command")
-
-    return members, edges
-
-
-def extract_xaml(path: Path) -> dict:
-    """Extract WPF/XAML structure, bindings, x:Class, and event handler references."""
-    import xml.etree.ElementTree as ET
-
-    try:
-        src = path.read_bytes()
-    except OSError:
-        return {"nodes": [], "edges": [], "error": f"cannot read {path}"}
-
-    if len(src) > _PROJECT_XML_MAX_BYTES:
-        return {"nodes": [], "edges": [], "error": "xaml file too large"}
-    if not _project_xml_is_safe(src):
-        return {"nodes": [], "edges": [],
-                "error": "refusing XML with DOCTYPE/ENTITY declaration"}
-
-    try:
-        tree = ET.fromstring(src)
-    except ET.ParseError as e:
-        return {"nodes": [], "edges": [], "error": f"XML parse error: {e}"}
-
-    text = src.decode("utf-8", errors="replace")
-    lines = text.splitlines()
-    str_path = str(path)
-    stem = _file_stem(path)
-    file_nid = _make_id(str(path))
-    root_type = _xml_local_name(tree.tag)
-    root_nid = _make_id(stem, root_type)
-    nodes: list[dict] = []
-    edges: list[dict] = []
-    seen_ids: set[str] = set()
-    seen_edges: set[tuple[str, str, str, str | None]] = set()
-
-    def line_for(value: str | None) -> int:
-        if value:
-            for idx, line in enumerate(lines, 1):
-                if value in line:
-                    return idx
-        return 1
-
-    def add_node(
-        nid: str,
-        label: str,
-        line: int | None,
-        *,
-        file_type: str = "code",
-        source_file: str = str_path,
-    ) -> None:
-        if nid in seen_ids:
-            return
-        seen_ids.add(nid)
-        nodes.append({
-            "id": nid, "label": label, "file_type": file_type,
-            "source_file": source_file,
-            "source_location": f"L{line}" if line else None,
-        })
-
-    def add_existing_node(node: dict | None) -> None:
-        if not node:
-            return
-        nid = node.get("id")
-        if not nid or nid in seen_ids:
-            return
-        seen_ids.add(nid)
-        nodes.append(dict(node))
-
-    def add_edge(
-        src_nid: str,
-        tgt_nid: str,
-        relation: str,
-        line: int,
-        *,
-        context: str | None = None,
-        source_file: str = str_path,
-        confidence: str = "EXTRACTED",
-    ) -> None:
-        key = (src_nid, tgt_nid, relation, context)
-        if key in seen_edges:
-            return
-        seen_edges.add(key)
-        edge = {
-            "source": src_nid, "target": tgt_nid, "relation": relation,
-            "confidence": confidence, "source_file": source_file,
-            "source_location": f"L{line}", "weight": 1.0,
-        }
-        if context:
-            edge["context"] = context
-        edges.append(edge)
-
-    def add_existing_edge(edge: dict) -> None:
-        key = (edge.get("source"), edge.get("target"), edge.get("relation"), edge.get("context"))
-        if key in seen_edges:
-            return
-        seen_edges.add(key)
-        edges.append(dict(edge))
-
-    add_node(file_nid, path.name, 1)
-    add_node(root_nid, root_type, 1)
-    add_edge(file_nid, root_nid, "contains", 1)
-
-    class_name = None
-    for key, value in tree.attrib.items():
-        if _xml_local_name(key) == "Class" and value:
-            class_name = value.strip()
-            break
-
-    class_node, codebehind_methods, class_method_edges = _xaml_codebehind_symbols(path, class_name)
-    if class_name:
-        if class_node:
-            class_nid = class_node["id"]
-            add_existing_node(class_node)
-        else:
-            class_label = class_name.rsplit(".", 1)[-1]
-            class_nid = _make_id(stem, class_label)
-            add_node(class_nid, class_label, line_for(class_name))
-        add_edge(root_nid, class_nid, "references", line_for(class_name), context="x_class")
-
-    has_data_context, vm_names = _xaml_explicit_viewmodel_names(tree)
-    prism_autowire = _xaml_prism_autowire_viewmodel(tree)
-    vm_confidence = "EXTRACTED"
-    if not has_data_context:
-        view_name = class_name.rsplit(".", 1)[-1] if class_name else None
-        view_name = view_name or (path.stem if prism_autowire else None)
-        vm_names = _xaml_inferred_viewmodel_names(view_name)
-        vm_confidence = "INFERRED"
-    generated_members: dict[str, dict] = {}
-    generated_member_edges: list[dict] = []
-    if vm_names:
-        csharp_classes = _xaml_csharp_class_nodes(path)
-        vm_candidates = []
-        for vm_name in vm_names:
-            vm_candidates.extend(csharp_classes.get(vm_name, []))
-        by_id = {node.get("id"): node for node in vm_candidates if node.get("id")}
-        if len(by_id) == 1:
-            vm_node = next(iter(by_id.values()))
-            add_existing_node(vm_node)
-            add_edge(
-                root_nid,
-                vm_node["id"],
-                "references",
-                line_for(vm_node["label"]),
-                context="view_model",
-                confidence=vm_confidence,
-            )
-            generated_members, generated_member_edges = _xaml_communitytoolkit_members(vm_node)
-            for member in generated_members.values():
-                add_existing_node(member)
-            for member_edge in generated_member_edges:
-                add_existing_edge(member_edge)
-
-    for elem in tree.iter():
-        elem_type = _xml_local_name(elem.tag)
-        elem_name = None
-        for key, value in elem.attrib.items():
-            if _xml_local_name(key) == "Name" and value:
-                elem_name = value.strip()
-                break
-        owner_nid = root_nid
-        if elem_name:
-            owner_nid = _make_id(stem, elem_name)
-            add_node(owner_nid, elem_name, line_for(elem_name))
-            add_edge(root_nid, owner_nid, "contains", line_for(elem_name))
-            type_nid = _make_id("xaml", elem_type)
-            add_node(type_nid, elem_type, line_for(elem_name), file_type="concept")
-            add_edge(owner_nid, type_nid, "references", line_for(elem_name), context="type")
-
-        for key, value in elem.attrib.items():
-            value = value or ""
-            # Event wiring: an attribute references a handler only when its local
-            # name isn't a known free-form/identity property, its value is a bare
-            # identifier (a method name, not markup or a sentence), and the matched
-            # code-behind method actually has an event-handler signature (the gate
-            # in _xaml_codebehind_symbols). This stops Content="Save" / Tag="..."
-            # from fabricating event edges against same-named ordinary methods.
-            attr_local = _xml_local_name(key)
-            if attr_local not in _XAML_NON_EVENT_ATTRS and _XAML_IDENT_RE.fullmatch(value):
-                method = codebehind_methods.get(value)
-                if method:
-                    add_existing_node(method)
-                    add_edge(owner_nid, method["id"], "references", line_for(value), context="event")
-                    for method_edge in class_method_edges:
-                        if method_edge.get("target") == method["id"]:
-                            add_existing_node(class_node)
-                            add_existing_edge(method_edge)
-                            break
-            binding_path, binding_converter = _xaml_binding_refs(value)
-            if binding_path:
-                bind_nid = _make_id("binding", binding_path)
-                add_node(bind_nid, binding_path, line_for(value), file_type="concept")
-                binding_context = (
-                    "binding_command"
-                    if attr_local == "Command" or attr_local.endswith(".Command")
-                    else "binding_path"
-                )
-                add_edge(owner_nid, bind_nid, "references", line_for(value), context=binding_context)
-                generated_member = generated_members.get(binding_path)
-                if generated_member:
-                    add_existing_node(generated_member)
-                    add_edge(
-                        owner_nid,
-                        generated_member["id"],
-                        "references",
-                        line_for(value),
-                        context=binding_context,
-                        confidence="INFERRED",
-                    )
-            if binding_converter:
-                converter_nid = _make_id("binding_converter", binding_converter)
-                add_node(converter_nid, binding_converter, line_for(value), file_type="concept")
-                add_edge(owner_nid, converter_nid, "references", line_for(value), context="binding_converter")
-            if elem_type == "Binding" and attr_local == "Path":
-                direct_path = value.strip()
-                if direct_path and "{" not in direct_path and "}" not in direct_path:
-                    bind_nid = _make_id("binding", direct_path)
-                    add_node(bind_nid, direct_path, line_for(value), file_type="concept")
-                    add_edge(owner_nid, bind_nid, "references", line_for(value), context="binding_path")
-            if elem_type == "Binding" and attr_local == "Converter":
-                direct_converter = _xaml_static_resource_key(value)
-                if direct_converter:
-                    converter_nid = _make_id("binding_converter", direct_converter)
-                    add_node(converter_nid, direct_converter, line_for(value), file_type="concept")
-                    add_edge(owner_nid, converter_nid, "references", line_for(value), context="binding_converter")
-
-    return {"nodes": nodes, "edges": edges}
 
 
 # Config/manifest JSON filenames the structural extractor understands. Anything
@@ -5009,13 +2512,13 @@ def _get_extractor(path: Path) -> Any | None:
 
 
 def _safe_extract_with_xaml_root(extractor, path: Path, root: Path) -> dict:
-    global _XAML_ACTIVE_EXTRACT_ROOT
-    previous_root = _XAML_ACTIVE_EXTRACT_ROOT
-    _XAML_ACTIVE_EXTRACT_ROOT = root.resolve()
+    import graphify.extractors.xaml as _xaml_mod
+    previous_root = _xaml_mod._XAML_ACTIVE_EXTRACT_ROOT
+    _xaml_mod._XAML_ACTIVE_EXTRACT_ROOT = root.resolve()
     try:
         return _safe_extract(extractor, path)
     finally:
-        _XAML_ACTIVE_EXTRACT_ROOT = previous_root
+        _xaml_mod._XAML_ACTIVE_EXTRACT_ROOT = previous_root
 
 
 def _extract_single_file(args: tuple) -> tuple[int, dict]:
diff --git a/graphify/extractors/MIGRATION.md b/graphify/extractors/MIGRATION.md
index 75e1525e2e..016722b9ec 100644
--- a/graphify/extractors/MIGRATION.md
+++ b/graphify/extractors/MIGRATION.md
@@ -25,8 +25,31 @@ written so an AI agent can execute it in a single session.
 | sln | yes |
 | pascal_forms (dfm + lfm) | yes |
 | json_config | yes |
-| (config-driven core: python, js, java, c, cpp, csharp, kotlin, scala, php, lua, swift, groovy, vue, svelte, astro, xaml, groovy) | no — shared _extract_generic core, move as one batch |
-| (other bespoke: julia, verilog, markdown, objc, csproj, slnx, lazarus_package, pascal) | no |
+| python | yes |
+| js (js/ts/tsx/mts/cts) | yes |
+| svelte | yes |
+| astro | yes |
+| vue | yes |
+| java | yes |
+| groovy | yes |
+| c | yes |
+| cpp | yes |
+| ruby | yes |
+| csharp (extractor appended to existing csharp.py) | yes |
+| kotlin | yes |
+| scala | yes |
+| php | yes |
+| lua | yes |
+| swift | yes |
+| lazarus_package | yes |
+| slnx | yes |
+| csproj | yes |
+| objc | yes |
+| pascal | yes |
+| julia | yes |
+| verilog | yes |
+| markdown | yes |
+| xaml | yes |
 
 Note: config-driven extractors (python, js, java, c, cpp, ruby, csharp,
 kotlin, scala, php, lua, swift, groovy) depend on the shared
diff --git a/graphify/extractors/__init__.py b/graphify/extractors/__init__.py
index ada517094e..d65c21096a 100644
--- a/graphify/extractors/__init__.py
+++ b/graphify/extractors/__init__.py
@@ -11,31 +11,56 @@
 from typing import Callable
 
 from graphify.extractors.apex import extract_apex
+from graphify.extractors.astro import extract_astro
 from graphify.extractors.bash import extract_bash
 from graphify.extractors.blade import extract_blade
+from graphify.extractors.c import extract_c
+from graphify.extractors.cpp import extract_cpp
+from graphify.extractors.csharp import extract_csharp
+from graphify.extractors.csproj import extract_csproj
 from graphify.extractors.dart import extract_dart
 from graphify.extractors.dm import extract_dm, extract_dmf, extract_dmi, extract_dmm
 from graphify.extractors.elixir import extract_elixir
 from graphify.extractors.fortran import extract_fortran
 from graphify.extractors.go import extract_go
+from graphify.extractors.groovy import extract_groovy
+from graphify.extractors.java import extract_java
+from graphify.extractors.js import extract_js
 from graphify.extractors.json_config import extract_json
 from graphify.extractors.julia import extract_julia
+from graphify.extractors.kotlin import extract_kotlin
+from graphify.extractors.lazarus_package import extract_lazarus_package
+from graphify.extractors.lua import extract_lua
 from graphify.extractors.markdown import extract_markdown
 from graphify.extractors.objc import extract_objc
 from graphify.extractors.pascal import extract_pascal
 from graphify.extractors.pascal_forms import extract_delphi_form, extract_lazarus_form
+from graphify.extractors.php import extract_php
 from graphify.extractors.powershell import extract_powershell, extract_powershell_manifest
+from graphify.extractors.python import extract_python
 from graphify.extractors.razor import extract_razor
+from graphify.extractors.ruby import extract_ruby
 from graphify.extractors.rust import extract_rust
+from graphify.extractors.scala import extract_scala
 from graphify.extractors.sln import extract_sln
+from graphify.extractors.slnx import extract_slnx
 from graphify.extractors.sql import extract_sql
+from graphify.extractors.svelte import extract_svelte
+from graphify.extractors.swift import extract_swift
 from graphify.extractors.terraform import extract_terraform
 from graphify.extractors.verilog import extract_verilog
+from graphify.extractors.vue import extract_vue
+from graphify.extractors.xaml import extract_xaml
 from graphify.extractors.zig import extract_zig
 
 LANGUAGE_EXTRACTORS: dict[str, Callable[[Path], dict]] = {
     "apex": extract_apex,
+    "astro": extract_astro,
     "bash": extract_bash,
+    "c": extract_c,
+    "cpp": extract_cpp,
+    "csharp": extract_csharp,
+    "csproj": extract_csproj,
     "blade": extract_blade,
     "dart": extract_dart,
     "delphi_form": extract_delphi_form,
@@ -46,19 +71,34 @@
     "elixir": extract_elixir,
     "fortran": extract_fortran,
     "go": extract_go,
+    "groovy": extract_groovy,
+    "java": extract_java,
+    "js": extract_js,
     "json": extract_json,
     "julia": extract_julia,
+    "kotlin": extract_kotlin,
     "lazarus_form": extract_lazarus_form,
+    "lazarus_package": extract_lazarus_package,
+    "lua": extract_lua,
     "markdown": extract_markdown,
     "objc": extract_objc,
     "pascal": extract_pascal,
+    "php": extract_php,
     "powershell": extract_powershell,
     "powershell_manifest": extract_powershell_manifest,
+    "python": extract_python,
     "razor": extract_razor,
+    "ruby": extract_ruby,
     "rust": extract_rust,
+    "scala": extract_scala,
     "sln": extract_sln,
+    "slnx": extract_slnx,
     "sql": extract_sql,
+    "svelte": extract_svelte,
+    "swift": extract_swift,
     "terraform": extract_terraform,
     "verilog": extract_verilog,
+    "vue": extract_vue,
+    "xaml": extract_xaml,
     "zig": extract_zig,
 }
diff --git a/graphify/extractors/astro.py b/graphify/extractors/astro.py
new file mode 100644
index 0000000000..b7910b7d76
--- /dev/null
+++ b/graphify/extractors/astro.py
@@ -0,0 +1,72 @@
+"""Astro extractor. Moved verbatim from graphify/extract.py."""
+from __future__ import annotations
+
+from pathlib import Path
+
+from graphify.extractors.engine import _extract_generic
+from graphify.extractors.base import _make_id
+from graphify.extractors.resolution import _load_tsconfig_aliases, _load_tsconfig_base_url
+from graphify.extractors.js import _JS_CONFIG, _emit_rescued_import
+
+
+def extract_astro(path: Path) -> dict:
+    """Extract imports from .astro files: frontmatter (TS) + template regex fallback.
+
+    Astro files start with a ``---\\n...\\n---`` frontmatter block of TypeScript
+    setup code (where almost all imports live), followed by an HTML-with-expressions
+    template body, and optionally ``<script>`` blocks for client-side JS. Tree-sitter
+    only sees the file usefully through the frontmatter — feeding the whole file to
+    the JS parser produces a top-level ERROR node because the template is not valid
+    JS, so ``import_statement`` nodes are never reached and static imports are
+    silently dropped (#850). Mirrors :func:`extract_svelte` — same regex-rescue
+    approach, scanning the frontmatter block and any client-side ``<script>`` blocks
+    for static and dynamic imports.
+    """
+    result = _extract_generic(path, _JS_CONFIG)
+    try:
+        import re as _re
+        src = path.read_text(encoding="utf-8", errors="replace")
+        existing_ids = {n["id"] for n in result.get("nodes", [])}
+        file_node_id = _make_id(str(path))
+        aliases = _load_tsconfig_aliases(path.parent)
+        base_url = _load_tsconfig_base_url(path.parent)
+        # Dynamic imports anywhere in the file: `import('./X.astro')` is legal in
+        # frontmatter setup code and inside expression slots.
+        for m in _re.finditer(r"""import\(\s*['"]([^'"]+)['"]\s*\)""", src):
+            raw = m.group(1)
+            if not raw:
+                continue
+            _emit_rescued_import(
+                result, existing_ids, file_node_id, path, raw,
+                "dynamic_import", aliases, base_url,
+            )
+        # Static imports: scan the `---...---` frontmatter at the file head plus any
+        # client-side <script> blocks. Both are TS/JS regions but live inside a file
+        # the JS tree-sitter parser cannot validate as a whole.
+        frontmatter_re = _re.compile(
+            r"\A\s*---\s*\r?\n([\s\S]*?)\r?\n---\s*(?:\r?\n|\Z)"
+        )
+        script_re = _re.compile(
+            r"<script\b[^>]*>([\s\S]*?)</script\s*>", _re.IGNORECASE
+        )
+        static_import_re = _re.compile(
+            r"""import\s+(?:[^'"`;]+?\s+from\s+)?['"]([^'"]+)['"]"""
+        )
+        regions: list[str] = []
+        fm = frontmatter_re.search(src)
+        if fm:
+            regions.append(fm.group(1))
+        for script_match in script_re.finditer(src):
+            regions.append(script_match.group(1))
+        for region in regions:
+            for m in static_import_re.finditer(region):
+                raw = m.group(1)
+                if not raw:
+                    continue
+                _emit_rescued_import(
+                    result, existing_ids, file_node_id, path, raw,
+                    "imports_from", aliases, base_url,
+                )
+    except Exception:
+        pass
+    return result
diff --git a/graphify/extractors/base.py b/graphify/extractors/base.py
index 148fc18c64..1894435af6 100644
--- a/graphify/extractors/base.py
+++ b/graphify/extractors/base.py
@@ -1,6 +1,7 @@
 # DO NOT import from graphify.extract here — direction is extract.py → extractors/ only.
 from __future__ import annotations
 
+import textwrap
 from pathlib import Path
 
 from graphify.ids import make_id
@@ -83,3 +84,41 @@ def _file_stem(path: Path) -> str:
 
 def _read_text(node, source: bytes) -> str:
     return source[node.start_byte:node.end_byte].decode("utf-8", errors="replace")
+
+
+# Size cap for project XML files we parse with stdlib ElementTree.
+# Real .csproj/.fsproj/.vbproj/.lpk files are well under 2 MiB; anything
+# larger is either malformed or hostile.
+_PROJECT_XML_MAX_BYTES = 2 * 1024 * 1024
+
+
+def _shorten_rationale_label(text: str, width: int = 80) -> str:
+    """Collapse whitespace and truncate ``text`` to ``width`` chars for a
+    rationale node label, cutting on a word boundary rather than mid-word.
+    Shared by the Python and JS/TS rationale extractors (#2206).
+
+    ``textwrap.shorten`` collapses to just the placeholder when the first
+    "word" alone exceeds ``width`` (e.g. a docstring/comment that opens with
+    an unbroken URL) -- that would emit a content-free label, so fall back to
+    a plain character truncation of the normalized text in that case.
+    """
+    label = textwrap.shorten(text, width=width, placeholder="…")
+    if label in ("", "…"):
+        flat = " ".join(text.split())
+        label = flat if len(flat) <= width else flat[: width - 1] + "…"
+    return label
+
+
+def _project_xml_is_safe(src: bytes) -> bool:
+    """Reject XML that declares DTDs or entities.
+
+    Stdlib ``xml.etree.ElementTree`` does not cap entity expansion, so a
+    crafted project file could trigger a billion-laughs style DoS. External
+    entity resolution is already disabled by pyexpat defaults, but rejecting
+    ``<!DOCTYPE`` / ``<!ENTITY`` outright is defense in depth.
+
+    Legitimate MSBuild and Lazarus package files never contain a DOCTYPE
+    or ENTITY declaration, so this is a zero-false-positive screen.
+    """
+    lowered = src.lower()
+    return b"<!doctype" not in lowered and b"<!entity" not in lowered
diff --git a/graphify/extractors/c.py b/graphify/extractors/c.py
new file mode 100644
index 0000000000..e70e21c86b
--- /dev/null
+++ b/graphify/extractors/c.py
@@ -0,0 +1,84 @@
+"""C extractor. Moved verbatim from graphify/extract.py."""
+from __future__ import annotations
+
+from pathlib import Path
+
+from graphify.extractors.models import LanguageConfig
+from graphify.extractors.engine import _extract_generic
+from graphify.extractors.base import _make_id, _read_text
+from graphify.extractors.resolution import _resolve_c_include_path
+
+
+def _get_c_func_name(node, source: bytes) -> str | None:
+    """Recursively unwrap declarator to find the innermost identifier (C)."""
+    if node.type == "identifier":
+        return _read_text(node, source)
+    decl = node.child_by_field_name("declarator")
+    if decl:
+        return _get_c_func_name(decl, source)
+    for child in node.children:
+        if child.type == "identifier":
+            return _read_text(child, source)
+    return None
+
+
+def _import_c(node, source: bytes, file_nid: str, stem: str, edges: list, str_path: str, scope_stack: list[str] | None = None) -> None:
+    for child in node.children:
+        if child.type in ("string_literal", "system_lib_string", "string"):
+            raw = _read_text(child, source).strip('"<> ')
+            # Quoted includes: try to resolve to a real file so the target ID
+            # matches the node ID _extract_generic creates for that file.
+            if child.type != "system_lib_string":
+                resolved = _resolve_c_include_path(raw, str_path)
+                if resolved is not None:
+                    tgt_nid = _make_id(str(resolved))
+                    edges.append({
+                        "source": file_nid,
+                        "target": tgt_nid,
+                        "relation": "imports",
+                        "context": "import",
+                        "confidence": "EXTRACTED",
+                        "source_file": str_path,
+                        "source_location": f"L{node.start_point[0] + 1}",
+                        "weight": 1.0,
+                        # Stamp the resolved target, mirroring _import_python (#1814):
+                        # without it, an include whose header lives outside this
+                        # batch's paths keeps the raw absolute-path id no later pass
+                        # ever learns to relativize (#2243).
+                        "target_file": str(resolved),
+                    })
+                    break
+            module_name = raw.split("/")[-1].split(".")[0]
+            if module_name:
+                tgt_nid = _make_id(module_name)
+                edges.append({
+                    "source": file_nid,
+                    "target": tgt_nid,
+                    "relation": "imports",
+                    "context": "import",
+                    "confidence": "EXTRACTED",
+                    "source_file": str_path,
+                    "source_location": f"L{node.start_point[0] + 1}",
+                    "weight": 1.0,
+                })
+            break
+
+
+_C_CONFIG = LanguageConfig(
+    ts_module="tree_sitter_c",
+    class_types=frozenset(),
+    function_types=frozenset({"function_definition"}),
+    import_types=frozenset({"preproc_include"}),
+    call_types=frozenset({"call_expression"}),
+    call_function_field="function",
+    call_accessor_node_types=frozenset({"field_expression"}),
+    call_accessor_field="field",
+    function_boundary_types=frozenset({"function_definition"}),
+    import_handler=_import_c,
+    resolve_function_name_fn=_get_c_func_name,
+)
+
+
+def extract_c(path: Path) -> dict:
+    """Extract functions and includes from a .c/.h file."""
+    return _extract_generic(path, _C_CONFIG)
diff --git a/graphify/extractors/cpp.py b/graphify/extractors/cpp.py
new file mode 100644
index 0000000000..dffb426b06
--- /dev/null
+++ b/graphify/extractors/cpp.py
@@ -0,0 +1,30 @@
+"""C++ extractor. Moved verbatim from graphify/extract.py."""
+from __future__ import annotations
+
+from pathlib import Path
+
+from graphify.extractors.models import LanguageConfig
+from graphify.extractors.engine import _extract_generic, _get_cpp_func_name
+from graphify.extractors.base import _make_id, _read_text
+from graphify.extractors.resolution import _resolve_c_include_path
+from graphify.extractors.c import _import_c
+
+
+_CPP_CONFIG = LanguageConfig(
+    ts_module="tree_sitter_cpp",
+    class_types=frozenset({"class_specifier", "struct_specifier"}),
+    function_types=frozenset({"function_definition"}),
+    import_types=frozenset({"preproc_include"}),
+    call_types=frozenset({"call_expression"}),
+    call_function_field="function",
+    call_accessor_node_types=frozenset({"field_expression", "qualified_identifier"}),
+    call_accessor_field="field",
+    function_boundary_types=frozenset({"function_definition"}),
+    import_handler=_import_c,
+    resolve_function_name_fn=_get_cpp_func_name,
+)
+
+
+def extract_cpp(path: Path) -> dict:
+    """Extract functions, classes, and includes from a .cpp/.cc/.cxx/.hpp file."""
+    return _extract_generic(path, _CPP_CONFIG)
diff --git a/graphify/extractors/csharp.py b/graphify/extractors/csharp.py
index 3aa34e0edb..74e2d6ab62 100644
--- a/graphify/extractors/csharp.py
+++ b/graphify/extractors/csharp.py
@@ -1,19 +1,13 @@
-"""C# cross-file resolution.
-
-The config-driven C# *extractor* (``extract_csharp`` → ``_extract_generic``)
-still lives in ``graphify/extract.py``; per ``extractors/MIGRATION.md`` the
-config-driven languages cannot be ported one-by-one until the shared
-``_extract_generic`` core moves as its own coordinated batch. This module is
-the C# home for the parts that *are* cleanly separable — today, the cross-file
-type-reference resolver below — and is where ``extract_csharp`` will land when
-the core migration happens.
-"""
+"""C# cross-file resolution and extractor. Moved verbatim from graphify/extract.py."""
 from __future__ import annotations
 
 import html
 from pathlib import Path
 
-from graphify.extractors.base import _make_id
+from graphify.extractors.base import _make_id, _read_text
+from graphify.extractors.models import LanguageConfig
+from graphify.extractors.engine import _extract_generic
+from graphify.security import sanitize_metadata
 
 
 def _build_csharp_type_def_index(all_nodes: list[dict]) -> dict[tuple[str, str], str]:
@@ -439,3 +433,60 @@ def _dangling_stub_id(label: str, current_target: object) -> str:
         node for node in all_nodes
         if node.get("id") not in repointed_from or node.get("id") in still_referenced
     ]
+
+
+def _import_csharp(node, source: bytes, file_nid: str, stem: str, edges: list, str_path: str, scope_stack: list[str] | None = None) -> None:
+    text = _read_text(node, source).strip().rstrip(";")
+    if text.startswith("global "):
+        text = text[len("global "):].strip()
+    if not text.startswith("using"):
+        return
+    body = text[len("using"):].strip()
+    using_kind, alias, target_fqn = "namespace", None, body
+    if body.startswith("static "):
+        using_kind, target_fqn = "static", body[len("static "):].strip()
+    elif "=" in body:
+        lhs, rhs = body.split("=", 1)
+        using_kind, alias, target_fqn = "alias", lhs.strip(), rhs.strip()
+    if not target_fqn:
+        return
+    edges.append({
+        "source": file_nid,
+        "target": _make_id(target_fqn),
+        "relation": "imports",
+        "context": "import",
+        "confidence": "EXTRACTED",
+        "source_file": str_path,
+        "source_location": f"L{node.start_point[0] + 1}",
+        "weight": 1.0,
+        "metadata": sanitize_metadata({k: v for k, v in
+            {"using_kind": using_kind, "alias": alias, "target_fqn": target_fqn,
+             "scope_kind": "namespace" if scope_stack else "file",
+             "scope_id": scope_stack[-1] if scope_stack else None}.items() if v is not None}),
+    })
+
+
+_CSHARP_CONFIG = LanguageConfig(
+    ts_module="tree_sitter_c_sharp",
+    class_types=frozenset({
+        "class_declaration",
+        "interface_declaration",
+        "enum_declaration",
+        "struct_declaration",
+        "record_declaration",
+    }),
+    function_types=frozenset({"method_declaration"}),
+    import_types=frozenset({"using_directive"}),
+    call_types=frozenset({"invocation_expression"}),
+    call_function_field="function",
+    call_accessor_node_types=frozenset({"member_access_expression"}),
+    call_accessor_field="name",
+    body_fallback_child_types=("declaration_list",),
+    function_boundary_types=frozenset({"method_declaration"}),
+    import_handler=_import_csharp,
+)
+
+
+def extract_csharp(path: Path) -> dict:
+    """Extract C# type declarations, methods, namespaces, and usings from a .cs file."""
+    return _extract_generic(path, _CSHARP_CONFIG)
diff --git a/graphify/extractors/csproj.py b/graphify/extractors/csproj.py
new file mode 100644
index 0000000000..6b202d1202
--- /dev/null
+++ b/graphify/extractors/csproj.py
@@ -0,0 +1,120 @@
+"""Csproj extractor. Moved verbatim from graphify/extract.py."""
+from __future__ import annotations
+
+from pathlib import Path
+
+from graphify.extractors.base import _PROJECT_XML_MAX_BYTES, _make_id, _project_xml_is_safe
+
+
+def extract_csproj(path: Path) -> dict:
+    """Extract packages, project refs, and target framework from a .csproj/.fsproj/.vbproj."""
+    import xml.etree.ElementTree as ET
+
+    try:
+        src = path.read_bytes()
+    except OSError:
+        return {"nodes": [], "edges": [], "error": f"cannot read {path}"}
+
+    if len(src) > _PROJECT_XML_MAX_BYTES:
+        return {"nodes": [], "edges": [], "error": "project file too large"}
+    if not _project_xml_is_safe(src):
+        return {"nodes": [], "edges": [],
+                "error": "refusing XML with DOCTYPE/ENTITY declaration"}
+
+    try:
+        tree = ET.fromstring(src)
+    except ET.ParseError as e:
+        return {"nodes": [], "edges": [], "error": f"XML parse error: {e}"}
+
+    file_nid = _make_id(str(path))
+    str_path = str(path)
+    nodes: list[dict] = [{"id": file_nid, "label": path.name, "file_type": "code",
+                          "source_file": str_path, "source_location": None}]
+    edges: list[dict] = []
+    seen_ids: set[str] = set()
+    seen_ids.add(file_nid)
+
+    ns = ""
+    root_tag = tree.tag
+    if root_tag.startswith("{"):
+        ns = root_tag.split("}")[0] + "}"
+
+    def find_all(tag: str):
+        return tree.iter(f"{ns}{tag}")
+
+    for tf in find_all("TargetFramework"):
+        if tf.text:
+            fw_nid = _make_id("framework", tf.text.strip())
+            if fw_nid and fw_nid not in seen_ids:
+                seen_ids.add(fw_nid)
+                nodes.append({"id": fw_nid, "label": tf.text.strip(),
+                              "file_type": "concept", "source_file": str_path,
+                              "source_location": None})
+                edges.append({"source": file_nid, "target": fw_nid,
+                              "relation": "references", "confidence": "EXTRACTED",
+                              "source_file": str_path, "weight": 1.0})
+
+    for tf in find_all("TargetFrameworks"):
+        if tf.text:
+            for fw in tf.text.strip().split(";"):
+                fw = fw.strip()
+                if fw:
+                    fw_nid = _make_id("framework", fw)
+                    if fw_nid and fw_nid not in seen_ids:
+                        seen_ids.add(fw_nid)
+                        nodes.append({"id": fw_nid, "label": fw,
+                                      "file_type": "concept", "source_file": str_path,
+                                      "source_location": None})
+                        edges.append({"source": file_nid, "target": fw_nid,
+                                      "relation": "references", "confidence": "EXTRACTED",
+                                      "source_file": str_path, "weight": 1.0})
+
+    for pkg in find_all("PackageReference"):
+        name = pkg.get("Include") or pkg.get("include") or ""
+        version = pkg.get("Version") or pkg.get("version") or ""
+        if not name:
+            continue
+        pkg_nid = _make_id("nuget", name)
+        label = f"{name} ({version})" if version else name
+        if pkg_nid and pkg_nid not in seen_ids:
+            seen_ids.add(pkg_nid)
+            nodes.append({"id": pkg_nid, "label": label,
+                          "file_type": "code", "source_file": str_path,
+                          "source_location": None})
+        edges.append({"source": file_nid, "target": pkg_nid,
+                      "relation": "imports", "confidence": "EXTRACTED",
+                      "source_file": str_path, "weight": 1.0})
+
+    for proj in find_all("ProjectReference"):
+        ref_path = proj.get("Include") or proj.get("include") or ""
+        if not ref_path:
+            continue
+        ref_path_norm = ref_path.replace("\\", "/")
+        try:
+            abs_ref = str((path.parent / ref_path_norm).resolve())
+        except Exception:
+            abs_ref = ref_path_norm
+        proj_nid = _make_id(abs_ref)
+        if proj_nid and proj_nid not in seen_ids:
+            seen_ids.add(proj_nid)
+            proj_label = Path(ref_path_norm).name
+            nodes.append({"id": proj_nid, "label": proj_label,
+                          "file_type": "code", "source_file": abs_ref,
+                          "source_location": None})
+        edges.append({"source": file_nid, "target": proj_nid,
+                      "relation": "imports", "confidence": "EXTRACTED",
+                      "source_file": str_path, "weight": 1.0})
+
+    sdk = tree.get("Sdk") or ""
+    if sdk:
+        sdk_nid = _make_id("sdk", sdk)
+        if sdk_nid and sdk_nid not in seen_ids:
+            seen_ids.add(sdk_nid)
+            nodes.append({"id": sdk_nid, "label": sdk,
+                          "file_type": "concept", "source_file": str_path,
+                          "source_location": None})
+            edges.append({"source": file_nid, "target": sdk_nid,
+                          "relation": "references", "confidence": "EXTRACTED",
+                          "source_file": str_path, "weight": 1.0})
+
+    return {"nodes": nodes, "edges": edges}
diff --git a/graphify/extractors/groovy.py b/graphify/extractors/groovy.py
new file mode 100644
index 0000000000..3567d2321e
--- /dev/null
+++ b/graphify/extractors/groovy.py
@@ -0,0 +1,138 @@
+"""Groovy extractor. Moved verbatim from graphify/extract.py."""
+from __future__ import annotations
+
+from pathlib import Path
+
+from graphify.extractors.models import LanguageConfig
+from graphify.extractors.engine import _extract_generic
+from graphify.extractors.base import _make_id, _file_stem, _read_text
+from graphify.extractors.java import _import_java
+
+
+_GROOVY_CONFIG = LanguageConfig(
+    ts_module="tree_sitter_groovy",
+    class_types=frozenset({"class_declaration", "interface_declaration"}),
+    function_types=frozenset({"method_declaration", "constructor_declaration"}),
+    import_types=frozenset({"import_declaration"}),
+    call_types=frozenset({"method_invocation"}),
+    call_function_field="name",
+    call_accessor_node_types=frozenset(),
+    function_boundary_types=frozenset({"method_declaration", "constructor_declaration"}),
+    import_handler=_import_java,
+)
+
+
+def _is_spock_file(path: Path, ts_result: dict) -> bool:
+    """Return True when the file contains Spock-style ``def "feature"()`` methods
+    that tree-sitter-groovy cannot parse, detected by checking the raw source."""
+    import re as _re
+    _SPOCK_FEATURE_RE = _re.compile(r"""^\s*def\s+[\"']""", _re.MULTILINE)
+    try:
+        return bool(_SPOCK_FEATURE_RE.search(path.read_text(errors="replace")))
+    except OSError:
+        return False
+
+
+def _extract_spock_fallback(path: Path, ts_result: dict) -> dict:
+    """Regex-based fallback for Spock spec files where tree-sitter-groovy cannot parse
+    ``def "feature name"()`` methods. Merges import edges from the tree-sitter pass
+    (which survive reliably) with class and feature-method nodes extracted via regex.
+    """
+    import re as _re
+    source = path.read_text(errors="replace")
+    str_path = str(path)
+    stem = _file_stem(path)
+
+    # Only keep the file node from the tree-sitter pass (guaranteed present and
+    # correctly IDed) plus all import edges.  All other ts nodes are discarded to
+    # avoid orphaned method/constructor nodes whose parent edges were dropped.
+    file_node = next((n for n in ts_result.get("nodes", []) if n.get("label") == path.name), None)
+    nodes: list[dict] = [file_node] if file_node else []
+    edges: list[dict] = [e for e in ts_result.get("edges", []) if e.get("context") == "import"]
+    seen_ids: set[str] = {n["id"] for n in nodes}
+
+    def _add_node(nid: str, label: str, line: int) -> None:
+        if nid not in seen_ids:
+            seen_ids.add(nid)
+            nodes.append({
+                "id": nid,
+                "label": label,
+                "file_type": "code",
+                "source_file": str_path,
+                "source_location": f"L{line}",
+            })
+
+    def _add_edge(src: str, tgt: str, relation: str, line: int,
+                  confidence: str = "EXTRACTED") -> None:
+        edges.append({
+            "source": src,
+            "target": tgt,
+            "relation": relation,
+            "confidence": confidence,
+            "source_file": str_path,
+            "source_location": f"L{line}",
+            "weight": 1.0,
+        })
+
+    lines_text = source.splitlines()
+
+    # Extract class declarations
+    class_re = _re.compile(r"^\s*(?:[\w@]+\s+)*class\s+(\w+)")
+    # Extract Spock feature methods: def "..." () or def '...' ()
+    # Two separate capture groups per quote style so apostrophes inside
+    # double-quoted names (e.g. "shouldn't") are captured correctly.
+    feature_re = _re.compile(r"""^\s*def\s+(?:\"([^\"]+)\"|'([^']+)')\s*\(""")
+    # Extract plain def methods (non-string names) as well
+    plain_method_re = _re.compile(r"""^\s*def\s+(\w+)\s*\(""")
+
+    current_class_nid: str | None = None
+    file_nid = _make_id(str_path)
+
+    # Ensure the file node exists (tree-sitter pass may have emitted it)
+    if file_nid not in seen_ids:
+        _add_node(file_nid, path.name, 1)
+
+    for lineno, line_text in enumerate(lines_text, start=1):
+        cm = class_re.match(line_text)
+        if cm:
+            class_name = cm.group(1)
+            class_nid = _make_id(stem, class_name)
+            _add_node(class_nid, class_name, lineno)
+            _add_edge(file_nid, class_nid, "contains", lineno)
+            current_class_nid = class_nid
+            continue
+
+        if current_class_nid is None:
+            continue
+
+        fm = feature_re.match(line_text)
+        if fm:
+            method_name = fm.group(1) or fm.group(2)
+            method_label = f'"{method_name}"'
+            method_nid = _make_id(current_class_nid, method_name)
+            _add_node(method_nid, method_label, lineno)
+            _add_edge(current_class_nid, method_nid, "method", lineno)
+            continue
+
+        pm = plain_method_re.match(line_text)
+        if pm:
+            method_name = pm.group(1)
+            if method_name not in ("if", "while", "for", "switch", "catch"):
+                method_label = f".{method_name}()"
+                method_nid = _make_id(current_class_nid, method_name)
+                _add_node(method_nid, method_label, lineno)
+                _add_edge(current_class_nid, method_nid, "method", lineno)
+
+    return {"nodes": nodes, "edges": edges}
+
+
+def extract_groovy(path: Path) -> dict:
+    """Extract classes, methods, constructors, and imports from a .groovy/.gradle file.
+
+    Falls back to a regex-based Spock extractor when tree-sitter-groovy cannot parse
+    ``def "feature name"()`` methods (common in Spock specification classes).
+    """
+    result = _extract_generic(path, _GROOVY_CONFIG)
+    if _is_spock_file(path, result):
+        result = _extract_spock_fallback(path, result)
+    return result
diff --git a/graphify/extractors/java.py b/graphify/extractors/java.py
new file mode 100644
index 0000000000..2642c6dcb7
--- /dev/null
+++ b/graphify/extractors/java.py
@@ -0,0 +1,73 @@
+"""Java extractor. Moved verbatim from graphify/extract.py."""
+from __future__ import annotations
+
+from pathlib import Path
+
+from graphify.extractors.models import LanguageConfig
+from graphify.extractors.engine import _extract_generic
+from graphify.extractors.base import _make_id, _read_text
+
+
+def _import_java(node, source: bytes, file_nid: str, stem: str, edges: list, str_path: str, scope_stack: list[str] | None = None) -> None:
+    def _walk_scoped(n) -> str:
+        parts: list[str] = []
+        cur = n
+        while cur:
+            if cur.type == "scoped_identifier":
+                name_node = cur.child_by_field_name("name")
+                if name_node:
+                    parts.append(_read_text(name_node, source))
+                cur = cur.child_by_field_name("scope")
+            elif cur.type == "identifier":
+                parts.append(_read_text(cur, source))
+                break
+            else:
+                break
+        parts.reverse()
+        return ".".join(parts)
+
+    for child in node.children:
+        if child.type in ("scoped_identifier", "identifier"):
+            path_str = _walk_scoped(child)
+            module_name = path_str.split(".")[-1].strip("*").strip(".") or (
+                path_str.split(".")[-2] if len(path_str.split(".")) > 1 else path_str
+            )
+            if module_name:
+                tgt_nid = _make_id(module_name)
+                edges.append({
+                    "source": file_nid,
+                    "target": tgt_nid,
+                    "relation": "imports",
+                    "context": "import",
+                    "confidence": "EXTRACTED",
+                    "source_file": str_path,
+                    "source_location": f"L{node.start_point[0] + 1}",
+                    "weight": 1.0,
+                })
+            break
+
+
+_JAVA_CONFIG = LanguageConfig(
+    ts_module="tree_sitter_java",
+    # record_declaration shares class_declaration's name/body/interfaces fields,
+    # so it becomes a first-class type node instead of an isolated file (#1373).
+    # Enums and annotation declarations use the same name/body contract.
+    class_types=frozenset({
+        "class_declaration", "interface_declaration", "record_declaration",
+        "enum_declaration", "annotation_type_declaration",
+    }),
+    function_types=frozenset({"method_declaration", "constructor_declaration"}),
+    import_types=frozenset({"import_declaration"}),
+    # object_creation_expression (`new Foo(...)`) is handled by a dedicated Java
+    # branch in walk_calls below — its callee is in the `type` field, not `name`.
+    call_types=frozenset({"method_invocation", "object_creation_expression"}),
+    call_function_field="name",
+    call_accessor_node_types=frozenset(),
+    function_boundary_types=frozenset({"method_declaration", "constructor_declaration"}),
+    import_handler=_import_java,
+)
+
+
+def extract_java(path: Path) -> dict:
+    """Extract classes, interfaces, methods, constructors, and imports from a .java file."""
+    return _extract_generic(path, _JAVA_CONFIG)
diff --git a/graphify/extractors/js.py b/graphify/extractors/js.py
new file mode 100644
index 0000000000..e85e2ab45b
--- /dev/null
+++ b/graphify/extractors/js.py
@@ -0,0 +1,521 @@
+"""JS extractor. Moved verbatim from graphify/extract.py."""
+from __future__ import annotations
+
+import os
+import re
+from pathlib import Path
+
+from graphify.extractors.models import LanguageConfig
+from graphify.extractors.engine import _extract_generic
+from graphify.extractors.base import _make_id, _file_stem, _read_text, _shorten_rationale_label
+from graphify.extractors.resolution import (
+    _resolve_js_import_target,
+    _resolve_js_module_path,
+    _resolve_tsconfig_alias,
+    _load_tsconfig_aliases,
+    _load_tsconfig_base_url,
+)
+
+
+def _import_js(node, source: bytes, file_nid: str, stem: str, edges: list, str_path: str, scope_stack: list[str] | None = None) -> None:
+    is_reexport = node.type == "export_statement"
+    # Only handle export_statement if it has a `from` clause (re-export).
+    # Pure exports like `export const x = 1` or `export { localVar }` have no source module.
+    if is_reexport:
+        has_from = any(child.type == "from" or (_read_text(child, source) == "from") for child in node.children if child.type in ("from", "identifier"))
+        if not has_from:
+            # Check for string child (source path) as a more reliable indicator
+            has_from = any(child.type == "string" for child in node.children)
+            if not has_from:
+                return
+
+    resolved_path: "Path | None" = None
+    module_string = None
+    for child in node.children:
+        if child.type == "string":
+            module_string = child
+            break
+        if child.type == "import_require_clause":
+            # TS import-equals form: `import x = require("./m")`. The module
+            # string sits inside the clause, not on the import_statement
+            # itself, so the direct-child scan above never sees it.
+            module_string = next(
+                (sub for sub in child.children if sub.type == "string"), None
+            )
+            break
+    if module_string is not None:
+        raw = _read_text(module_string, source).strip("'\"` ")
+        resolved = _resolve_js_import_target(raw, str_path)
+        if resolved is not None:
+            tgt_nid, resolved_path = resolved
+            # `_resolve_js_import_path` returns the attempted path when no
+            # local file exists. Static ES imports must treat that as unresolved
+            # rather than minting a checkout-specific target ID (#2457).
+            if resolved_path is not None and not resolved_path.is_file():
+                tgt_nid = _make_id("ref", raw)
+                resolved_path = None
+            edge = {
+                "source": file_nid,
+                "target": tgt_nid,
+                "relation": "imports_from",
+                "context": "re-export" if is_reexport else "import",
+                "confidence": "EXTRACTED",
+                "source_file": str_path,
+                "source_location": f"L{node.start_point[0] + 1}",
+                "weight": 1.0,
+            }
+            # Stamp the resolved target file so a same-basename cross-extension
+            # sibling (foo.ts importing/re-exporting ./foo.mjs) keys its target salt
+            # by the TARGET's file rather than the importer's. Both files collapse to
+            # the base id `foo`; without this the salted lookup mis-points the target
+            # back onto the importer's own variant, a phantom self-loop (#1814).
+            if resolved_path is not None:
+                edge["target_file"] = str(resolved_path)
+            edges.append(edge)
+
+    # Emit symbol-level edges for named imports/re-exports from local/aliased files.
+    # e.g. `import { Foo, type Bar } from './bar'` → file → Foo, file → Bar (EXTRACTED)
+    # e.g. `export { Foo } from './bar'` → file → Foo (re_exports edge)
+    # Uses the same _make_id(target_stem, name) key that _extract_generic emits when
+    # defining the symbol, so these edges wire importers directly to existing symbol nodes.
+    if resolved_path is not None:
+        target_stem = _file_stem(resolved_path)
+        line = node.start_point[0] + 1
+
+        if is_reexport:
+            # Handle: export { foo, bar } from './module'
+            #         export { default as baz } from './module'
+            for child in node.children:
+                if child.type == "export_clause":
+                    for spec in child.children:
+                        if spec.type == "export_specifier":
+                            # The exported name is the local name from the source module
+                            name_node = spec.child_by_field_name("name")
+                            if name_node:
+                                sym = _read_text(name_node, source)
+                                if sym == "default":
+                                    continue  # skip default re-exports for ID matching
+                                edges.append({
+                                    "source": file_nid,
+                                    "target": _make_id(target_stem, sym),
+                                    "relation": "re_exports",
+                                    "context": "re-export",
+                                    "confidence": "EXTRACTED",
+                                    "source_file": str_path,
+                                    "source_location": f"L{line}",
+                                    "weight": 1.0,
+                                    # Which file this symbol target was synthesized
+                                    # from, so the id-remap post-pass can repoint a
+                                    # target the candidates rewrite never learns —
+                                    # a barrel defines no symbols (#1983). Transient,
+                                    # stripped at build like the #1814 stamp.
+                                    "target_file": str(resolved_path),
+                                })
+        else:
+            # Handle: import { Foo, type Bar } from './bar'
+            for child in node.children:
+                if child.type == "import_clause":
+                    for sub in child.children:
+                        if sub.type == "named_imports":
+                            for spec in sub.children:
+                                if spec.type == "import_specifier":
+                                    name_node = spec.child_by_field_name("name")
+                                    if name_node:
+                                        sym = _read_text(name_node, source)
+                                        edges.append({
+                                            "source": file_nid,
+                                            "target": _make_id(target_stem, sym),
+                                            "relation": "imports",
+                                            "context": "import",
+                                            "confidence": "EXTRACTED",
+                                            "source_file": str_path,
+                                            "source_location": f"L{line}",
+                                            "weight": 1.0,
+                                            # See the re_exports stamp above (#1983).
+                                            "target_file": str(resolved_path),
+                                        })
+
+
+_JS_CONFIG = LanguageConfig(
+    ts_module="tree_sitter_javascript",
+    class_types=frozenset({"class_declaration"}),
+    function_types=frozenset({"function_declaration", "generator_function_declaration", "method_definition"}),
+    import_types=frozenset({"import_statement", "export_statement"}),
+    call_types=frozenset({"call_expression", "new_expression"}),
+    call_function_field="function",
+    call_accessor_node_types=frozenset({"member_expression"}),
+    call_accessor_field="property",
+    call_accessor_object_field="object",
+    function_boundary_types=frozenset({"function_declaration", "generator_function_declaration", "arrow_function", "method_definition"}),
+    import_handler=_import_js,
+)
+
+_TS_CONFIG = LanguageConfig(
+    ts_module="tree_sitter_typescript",
+    ts_language_fn="language_typescript",
+    class_types=frozenset({
+        "class_declaration",
+        "abstract_class_declaration",  # TS abstract class
+        "interface_declaration",   # parity with Java/C#
+        "enum_declaration",        # named enums
+        "type_alias_declaration",  # named type aliases
+    }),
+    function_types=frozenset({"function_declaration", "generator_function_declaration", "method_definition", "method_signature"}),
+    import_types=frozenset({"import_statement", "export_statement"}),
+    call_types=frozenset({"call_expression", "new_expression"}),
+    call_function_field="function",
+    call_accessor_node_types=frozenset({"member_expression"}),
+    call_accessor_field="property",
+    call_accessor_object_field="object",
+    function_boundary_types=frozenset({"function_declaration", "generator_function_declaration", "arrow_function", "method_definition"}),
+    import_handler=_import_js,
+)
+
+# .tsx files must use the TSX grammar (JSX-aware), not the plain TypeScript grammar.
+# tree-sitter-typescript ships two languages: language_typescript (for .ts) and
+# language_tsx (for .tsx). Parsing .tsx with language_typescript silently fails on
+# JSX expressions, dropping any call_expression nested inside JSX (e.g. {fmtDate(x)}).
+_TSX_CONFIG = LanguageConfig(
+    ts_module="tree_sitter_typescript",
+    ts_language_fn="language_tsx",
+    class_types=_TS_CONFIG.class_types,
+    function_types=_TS_CONFIG.function_types,
+    import_types=_TS_CONFIG.import_types,
+    call_types=_TS_CONFIG.call_types,
+    call_function_field=_TS_CONFIG.call_function_field,
+    call_accessor_node_types=_TS_CONFIG.call_accessor_node_types,
+    call_accessor_field=_TS_CONFIG.call_accessor_field,
+    call_accessor_object_field=_TS_CONFIG.call_accessor_object_field,
+    function_boundary_types=_TS_CONFIG.function_boundary_types,
+    import_handler=_TS_CONFIG.import_handler,
+)
+
+
+def _rescue_js_dynamic_imports(path: Path, result: dict) -> None:
+    """Recover ``import('…')`` edges the AST pass does not emit for plain JS/TS.
+
+    tree-sitter models ``await import('x')`` as a ``call_expression``, not an
+    ``import_statement``, so the specifier only reaches the graph when
+    ``walk_calls`` visits that call — which it never does at module scope
+    (only function bodies are walked for calls). The Svelte/Astro/Vue
+    extractors already patch the same gap by regex because their AST pass
+    fails wholesale; plain ``.ts``/``.js`` was left out on the reasoning that
+    its AST pass "works". It works for STATIC imports; dynamic ones outside a
+    walked body fell through silently (#2575), and because they cluster under
+    hub modules the loss compounds with ``affected`` traversal depth.
+
+    Dedupe: a dynamic import the AST pass DID capture is already in the graph
+    as an ``imports_from`` edge marked ``deferred`` (``_dynamic_import_js``).
+    Re-emitting it here as a second ``dynamic_import`` edge would state the
+    same fact twice, so a match whose resolved target already has a deferred
+    edge FROM THIS FILE'S NODE is skipped. The source check matters: the AST
+    pass anchors the edge on the enclosing function when the ``import()`` is
+    written inside one, and that is a different fact from "this file depends on
+    that module" — the only one file-level traversal can use (#2584).
+
+    Regex false positives in comments/strings are the precedented trade of
+    the Svelte/Vue rescues; a ``//``-prefix guard covers the common case.
+    """
+    try:
+        import re as _re
+        src = path.read_text(encoding="utf-8", errors="replace")
+        if "import(" not in src:  # cheap bail — most files have none
+            return
+        existing_ids = {n["id"] for n in result.get("nodes", [])}
+        file_node_id = _make_id(str(path))
+        aliases = _load_tsconfig_aliases(path.parent)
+        base_url = _load_tsconfig_base_url(path.parent)
+        deferred_ids: set[str] = set()
+        deferred_files: set[str] = set()
+        rescued_targets: set[str] = set()
+        for e in result.get("edges", []):
+            # Only a FILE-level deferred edge makes the rescue redundant (#2584).
+            #
+            # `_dynamic_import_js` emits `caller_nid -> target`, and `caller_nid` is this
+            # file's node only when the `import()` sits at module scope. Written inside a
+            # function it is that function's node — a different fact, at a granularity
+            # `affected` does not walk. Matching on target alone treated the two as one and
+            # skipped the rescue, so a dynamic import inside a function ended up with no
+            # file-level edge at all. The reverse walk then reached the enclosing function
+            # and stopped: the only edge pointing at it is `contains`, deliberately kept out
+            # of DEFAULT_AFFECTED_RELATIONS.
+            #
+            # Measured on a ~700-file TS repo: `affected --depth 3` returned 39 of 49 truly
+            # affected files (recall 0.80, precision 1.00) and deeper traversal did not help,
+            # which is a dead end rather than a depth limit. It stayed hidden because the
+            # usual case still resolves — when the next importer imports that exact symbol
+            # by name there IS an edge into the function. Switch that importer to
+            # `import * as ns` or a side-effect `import './dyn'` and the same graph goes
+            # silent.
+            if (e.get("deferred") and e.get("relation") == "imports_from"
+                    and e.get("source") == file_node_id):
+                deferred_ids.add(e.get("target"))
+                tf = e.get("target_file")
+                if tf:
+                    try:
+                        deferred_files.add(str(Path(tf).resolve()))
+                    except OSError:
+                        deferred_files.add(str(tf))
+        # `(?<!\w)` so `fooimport('x')` and `_import('x')` do not match. The
+        # backtick alternative mirrors _dynamic_import_js's template-string
+        # handling: a literal `import(`./x`)` resolves, `${`-substituted ones
+        # are excluded (no `$` in the class) as statically unresolvable.
+        for m in _re.finditer(
+            r"""(?<!\w)import\(\s*(?:'([^'\n]+)'|"([^"\n]+)"|`([^`$\n]+)`)\s*\)""",
+            src,
+        ):
+            raw = m.group(1) or m.group(2) or m.group(3)
+            if not raw:
+                continue
+            line_start = src.rfind("\n", 0, m.start()) + 1
+            if "//" in src[line_start:m.start()]:
+                continue  # line-commented-out import
+            resolution = _resolve_rescued_specifier(path, raw, aliases, base_url)
+            if resolution is None:
+                continue
+            node_id, _stub_sf, resolved_file = resolution
+            # AST-captured already: same resolved target id, same resolved
+            # on-disk file, or the engine's ref-namespaced external id.
+            if node_id in deferred_ids or _make_id("ref", raw) in deferred_ids:
+                continue
+            if resolved_file is not None:
+                try:
+                    if str(resolved_file.resolve()) in deferred_files:
+                        continue
+                except OSError:
+                    pass
+            # One file depending on one module is one file-level fact, however many
+            # call sites defer it. Pre-existing (two module-scope `import('./x')` in one
+            # file already emitted two identical edges on v8), but #2584 routes every
+            # in-function dynamic import through here too, which would turn an edge case
+            # into the common one — a hub module deferred from eight functions of the same
+            # file would carry eight identical arrows.
+            emit_key = str(resolved_file.resolve()) if resolved_file is not None else raw
+            if emit_key in rescued_targets:
+                continue
+            rescued_targets.add(emit_key)
+            _emit_rescued_import(
+                result, existing_ids, file_node_id, path, raw,
+                "dynamic_import", aliases, base_url,
+            )
+    except Exception:
+        pass
+
+
+# ── JS/TS rationale + doc-reference extraction ────────────────────────────────
+#
+# Parity with _extract_python_rationale: Python files get rationale nodes from
+# docstrings and `# NOTE:`-style comments, but JS/TS comments were discarded
+# entirely. That silently drops two high-value signals in mixed corpora:
+#   1. rationale comments (`// NOTE:`, `// WHY:`, ...) — same as Python;
+#   2. architecture-decision references (`ADR-0011`, `RFC 793`) that teams
+#      conventionally cite in file/function headers. These are the natural
+#      join points between code and design docs in the same graph — without
+#      them, code<->ADR edges never form even when the code cites the ADR.
+
+_JS_RATIONALE_PREFIXES = (
+    "// NOTE:", "// IMPORTANT:", "// HACK:", "// WHY:", "// RATIONALE:",
+    "// TODO:", "// FIXME:",
+    "* NOTE:", "* IMPORTANT:", "* HACK:", "* WHY:", "* RATIONALE:",
+    "* TODO:", "* FIXME:",
+)
+
+# Doc-reference tokens worth first-classing as graph nodes. Deliberately
+# conservative: ADR-NNNN (Architecture Decision Records, any zero padding)
+# and RFC NNNN / RFC-NNNN.
+_JS_DOC_REF_RE = re.compile(r"\b(ADR[- ]?\d{1,5}|RFC[- ]?\d{1,5})\b", re.IGNORECASE)
+
+# Only look for doc references inside comments, not string literals or code.
+_JS_COMMENT_LINE_RE = re.compile(r"^\s*(//|/\*|\*)")
+
+
+def _extract_js_rationale(path: Path, result: dict) -> None:
+    """Post-pass: extract rationale comments and doc references from JS/TS source.
+    Mutates result in-place by appending to result['nodes'] and result['edges'].
+    """
+    try:
+        source_text = path.read_text(encoding="utf-8", errors="replace")
+    except Exception:
+        return
+
+    stem = _file_stem(path)
+    str_path = str(path)
+    nodes = result["nodes"]
+    edges = result["edges"]
+    seen_ids = {n["id"] for n in nodes}
+    file_nid = _make_id(str(path))
+    seen_doc_refs: set[str] = set()
+
+    def _add_rationale(text: str, line: int) -> None:
+        # Normalize whitespace before truncating, not after: slicing raw text
+        # first can land mid-word, leave a run of literal spaces where a
+        # newline + indentation used to be, or end on a "." that turns into
+        # an Obsidian "..md" filename once export.py appends the extension.
+        label = _shorten_rationale_label(text)
+        rid = _make_id(stem, "rationale", str(line))
+        if rid not in seen_ids:
+            seen_ids.add(rid)
+            nodes.append({
+                "id": rid,
+                "label": label,
+                "file_type": "rationale",
+                "source_file": str_path,
+                "source_location": f"L{line}",
+            })
+        edges.append({
+            "source": rid,
+            "target": file_nid,
+            "relation": "rationale_for",
+            "confidence": "EXTRACTED",
+            "source_file": str_path,
+            "source_location": f"L{line}",
+            "weight": 1.0,
+        })
+
+    def _add_doc_ref(token: str, line: int) -> None:
+        # Normalize "adr 11" / "ADR-0011" spellings to a canonical "ADR-0011"
+        # style label so references to the same document collapse to one node.
+        kind, num = re.match(r"([A-Za-z]+)[- ]?(\d+)", token).groups()
+        kind = kind.upper()
+        label = f"{kind}-{num.zfill(4)}" if kind == "ADR" else f"{kind}-{num}"
+        if label in seen_doc_refs:
+            return
+        seen_doc_refs.add(label)
+        rid = _make_id("docref", label)
+        if rid not in seen_ids:
+            seen_ids.add(rid)
+            nodes.append({
+                "id": rid,
+                "label": label,
+                "file_type": "doc_ref",
+                "source_file": str_path,
+                "source_location": f"L{line}",
+            })
+        edges.append({
+            "source": file_nid,
+            "target": rid,
+            "relation": "cites",
+            "confidence": "EXTRACTED",
+            "source_file": str_path,
+            "source_location": f"L{line}",
+            "weight": 1.0,
+        })
+
+    for lineno, line_text in enumerate(source_text.splitlines(), start=1):
+        stripped = line_text.strip()
+        if any(stripped.startswith(p) for p in _JS_RATIONALE_PREFIXES):
+            _add_rationale(stripped.lstrip("/* "), lineno)
+        if _JS_COMMENT_LINE_RE.match(line_text):
+            for m in _JS_DOC_REF_RE.finditer(stripped):
+                _add_doc_ref(m.group(1), lineno)
+
+
+def _resolve_rescued_specifier(
+    path: Path,
+    raw: str,
+    aliases,
+    base_url,
+) -> "tuple[str, str, Path | None] | None":
+    """Resolve a regex-rescued import specifier the way ``_import_js`` does.
+
+    Returns ``(node_id, stub_source_file, resolved_file)`` — ``resolved_file``
+    is the target as a real on-disk file, or None when the specifier is
+    external or dangling. Returns None when no target can be minted at all
+    (empty bare-import segment). Split out of :func:`_emit_rescued_import` so
+    :func:`_rescue_js_dynamic_imports` can resolve a match FIRST and skip
+    specifiers the AST pass already emitted, without duplicating the
+    resolution rules.
+    """
+    if raw.startswith("."):
+        resolved = _resolve_js_module_path(
+            Path(os.path.normpath(path.parent / raw))
+        )
+        resolved_file = resolved if resolved is not None and resolved.is_file() else None
+        return _make_id(str(resolved)), str(resolved), resolved_file
+    # Check tsconfig.json path aliases (e.g. "$lib/" -> "src/lib/",
+    # "@/" -> "src/") before treating as external. Mirrors _import_js
+    # logic so alias imports resolve to the same file node IDs the
+    # extractor creates (#701).
+    resolved_alias = _resolve_tsconfig_alias(raw, aliases, base_url=base_url)
+    if resolved_alias is not None:
+        resolved_alias = _resolve_js_module_path(resolved_alias)
+        resolved_file = (resolved_alias if resolved_alias is not None
+                         and resolved_alias.is_file() else None)
+        return _make_id(str(resolved_alias)), str(resolved_alias), resolved_file
+    # Bare/scoped import (node_modules) - use last segment;
+    # build_from_json drops as external if no matching node exists.
+    module_name = raw.split("/")[-1]
+    if not module_name:
+        return None
+    return _make_id(module_name), raw, None
+
+
+def _emit_rescued_import(
+    result: dict,
+    existing_ids: set,
+    file_node_id: str,
+    path: Path,
+    raw: str,
+    relation: str,
+    aliases,
+    base_url,
+) -> None:
+    """Shared edge/stub emit for the Svelte/Astro/Vue regex-rescue import passes.
+
+    Resolves the specifier the same way ``_import_js`` does — relative paths and
+    tsconfig aliases both go through :func:`_resolve_js_module_path` so
+    extensionless specifiers probe real on-disk extensions (``../lib/content``
+    -> ``content.ts``) instead of a naive ``.js``->``.ts`` suffix swap.
+
+    When the resolved target is a real file on disk, mirror ``_import_js``:
+    emit ONLY the edge, stamped with ``target_file``, and mint no stub node.
+    The #2169 canonicalization loop in :func:`extract` reads the stamp and
+    repoints the edge at the real file node's canonical id. Minting a stub
+    here would carry an absolute-path-derived id when the input path is
+    absolute — a ghost node (e.g. ``private_tmp_..._src_lib_content``)
+    duplicating the real ``src_lib_content`` node and clobbering its label on
+    dedupe (#2195). Stub nodes are still minted for unresolved specifiers
+    (externals, not-yet-created files) so prior behavior is preserved.
+    """
+    resolution = _resolve_rescued_specifier(path, raw, aliases, base_url)
+    if resolution is None:
+        return
+    node_id, stub_source_file, resolved_file = resolution
+    edge = {
+        "source": file_node_id, "target": node_id,
+        "relation": relation, "confidence": "EXTRACTED",
+        "source_file": str(path),
+    }
+    if resolved_file is not None:
+        # Real file on disk: edge only (no stub node), stamped so the #2169
+        # canonicalization pass repoints it at the real node (#2195).
+        edge["target_file"] = str(resolved_file)
+        result.setdefault("edges", []).append(edge)
+        return
+    if node_id in existing_ids:
+        # Edge target already a real node - just add the edge, don't add a node.
+        result.setdefault("edges", []).append(edge)
+        return
+    result.setdefault("nodes", []).append({
+        "id": node_id, "label": raw,
+        "file_type": "code", "source_file": stub_source_file,
+        "confidence": "EXTRACTED",
+    })
+    result.setdefault("edges", []).append(edge)
+    existing_ids.add(node_id)
+
+
+def extract_js(path: Path) -> dict:
+    """Extract classes, functions, arrow functions, and imports from a .js/.ts/.tsx/.mts/.cts file."""
+    suffix = path.suffix.lower()
+    if suffix == ".tsx":
+        config = _TSX_CONFIG
+    elif suffix in (".ts", ".mts", ".cts"):
+        config = _TS_CONFIG
+    else:
+        config = _JS_CONFIG
+    result = _extract_generic(path, config)
+    if "error" not in result:
+        _extract_js_rationale(path, result)
+        _rescue_js_dynamic_imports(path, result)
+    return result
diff --git a/graphify/extractors/kotlin.py b/graphify/extractors/kotlin.py
new file mode 100644
index 0000000000..9c2494bcff
--- /dev/null
+++ b/graphify/extractors/kotlin.py
@@ -0,0 +1,94 @@
+"""Kotlin extractor. Moved verbatim from graphify/extract.py."""
+from __future__ import annotations
+
+from pathlib import Path
+
+from graphify.extractors.models import LanguageConfig
+from graphify.extractors.engine import _extract_generic
+from graphify.extractors.base import _make_id, _read_text
+from graphify.security import sanitize_metadata
+
+
+def _import_kotlin(node, source: bytes, file_nid: str, stem: str, edges: list, str_path: str, scope_stack: list[str] | None = None) -> None:
+    # Grammar 1.1.0 (PyPI tree_sitter_kotlin) emits an `import` node whose
+    # children are the `import` keyword and a `qualified_identifier` (the dotted
+    # path), optionally followed by `.` `*` (wildcard) or `as` + `identifier`
+    # (alias). There is no `path` field. Older forks emit `import_header` with a
+    # `path` field or a bare `identifier` child; keep those branches so the
+    # extractor works across grammar generations (#2526, adapted from PR #2531
+    # by @Mustaqeem66).
+    path_node = node.child_by_field_name("path")
+    if path_node is None:
+        path_node = next(
+            (c for c in node.children if c.type == "qualified_identifier"), None
+        )
+    if path_node is not None:
+        raw = _read_text(path_node, source).strip()
+    else:
+        raw = next(
+            (_read_text(c, source).strip() for c in node.children
+             if c.type == "identifier"),
+            "",
+        )
+    if not raw:
+        return
+    # Wildcard (`import a.b.*`): imports a whole package, not a symbol. The last
+    # path segment is a PACKAGE name, so a symbol-level edge would dangle on (or
+    # collide with) an unrelated node that happens to share the package's name.
+    if raw.endswith(".*") or raw == "*" or any(c.type == "*" for c in node.children):
+        return
+    # Alias (`import a.b.C as D`): the alias is the identifier child after `as`.
+    alias = None
+    saw_as = False
+    for child in node.children:
+        if not saw_as:
+            saw_as = child.type == "as"
+        elif child.type in ("identifier", "simple_identifier"):
+            alias = _read_text(child, source).strip() or None
+            break
+    module_name = raw.split(".")[-1].strip()
+    if not module_name:
+        return
+    # Target is the bare last segment for now; _resolve_kotlin_import_targets
+    # rewrites it to the real node id via the target_fqn stamped here, once the
+    # per-file package index exists. Unresolved targets stay dangling like other
+    # languages' external imports.
+    edges.append({
+        "source": file_nid,
+        "target": _make_id(module_name),
+        "relation": "imports",
+        "context": "import",
+        "confidence": "EXTRACTED",
+        "source_file": str_path,
+        "source_location": f"L{node.start_point[0] + 1}",
+        "weight": 1.0,
+        "metadata": sanitize_metadata({k: v for k, v in
+            {"target_fqn": raw, "alias": alias}.items() if v is not None}),
+    })
+
+
+_KOTLIN_CONFIG = LanguageConfig(
+    ts_module="tree_sitter_kotlin",
+    class_types=frozenset({"class_declaration", "object_declaration"}),
+    function_types=frozenset({"function_declaration"}),
+    # Grammar 1.1.0 (PyPI tree_sitter_kotlin) names the import node `import`;
+    # older forks use `import_header`. Accept both (#2526).
+    import_types=frozenset({"import_header", "import"}),
+    call_types=frozenset({"call_expression"}),
+    call_function_field="",
+    call_accessor_node_types=frozenset({"navigation_expression"}),
+    call_accessor_field="",
+    # Different tree-sitter-kotlin grammar versions name plain identifier
+    # nodes differently: PyPI's `tree_sitter_kotlin` uses `identifier`,
+    # older forks use `simple_identifier`. Accept both so the extractor
+    # works across grammar generations.
+    name_fallback_child_types=("simple_identifier", "identifier"),
+    body_fallback_child_types=("function_body", "class_body", "enum_class_body"),
+    function_boundary_types=frozenset({"function_declaration"}),
+    import_handler=_import_kotlin,
+)
+
+
+def extract_kotlin(path: Path) -> dict:
+    """Extract classes, objects, functions, and imports from a .kt/.kts file."""
+    return _extract_generic(path, _KOTLIN_CONFIG)
diff --git a/graphify/extractors/lazarus_package.py b/graphify/extractors/lazarus_package.py
new file mode 100644
index 0000000000..9c818a087c
--- /dev/null
+++ b/graphify/extractors/lazarus_package.py
@@ -0,0 +1,98 @@
+"""Lazarus package extractor. Moved verbatim from graphify/extract.py."""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from graphify.extractors.base import _PROJECT_XML_MAX_BYTES, _file_stem, _make_id, _project_xml_is_safe
+from graphify.extractors.pascal import _pascal_resolve_unit
+
+
+def extract_lazarus_package(path: Path) -> dict:
+    """Extract package metadata from Lazarus .lpk package files (XML format).
+
+    .lpk is an XML file listing the package name, required dependencies,
+    and the Pascal units that belong to the package.
+
+    Produces nodes for:
+    - The package file itself
+    - The package (by name)
+    - Each required package (dependency)
+    - Each listed unit file (resolved to path-based IDs where possible)
+
+    Produces edges for:
+    - file --contains--> package
+    - package --imports--> required dependency (context: "import")
+    - package --contains--> listed unit
+    """
+    try:
+        import xml.etree.ElementTree as ET
+        src = path.read_bytes()
+    except OSError as e:
+        return {"nodes": [], "edges": [], "error": str(e)}
+
+    if len(src) > _PROJECT_XML_MAX_BYTES:
+        return {"nodes": [], "edges": [], "error": "package file too large"}
+    if not _project_xml_is_safe(src):
+        return {"nodes": [], "edges": [],
+                "error": "refusing XML with DOCTYPE/ENTITY declaration"}
+
+    try:
+        xml_root = ET.fromstring(src)
+    except Exception as e:
+        return {"nodes": [], "edges": [], "error": str(e)}
+
+    str_path = str(path)
+    stem = _file_stem(path)
+    nodes: list[dict] = []
+    edges: list[dict] = []
+    seen_ids: set[str] = set()
+
+    def add_node(nid: str, label: str) -> None:
+        if nid not in seen_ids:
+            seen_ids.add(nid)
+            nodes.append({
+                "id": nid, "label": label, "file_type": "code",
+                "source_file": str_path, "source_location": "L1",
+            })
+
+    def add_edge(src: str, tgt: str, relation: str, context: str | None = None) -> None:
+        edge: dict[str, Any] = {
+            "source": src, "target": tgt, "relation": relation,
+            "confidence": "EXTRACTED", "source_file": str_path,
+            "source_location": "L1", "weight": 1.0,
+        }
+        if context:
+            edge["context"] = context
+        edges.append(edge)
+
+    file_nid = _make_id(str(path))
+    add_node(file_nid, path.name)
+
+    name_elem = xml_root.find(".//Package/Name")
+    pkg_name = name_elem.get("Value") if name_elem is not None else path.stem
+    pkg_nid = _make_id(stem, pkg_name)
+    add_node(pkg_nid, pkg_name)
+    add_edge(file_nid, pkg_nid, "contains")
+
+    # Required packages → imports edges
+    for item in xml_root.findall(".//RequiredPkgs/"):
+        dep_elem = item.find("PackageName")
+        if dep_elem is not None:
+            dep_name = dep_elem.get("Value", "")
+            if dep_name:
+                dep_nid = _make_id(dep_name)
+                add_node(dep_nid, dep_name)
+                add_edge(pkg_nid, dep_nid, "imports", context="import")
+
+    # Listed units → contains edges, resolved to path-based IDs where possible
+    for item in xml_root.findall(".//Files/"):
+        unit_elem = item.find("UnitName")
+        if unit_elem is not None:
+            unit_name = unit_elem.get("Value", "")
+            if unit_name:
+                unit_nid = _pascal_resolve_unit(path, unit_name)
+                add_node(unit_nid, unit_name)
+                add_edge(pkg_nid, unit_nid, "contains")
+
+    return {"nodes": nodes, "edges": edges, "input_tokens": 0, "output_tokens": 0}
diff --git a/graphify/extractors/lua.py b/graphify/extractors/lua.py
new file mode 100644
index 0000000000..02bf457620
--- /dev/null
+++ b/graphify/extractors/lua.py
@@ -0,0 +1,54 @@
+"""Lua extractor. Moved verbatim from graphify/extract.py."""
+from __future__ import annotations
+
+from pathlib import Path
+
+from graphify.extractors.models import LanguageConfig
+from graphify.extractors.engine import _extract_generic
+from graphify.extractors.base import _make_id, _read_text
+from graphify.extractors.resolution import _resolve_lua_import_target
+
+
+def _import_lua(node, source: bytes, file_nid: str, stem: str, edges: list, str_path: str, scope_stack: list[str] | None = None) -> None:
+    """Extract require('module') from Lua variable_declaration nodes."""
+    text = _read_text(node, source)
+    import re
+    m = re.search(r"""require\s*[\('"]\s*['"]?([^'")\s]+)""", text)
+    if m:
+        raw_module = m.group(1)
+        if raw_module:
+            tgt_nid = _resolve_lua_import_target(raw_module, str_path)
+            if tgt_nid:
+                edges.append({
+                    "source": file_nid,
+                    "target": tgt_nid,
+                    "relation": "imports",
+                    "context": "import",
+                    "confidence": "EXTRACTED",
+                    "confidence_score": 1.0,
+                    "source_file": str_path,
+                    "source_location": str(node.start_point[0] + 1),
+                    "weight": 1.0,
+                })
+
+
+_LUA_CONFIG = LanguageConfig(
+    ts_module="tree_sitter_lua",
+    ts_language_fn="language",
+    class_types=frozenset(),
+    function_types=frozenset({"function_declaration"}),
+    import_types=frozenset({"variable_declaration"}),
+    call_types=frozenset({"function_call"}),
+    call_function_field="name",
+    call_accessor_node_types=frozenset({"method_index_expression"}),
+    call_accessor_field="name",
+    name_fallback_child_types=("identifier", "method_index_expression"),
+    body_fallback_child_types=("block",),
+    function_boundary_types=frozenset({"function_declaration"}),
+    import_handler=_import_lua,
+)
+
+
+def extract_lua(path: Path) -> dict:
+    """Extract functions, methods, require() imports, and calls from a .lua file."""
+    return _extract_generic(path, _LUA_CONFIG)
diff --git a/graphify/extractors/php.py b/graphify/extractors/php.py
new file mode 100644
index 0000000000..e88eb73691
--- /dev/null
+++ b/graphify/extractors/php.py
@@ -0,0 +1,54 @@
+"""PHP extractor. Moved verbatim from graphify/extract.py."""
+from __future__ import annotations
+
+from pathlib import Path
+
+from graphify.extractors.models import LanguageConfig
+from graphify.extractors.engine import _extract_generic
+from graphify.extractors.base import _make_id, _read_text
+
+
+def _import_php(node, source: bytes, file_nid: str, stem: str, edges: list, str_path: str, scope_stack: list[str] | None = None) -> None:
+    for child in node.children:
+        if child.type in ("qualified_name", "name", "identifier"):
+            raw = _read_text(child, source)
+            module_name = raw.split("\\")[-1].strip()
+            if module_name:
+                tgt_nid = _make_id(module_name)
+                edges.append({
+                    "source": file_nid,
+                    "target": tgt_nid,
+                    "relation": "imports",
+                    "context": "import",
+                    "confidence": "EXTRACTED",
+                    "source_file": str_path,
+                    "source_location": f"L{node.start_point[0] + 1}",
+                    "weight": 1.0,
+                })
+            break
+
+
+_PHP_CONFIG = LanguageConfig(
+    ts_module="tree_sitter_php",
+    ts_language_fn="language_php",
+    class_types=frozenset({"class_declaration"}),
+    function_types=frozenset({"function_definition", "method_declaration"}),
+    import_types=frozenset({"namespace_use_clause"}),
+    call_types=frozenset({"function_call_expression", "member_call_expression", "scoped_call_expression", "class_constant_access_expression"}),
+    static_prop_types=frozenset({"scoped_property_access_expression"}),
+    helper_fn_names=frozenset({"config"}),
+    container_bind_methods=frozenset({"bind", "singleton", "scoped", "instance"}),
+    event_listener_properties=frozenset({"listen", "subscribe"}),
+    call_function_field="function",
+    call_accessor_node_types=frozenset({"member_call_expression"}),
+    call_accessor_field="name",
+    name_fallback_child_types=("name",),
+    body_fallback_child_types=("declaration_list", "compound_statement"),
+    function_boundary_types=frozenset({"function_definition", "method_declaration"}),
+    import_handler=_import_php,
+)
+
+
+def extract_php(path: Path) -> dict:
+    """Extract classes, functions, methods, namespace uses, and calls from a .php file."""
+    return _extract_generic(path, _PHP_CONFIG)
diff --git a/graphify/extractors/python.py b/graphify/extractors/python.py
new file mode 100644
index 0000000000..62b893a2eb
--- /dev/null
+++ b/graphify/extractors/python.py
@@ -0,0 +1,234 @@
+"""Python extractor. Moved verbatim from graphify/extract.py."""
+from __future__ import annotations
+
+import re
+import textwrap
+from pathlib import Path
+
+from graphify.extractors.models import LanguageConfig
+from graphify.extractors.engine import _extract_generic
+from graphify.extractors.base import _make_id, _file_stem, _read_text, _shorten_rationale_label
+
+
+def _import_python(node, source: bytes, file_nid: str, stem: str, edges: list, str_path: str, scope_stack: list[str] | None = None) -> None:
+    t = node.type
+    if t == "import_statement":
+        for child in node.children:
+            if child.type in ("dotted_name", "aliased_import"):
+                raw = _read_text(child, source)
+                raw_module, _, raw_alias = raw.partition(" as ")
+                module_name = raw_module.strip().lstrip(".")
+                tgt_nid = _make_id(module_name)
+                edge = {
+                    "source": file_nid,
+                    "target": tgt_nid,
+                    "relation": "imports",
+                    "context": "import",
+                    "confidence": "EXTRACTED",
+                    "source_file": str_path,
+                    "source_location": f"L{node.start_point[0] + 1}",
+                    "weight": 1.0,
+                }
+                if raw_alias:
+                    # `import pkg.mod as alias` binds the local name `alias`, not
+                    # `mod`'s own stem, to the module -- stash it so the cross-file
+                    # member-call resolver can match `alias.func()` against this
+                    # edge instead of dropping it (#2082).
+                    edge["local_alias"] = raw_alias.strip()
+                edges.append(edge)
+    elif t == "import_from_statement":
+        module_node = node.child_by_field_name("module_name")
+        if module_node:
+            raw = _read_text(module_node, source)
+            target_path: "Path | None" = None
+            if raw.startswith("."):
+                # Relative import - resolve to full path so IDs match file node IDs
+                dots = len(raw) - len(raw.lstrip("."))
+                module_name = raw.lstrip(".")
+                base = Path(str_path).parent
+                for _ in range(dots - 1):
+                    base = base.parent
+                rel = (module_name.replace(".", "/") + ".py") if module_name else "__init__.py"
+                target_path = base / rel
+                tgt_nid = _make_id(str(target_path))
+            else:
+                tgt_nid = _make_id(raw)
+            edge = {
+                "source": file_nid,
+                "target": tgt_nid,
+                "relation": "imports_from",
+                "context": "import",
+                "confidence": "EXTRACTED",
+                "source_file": str_path,
+                "source_location": f"L{node.start_point[0] + 1}",
+                "weight": 1.0,
+            }
+            # Stamp the resolved target file (mirroring _import_js, #1814) so
+            # the #2169 remap pass can canonicalize this edge's target on an
+            # incremental run where the target file itself is not in the
+            # batch — without it the target keeps an absolute-path-derived id
+            # that matches no node in the merged graph and dangles (#2213).
+            # Existence-gated: a speculative import of a nonexistent sibling
+            # must stay dangling, exactly as before. The stamp is transient
+            # and popped before graph.json ships.
+            if target_path is not None:
+                try:
+                    if target_path.is_file():
+                        edge["target_file"] = str(target_path)
+                except OSError:
+                    pass
+            edges.append(edge)
+
+
+_PYTHON_CONFIG = LanguageConfig(
+    ts_module="tree_sitter_python",
+    class_types=frozenset({"class_definition"}),
+    function_types=frozenset({"function_definition"}),
+    import_types=frozenset({"import_statement", "import_from_statement"}),
+    call_types=frozenset({"call"}),
+    call_function_field="function",
+    call_accessor_node_types=frozenset({"attribute"}),
+    call_accessor_field="attribute",
+    call_accessor_object_field="object",
+    function_boundary_types=frozenset({"function_definition"}),
+    import_handler=_import_python,
+)
+
+_RATIONALE_PREFIXES = ("# NOTE:", "# IMPORTANT:", "# HACK:", "# WHY:", "# RATIONALE:", "# TODO:", "# FIXME:")
+
+
+def _is_autogenerated_python(source: bytes) -> bool:
+    """Return True if this Python file is auto-generated and its module docstring is noise.
+
+    Covers: Alembic/Flask-Migrate revisions, Django migrations, protobuf/gRPC/OpenAPI stubs.
+    Module docstrings in these files are change annotations or boilerplate, not rationale.
+    """
+    head = source[:2048].decode("utf-8", errors="replace")
+    # Generic generated-file markers (protobuf, gRPC, OpenAPI codegen, etc.)
+    if any(m in head for m in ("DO NOT EDIT", "@generated", "Generated by the protocol buffer")):
+        return True
+    # Alembic / Flask-Migrate revision files
+    if (re.search(r"^revision\s*[:=]", head, re.MULTILINE)
+            and "def upgrade(" in head
+            and "down_revision" in head):
+        return True
+    # Django migrations
+    if "class Migration(migrations.Migration)" in head and "operations" in head:
+        return True
+    return False
+
+
+def _extract_python_rationale(path: Path, result: dict) -> None:
+    """Post-pass: extract docstrings and rationale comments from Python source.
+    Mutates result in-place by appending to result['nodes'] and result['edges'].
+    """
+    try:
+        import tree_sitter_python as tspython
+        from tree_sitter import Language, Parser
+        language = Language(tspython.language())
+        parser = Parser(language)
+        source = path.read_bytes()
+        tree = parser.parse(source)
+        root = tree.root_node
+    except Exception:
+        return
+
+    stem = _file_stem(path)
+    str_path = str(path)
+    nodes = result["nodes"]
+    edges = result["edges"]
+    seen_ids = {n["id"] for n in nodes}
+    file_nid = _make_id(str(path))
+
+    def _get_docstring(body_node) -> tuple[str, int] | None:
+        if not body_node:
+            return None
+        for child in body_node.children:
+            if child.type == "expression_statement":
+                for sub in child.children:
+                    if sub.type in ("string", "concatenated_string"):
+                        text = source[sub.start_byte:sub.end_byte].decode("utf-8", errors="replace")
+                        text = text.strip("\"'").strip('"""').strip("'''").strip()
+                        if len(text) > 20:
+                            return text, child.start_point[0] + 1
+            break
+        return None
+
+    def _add_rationale(text: str, line: int, parent_nid: str) -> None:
+        # Normalize whitespace before truncating, not after: slicing raw text
+        # first can land mid-word, leave a run of literal spaces where a
+        # newline + indentation used to be, or end on a "." that turns into
+        # an Obsidian "..md" filename once export.py appends the extension.
+        label = _shorten_rationale_label(text)
+        rid = _make_id(stem, "rationale", str(line))
+        if rid not in seen_ids:
+            seen_ids.add(rid)
+            nodes.append({
+                "id": rid,
+                "label": label,
+                "file_type": "rationale",
+                "source_file": str_path,
+                "source_location": f"L{line}",
+            })
+        edges.append({
+            "source": rid,
+            "target": parent_nid,
+            "relation": "rationale_for",
+            "confidence": "EXTRACTED",
+            "source_file": str_path,
+            "source_location": f"L{line}",
+            "weight": 1.0,
+        })
+
+    # Module-level docstring — skip for auto-generated files (Alembic, Django
+    # migrations, protobuf stubs, etc.) whose module docstrings are revision
+    # annotations, not architectural rationale.
+    if not _is_autogenerated_python(source):
+        ds = _get_docstring(root)
+        if ds:
+            _add_rationale(ds[0], ds[1], file_nid)
+
+    # Class and function docstrings
+    def walk_docstrings(node, parent_nid: str) -> None:
+        t = node.type
+        if t == "class_definition":
+            name_node = node.child_by_field_name("name")
+            body = node.child_by_field_name("body")
+            if name_node and body:
+                class_name = source[name_node.start_byte:name_node.end_byte].decode("utf-8", errors="replace")
+                nid = _make_id(stem, class_name)
+                ds = _get_docstring(body)
+                if ds:
+                    _add_rationale(ds[0], ds[1], nid)
+                for child in body.children:
+                    walk_docstrings(child, nid)
+            return
+        if t == "function_definition":
+            name_node = node.child_by_field_name("name")
+            body = node.child_by_field_name("body")
+            if name_node and body:
+                func_name = source[name_node.start_byte:name_node.end_byte].decode("utf-8", errors="replace")
+                nid = _make_id(parent_nid, func_name) if parent_nid != file_nid else _make_id(stem, func_name)
+                ds = _get_docstring(body)
+                if ds:
+                    _add_rationale(ds[0], ds[1], nid)
+            return
+        for child in node.children:
+            walk_docstrings(child, parent_nid)
+
+    walk_docstrings(root, file_nid)
+
+    # Rationale comments (# NOTE:, # IMPORTANT:, etc.)
+    source_text = source.decode("utf-8", errors="replace")
+    for lineno, line_text in enumerate(source_text.splitlines(), start=1):
+        stripped = line_text.strip()
+        if any(stripped.startswith(p) for p in _RATIONALE_PREFIXES):
+            _add_rationale(stripped, lineno, file_nid)
+
+
+def extract_python(path: Path) -> dict:
+    """Extract classes, functions, and imports from a .py file via tree-sitter AST."""
+    result = _extract_generic(path, _PYTHON_CONFIG)
+    if "error" not in result:
+        _extract_python_rationale(path, result)
+    return result
diff --git a/graphify/extractors/ruby.py b/graphify/extractors/ruby.py
new file mode 100644
index 0000000000..1f2636fd59
--- /dev/null
+++ b/graphify/extractors/ruby.py
@@ -0,0 +1,31 @@
+"""Ruby extractor. Moved verbatim from graphify/extract.py."""
+from __future__ import annotations
+
+from pathlib import Path
+
+from graphify.extractors.models import LanguageConfig
+from graphify.extractors.engine import _extract_generic
+
+
+_RUBY_CONFIG = LanguageConfig(
+    ts_module="tree_sitter_ruby",
+    # `module Foo` is a container node just like `class Foo` in tree-sitter's
+    # Ruby grammar (name in a `constant` child, body in `body_statement`), so it
+    # gets a node and its methods attach via `method` (#1640). Without it, plain
+    # utility/`module_function` modules produced no node and their methods hung
+    # off the file via `contains` with dot-less labels.
+    class_types=frozenset({"class", "module"}),
+    function_types=frozenset({"method", "singleton_method"}),
+    import_types=frozenset(),
+    call_types=frozenset({"call"}),
+    call_function_field="method",
+    call_accessor_node_types=frozenset(),
+    name_fallback_child_types=("constant", "scope_resolution", "identifier"),
+    body_fallback_child_types=("body_statement",),
+    function_boundary_types=frozenset({"method", "singleton_method"}),
+)
+
+
+def extract_ruby(path: Path) -> dict:
+    """Extract classes, methods, singleton methods, and calls from a .rb file."""
+    return _extract_generic(path, _RUBY_CONFIG)
diff --git a/graphify/extractors/scala.py b/graphify/extractors/scala.py
new file mode 100644
index 0000000000..9c3a7952eb
--- /dev/null
+++ b/graphify/extractors/scala.py
@@ -0,0 +1,49 @@
+"""Scala extractor. Moved verbatim from graphify/extract.py."""
+from __future__ import annotations
+
+from pathlib import Path
+
+from graphify.extractors.models import LanguageConfig
+from graphify.extractors.engine import _extract_generic
+from graphify.extractors.base import _make_id, _read_text
+
+
+def _import_scala(node, source: bytes, file_nid: str, stem: str, edges: list, str_path: str, scope_stack: list[str] | None = None) -> None:
+    for child in node.children:
+        if child.type in ("stable_id", "identifier"):
+            raw = _read_text(child, source)
+            module_name = raw.split(".")[-1].strip("{} ")
+            if module_name and module_name != "_":
+                tgt_nid = _make_id(module_name)
+                edges.append({
+                    "source": file_nid,
+                    "target": tgt_nid,
+                    "relation": "imports",
+                    "context": "import",
+                    "confidence": "EXTRACTED",
+                    "source_file": str_path,
+                    "source_location": f"L{node.start_point[0] + 1}",
+                    "weight": 1.0,
+                })
+            break
+
+
+_SCALA_CONFIG = LanguageConfig(
+    ts_module="tree_sitter_scala",
+    class_types=frozenset({"class_definition", "object_definition"}),
+    function_types=frozenset({"function_definition"}),
+    import_types=frozenset({"import_declaration"}),
+    call_types=frozenset({"call_expression"}),
+    call_function_field="",
+    call_accessor_node_types=frozenset({"field_expression"}),
+    call_accessor_field="field",
+    name_fallback_child_types=("identifier",),
+    body_fallback_child_types=("template_body",),
+    function_boundary_types=frozenset({"function_definition"}),
+    import_handler=_import_scala,
+)
+
+
+def extract_scala(path: Path) -> dict:
+    """Extract classes, objects, functions, and imports from a .scala file."""
+    return _extract_generic(path, _SCALA_CONFIG)
diff --git a/graphify/extractors/slnx.py b/graphify/extractors/slnx.py
new file mode 100644
index 0000000000..89e452a210
--- /dev/null
+++ b/graphify/extractors/slnx.py
@@ -0,0 +1,92 @@
+"""Slnx extractor. Moved verbatim from graphify/extract.py."""
+from __future__ import annotations
+
+from pathlib import Path
+
+from graphify.extractors.base import _PROJECT_XML_MAX_BYTES, _make_id, _project_xml_is_safe
+
+
+def extract_slnx(path: Path) -> dict:
+    """Extract projects and inter-project dependencies from a .slnx file.
+
+    .slnx is the XML-based replacement for the legacy .sln format. Projects
+    are listed as ``<Project Path="..."/>`` elements (optionally nested inside
+    ``<Folder>`` elements) and build-order dependencies as ``<BuildDependency
+    Project="..."/>`` children. Unlike .sln there are no GUIDs -- projects are
+    identified by their path.
+    """
+    import xml.etree.ElementTree as ET
+
+    try:
+        src = path.read_bytes()
+    except OSError:
+        return {"nodes": [], "edges": [], "error": f"cannot read {path}"}
+
+    if len(src) > _PROJECT_XML_MAX_BYTES:
+        return {"nodes": [], "edges": [], "error": "project file too large"}
+    if not _project_xml_is_safe(src):
+        return {"nodes": [], "edges": [],
+                "error": "refusing XML with DOCTYPE/ENTITY declaration"}
+
+    try:
+        tree = ET.fromstring(src)
+    except ET.ParseError as e:
+        return {"nodes": [], "edges": [], "error": f"XML parse error: {e}"}
+
+    file_nid = _make_id(str(path))
+    str_path = str(path)
+    nodes: list[dict] = [{"id": file_nid, "label": path.name, "file_type": "code",
+                          "source_file": str_path, "source_location": None}]
+    edges: list[dict] = []
+    seen_ids: set[str] = set()
+    seen_ids.add(file_nid)
+
+    ns = ""
+    if tree.tag.startswith("{"):
+        ns = tree.tag.split("}")[0] + "}"
+
+    def _resolve(proj_path: str) -> str:
+        proj_path = proj_path.replace("\\", "/")
+        try:
+            return str((path.parent / proj_path).resolve())
+        except Exception:
+            return proj_path
+
+    # First pass: collect projects (anywhere in the tree, incl. <Folder>).
+    project_nids: set[str] = set()
+    for proj in tree.iter(f"{ns}Project"):
+        proj_path = proj.get("Path")
+        if not proj_path:
+            continue
+        abs_proj = _resolve(proj_path)
+        proj_nid = _make_id(abs_proj)
+        if proj_nid and proj_nid not in seen_ids:
+            seen_ids.add(proj_nid)
+            label = Path(proj_path).stem
+            nodes.append({"id": proj_nid, "label": label,
+                          "file_type": "code", "source_file": abs_proj,
+                          "source_location": None})
+            edges.append({"source": file_nid, "target": proj_nid,
+                          "relation": "contains", "confidence": "EXTRACTED",
+                          "source_file": str_path, "weight": 1.0})
+        if proj_nid:
+            project_nids.add(proj_nid)
+
+    # Second pass: build-order dependencies between known projects.
+    for proj in tree.iter(f"{ns}Project"):
+        proj_path = proj.get("Path")
+        if not proj_path:
+            continue
+        from_nid = _make_id(_resolve(proj_path))
+        for dep in proj.iter(f"{ns}BuildDependency"):
+            dep_path = dep.get("Project")
+            if not dep_path:
+                continue
+            to_nid = _make_id(_resolve(dep_path))
+            if (from_nid and to_nid and from_nid != to_nid
+                    and to_nid in project_nids):
+                edges.append({"source": from_nid, "target": to_nid,
+                              "relation": "imports", "confidence": "EXTRACTED",
+                              "source_file": str_path, "weight": 1.0})
+
+    return {"nodes": nodes, "edges": edges}
diff --git a/graphify/extractors/svelte.py b/graphify/extractors/svelte.py
new file mode 100644
index 0000000000..6fddfa9fb4
--- /dev/null
+++ b/graphify/extractors/svelte.py
@@ -0,0 +1,65 @@
+"""Svelte extractor. Moved verbatim from graphify/extract.py."""
+from __future__ import annotations
+
+from pathlib import Path
+
+from graphify.extractors.engine import _extract_generic
+from graphify.extractors.base import _make_id
+from graphify.extractors.resolution import _load_tsconfig_aliases, _load_tsconfig_base_url
+from graphify.extractors.js import _JS_CONFIG, _emit_rescued_import
+
+
+def extract_svelte(path: Path) -> dict:
+    """Extract imports from .svelte files: script-block via JS AST + template regex fallback.
+
+    Tree-sitter only sees the <script> block. Svelte template syntax like
+    {#await import('./X.svelte')} lives in the markup layer and is invisible
+    to the JS parser, so a regex pass covers those dynamic imports.
+    """
+    result = _extract_generic(path, _JS_CONFIG)
+    try:
+        import re as _re
+        src = path.read_text(encoding="utf-8", errors="replace")
+        existing_ids = {n["id"] for n in result.get("nodes", [])}
+        # Source file node ID must match the one _extract_generic creates:
+        # _make_id(str(path)) - single arg, no stem prefix. Otherwise the source
+        # endpoint is a phantom node and build_from_json drops the edge (#701).
+        file_node_id = _make_id(str(path))
+        aliases = _load_tsconfig_aliases(path.parent)
+        base_url = _load_tsconfig_base_url(path.parent)
+        for m in _re.finditer(r"""import\(\s*['"]([^'"]+)['"]\s*\)""", src):
+            raw = m.group(1)
+            if not raw:
+                continue
+            # Resolution + emit shared with the static pass below: relative
+            # paths and tsconfig aliases probe real on-disk extensions (#716,
+            # #701), and a target that IS a real file emits an edge stamped
+            # with target_file instead of an absolute-id ghost stub (#2195).
+            _emit_rescued_import(
+                result, existing_ids, file_node_id, path, raw,
+                "dynamic_import", aliases, base_url,
+            )
+        # Static imports inside <script> blocks. The JS tree-sitter parser fed
+        # the full .svelte file produces a top-level ERROR node (HTML markup
+        # is not valid JS), so import_statement nodes are never reached and
+        # static imports are silently dropped (#713). Regex over each script
+        # body recovers them.
+        script_re = _re.compile(
+            r"<script\b[^>]*>([\s\S]*?)</script\s*>", _re.IGNORECASE
+        )
+        static_import_re = _re.compile(
+            r"""import\s+(?:[^'"`;]+?\s+from\s+)?['"]([^'"]+)['"]"""
+        )
+        for script_match in script_re.finditer(src):
+            script_body = script_match.group(1)
+            for m in static_import_re.finditer(script_body):
+                raw = m.group(1)
+                if not raw:
+                    continue
+                _emit_rescued_import(
+                    result, existing_ids, file_node_id, path, raw,
+                    "imports_from", aliases, base_url,
+                )
+    except Exception:
+        pass
+    return result
diff --git a/graphify/extractors/swift.py b/graphify/extractors/swift.py
new file mode 100644
index 0000000000..a1c51d1a0a
--- /dev/null
+++ b/graphify/extractors/swift.py
@@ -0,0 +1,58 @@
+"""Swift extractor. Moved verbatim from graphify/extract.py."""
+from __future__ import annotations
+
+from pathlib import Path
+
+from graphify.extractors.models import LanguageConfig
+from graphify.extractors.engine import _extract_generic
+from graphify.extractors.base import _make_id, _read_text
+
+
+def _import_swift(node, source: bytes, file_nid: str, stem: str, edges: list, str_path: str, scope_stack: list[str] | None = None) -> list[tuple[str, str]]:
+    """Emit module-level ``imports`` edges and report the imported modules.
+
+    A Swift ``import CoreKit`` names a module, not a file path, so — unlike the
+    file-resolving JS/TS handlers — there is no existing node for the edge to
+    point at. The returned ``(id, label)`` pairs let the extractor materialize a
+    ``type=module`` anchor node so the edge survives; without it ``build_from_json``
+    prunes every Swift import edge as a dangling/external reference (#1327).
+    """
+    modules: list[tuple[str, str]] = []
+    for child in node.children:
+        if child.type == "identifier":
+            raw = _read_text(child, source)
+            tgt_nid = _make_id(raw)
+            edges.append({
+                "source": file_nid,
+                "target": tgt_nid,
+                "relation": "imports",
+                "context": "import",
+                "confidence": "EXTRACTED",
+                "source_file": str_path,
+                "source_location": f"L{node.start_point[0] + 1}",
+                "weight": 1.0,
+            })
+            modules.append((tgt_nid, raw))
+            break
+    return modules
+
+
+_SWIFT_CONFIG = LanguageConfig(
+    ts_module="tree_sitter_swift",
+    class_types=frozenset({"class_declaration", "protocol_declaration"}),
+    function_types=frozenset({"function_declaration", "init_declaration", "deinit_declaration", "subscript_declaration"}),
+    import_types=frozenset({"import_declaration"}),
+    call_types=frozenset({"call_expression"}),
+    call_function_field="",
+    call_accessor_node_types=frozenset({"navigation_expression"}),
+    call_accessor_field="",
+    name_fallback_child_types=("simple_identifier", "type_identifier", "user_type"),
+    body_fallback_child_types=("class_body", "protocol_body", "function_body", "enum_class_body"),
+    function_boundary_types=frozenset({"function_declaration", "init_declaration", "deinit_declaration", "subscript_declaration"}),
+    import_handler=_import_swift,
+)
+
+
+def extract_swift(path: Path) -> dict:
+    """Extract classes, structs, protocols, functions, imports, and calls from a .swift file."""
+    return _extract_generic(path, _SWIFT_CONFIG)
diff --git a/graphify/extractors/vue.py b/graphify/extractors/vue.py
new file mode 100644
index 0000000000..ad89101a41
--- /dev/null
+++ b/graphify/extractors/vue.py
@@ -0,0 +1,57 @@
+"""Vue extractor. Moved verbatim from graphify/extract.py."""
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from graphify.extractors.engine import _extract_generic
+from graphify.extractors.base import _make_id
+from graphify.extractors.resolution import (
+    _load_tsconfig_aliases,
+    _load_tsconfig_base_url,
+    _vue_mask_non_script,
+)
+from graphify.extractors.js import _JS_CONFIG, _TS_CONFIG, _TSX_CONFIG, _emit_rescued_import
+
+
+def extract_vue(path: Path) -> dict:
+    """Extract imports, symbols, and type refs from a ``.vue`` SFC.
+
+    Masks the non-``<script>`` regions and parses the script with the grammar
+    its ``lang`` implies (``tsx``→TSX, ``js``/``jsx``→JS, ``ts`` or unset→TS;
+    TS is a superset of JS so it is a safe default). A regex pass then recovers
+    ``import('…')`` dynamic imports the AST does not edge.
+    """
+    try:
+        src = path.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return {"nodes": [], "edges": []}
+
+    masked, lang = _vue_mask_non_script(src)
+    if lang == "tsx":
+        config = _TSX_CONFIG
+    elif lang in ("js", "jsx"):
+        config = _JS_CONFIG
+    else:  # "ts" or unspecified — default to the TS grammar (superset of JS)
+        config = _TS_CONFIG
+
+    result = _extract_generic(path, config, source_override=masked.encode("utf-8"))
+
+    # Dynamic `import('…')` calls aren't edged by the AST pass; recover by regex,
+    # mirroring extract_svelte/extract_astro.
+    try:
+        existing_ids = {n["id"] for n in result.get("nodes", [])}
+        file_node_id = _make_id(str(path))
+        aliases = _load_tsconfig_aliases(path.parent)
+        base_url = _load_tsconfig_base_url(path.parent)
+        for m in re.finditer(r"""import\(\s*['"]([^'"]+)['"]\s*\)""", src):
+            raw = m.group(1)
+            if not raw:
+                continue
+            _emit_rescued_import(
+                result, existing_ids, file_node_id, path, raw,
+                "dynamic_import", aliases, base_url,
+            )
+    except Exception:
+        pass
+    return result
diff --git a/graphify/extractors/xaml.py b/graphify/extractors/xaml.py
new file mode 100644
index 0000000000..0b0d78f214
--- /dev/null
+++ b/graphify/extractors/xaml.py
@@ -0,0 +1,636 @@
+"""XAML extractor. Moved verbatim from graphify/extract.py."""
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Any
+
+from graphify.extractors.base import (
+    _PROJECT_XML_MAX_BYTES,
+    _file_stem,
+    _make_id,
+    _project_xml_is_safe,
+)
+from graphify.extractors.csharp import extract_csharp
+
+
+def _xml_local_name(name: str) -> str:
+    return name.rsplit("}", 1)[-1] if name.startswith("{") else name
+
+
+# A .NET event handler has the signature `(object sender, <T>EventArgs e)`. Used
+# to tell a real event handler in the code-behind apart from an ordinary method
+# whose name a XAML attribute value happens to match. Tolerates `object?`, a
+# namespace-qualified args type, and a generic `EventArgs<T>`.
+_EVENT_HANDLER_SIGNATURE_RE = re.compile(
+    r"\(\s*object\??\s+\w+\s*,\s*[\w.]*EventArgs(?:<[^>]*>)?\s+\w+\s*\)"
+)
+
+# XAML attribute names that carry free-form strings or identifiers and never name
+# an event handler. They are skipped when matching attribute values to code-behind
+# methods so e.g. Content="Save" or Tag="Refresh" can't fabricate an event edge.
+_XAML_NON_EVENT_ATTRS = frozenset({
+    "Name", "Content", "Text", "Title", "Tag", "ToolTip", "Header",
+    "Class", "Key", "Uid", "DataContext", "Style", "Source",
+})
+
+# A handler attribute value is a bare method name (e.g. Click="Save_Click"), not
+# markup, a path, or a sentence. Used to skip values like "{Binding ...}" or
+# free-form content before looking them up as code-behind methods.
+_XAML_IDENT_RE = re.compile(r"[A-Za-z_]\w*")
+_XAML_DESIGN_INSTANCE_TYPE_RE = re.compile(
+    r"\bType\s*=\s*(?:\{x:Type\s+)?(?P<type>[\w.:+]+)"
+)
+
+
+def _xaml_markup_extension(value: str) -> tuple[str, str] | None:
+    value = value.strip()
+    if not (value.startswith("{") and value.endswith("}")):
+        return None
+    inner = value[1:-1].strip()
+    if not inner or inner.startswith("}"):
+        return None
+    name, _, args = inner.partition(" ")
+    return name, args.strip()
+
+
+def _xaml_split_markup_args(args: str) -> list[str]:
+    parts: list[str] = []
+    start = 0
+    depth = 0
+    for idx, ch in enumerate(args):
+        if ch == "{":
+            depth += 1
+        elif ch == "}" and depth:
+            depth -= 1
+        elif ch == "," and depth == 0:
+            parts.append(args[start:idx].strip())
+            start = idx + 1
+    tail = args[start:].strip()
+    if tail:
+        parts.append(tail)
+    return parts
+
+
+def _xaml_static_resource_key(value: str) -> str | None:
+    markup = _xaml_markup_extension(value)
+    if not markup:
+        return None
+    name, args = markup
+    if name != "StaticResource":
+        return None
+    for part in _xaml_split_markup_args(args):
+        if "=" not in part:
+            return part.strip() or None
+        key, resource = part.split("=", 1)
+        if key.strip() == "ResourceKey":
+            return resource.strip() or None
+    return None
+
+
+def _xaml_binding_refs(value: str) -> tuple[str | None, str | None]:
+    markup = _xaml_markup_extension(value)
+    if not markup:
+        return None, None
+    name, args = markup
+    if name != "Binding":
+        return None, None
+
+    path_ref = None
+    converter_ref = None
+    for part in _xaml_split_markup_args(args):
+        if not part:
+            continue
+        if "=" not in part:
+            if path_ref is None:
+                path_ref = part.strip()
+            continue
+        key, raw_value = part.split("=", 1)
+        key = key.strip()
+        raw_value = raw_value.strip()
+        if key == "Path":
+            path_ref = raw_value
+        elif key == "Converter":
+            converter_ref = _xaml_static_resource_key(raw_value)
+
+    if path_ref and ("{" in path_ref or "}" in path_ref):
+        path_ref = None
+    return path_ref or None, converter_ref or None
+
+
+def _xaml_codebehind_path(path: Path) -> Path | None:
+    expected = path.with_suffix(path.suffix + ".cs")
+    if expected.exists():
+        return expected
+    try:
+        for sibling in path.parent.iterdir():
+            if sibling.name.casefold() == expected.name.casefold():
+                return sibling
+    except OSError:
+        return None
+    return None
+
+
+def _xaml_codebehind_symbols(
+    path: Path,
+    class_name: str | None,
+) -> tuple[dict | None, dict[str, dict], list[dict]]:
+    codebehind = _xaml_codebehind_path(path)
+    if not codebehind:
+        return None, {}, []
+    result = extract_csharp(codebehind)
+    if result.get("error"):
+        return None, {}, []
+
+    class_simple = class_name.rsplit(".", 1)[-1] if class_name else None
+    class_node = None
+    if class_simple:
+        for node in result.get("nodes", []):
+            if node.get("label") == class_simple:
+                class_node = node
+                break
+
+    class_method_edges: list[dict] = []
+    if class_node:
+        class_id = class_node.get("id")
+        for edge in result.get("edges", []):
+            if edge.get("source") == class_id and edge.get("relation") == "method":
+                class_method_edges.append(edge)
+    method_ids = {edge.get("target") for edge in class_method_edges} if class_node else None
+
+    # Only methods with a .NET event-handler signature -- (object sender,
+    # <T>EventArgs e) -- are eligible to be wired to a XAML attribute as an
+    # event. Without this gate, any attribute whose value happens to match a
+    # method name (e.g. Content="Save" next to a business method Save()) would
+    # produce a spurious "event" edge. The C# extractor does not record the
+    # parameter list on method nodes, so we read it from the code-behind source
+    # at the method's recorded line.
+    try:
+        cb_lines = codebehind.read_text(encoding="utf-8", errors="replace").splitlines()
+    except OSError:
+        cb_lines = []
+
+    def _has_event_handler_signature(node: dict) -> bool:
+        loc = str(node.get("source_location") or "")
+        m = re.match(r"L(\d+)", loc)
+        if not m or not cb_lines:
+            return False
+        start = int(m.group(1)) - 1
+        # Join a few lines so a signature split across lines still matches.
+        snippet = " ".join(cb_lines[start:start + 3])
+        return _EVENT_HANDLER_SIGNATURE_RE.search(snippet) is not None
+
+    methods: dict[str, dict] = {}
+    for node in result.get("nodes", []):
+        if method_ids is not None and node.get("id") not in method_ids:
+            continue
+        label = str(node.get("label", ""))
+        if label.startswith(".") and label.endswith("()") and _has_event_handler_signature(node):
+            methods[label.strip("()").lstrip(".")] = node
+    return class_node, methods, class_method_edges
+
+
+def _xaml_type_simple_name(type_ref: str) -> str | None:
+    type_ref = type_ref.strip().strip("{}")
+    if not type_ref:
+        return None
+    type_ref = type_ref.split(",", 1)[0].strip()
+    if type_ref.startswith("x:Type "):
+        type_ref = type_ref[len("x:Type "):].strip()
+    if ":" in type_ref:
+        type_ref = type_ref.rsplit(":", 1)[-1]
+    if "." in type_ref:
+        type_ref = type_ref.rsplit(".", 1)[-1]
+    if "+" in type_ref:
+        type_ref = type_ref.rsplit("+", 1)[-1]
+    return type_ref if _XAML_IDENT_RE.fullmatch(type_ref) else None
+
+
+def _xaml_explicit_viewmodel_names(tree) -> tuple[bool, list[str]]:
+    has_data_context = False
+    names: list[str] = []
+    for elem in tree.iter():
+        elem_type = _xml_local_name(elem.tag)
+        if elem_type.endswith(".DataContext") or elem_type == "DataContext":
+            has_data_context = True
+            for child in list(elem):
+                vm_name = _xaml_type_simple_name(_xml_local_name(child.tag))
+                if vm_name and vm_name not in names:
+                    names.append(vm_name)
+        for key, value in elem.attrib.items():
+            if _xml_local_name(key) != "DataContext" or not value:
+                continue
+            has_data_context = True
+            match = _XAML_DESIGN_INSTANCE_TYPE_RE.search(value)
+            if match:
+                vm_name = _xaml_type_simple_name(match.group("type"))
+                if vm_name and vm_name not in names:
+                    names.append(vm_name)
+    return has_data_context, names
+
+
+def _xaml_prism_autowire_viewmodel(tree) -> bool:
+    for elem in tree.iter():
+        for key, value in elem.attrib.items():
+            if (
+                _xml_local_name(key).endswith("ViewModelLocator.AutoWireViewModel")
+                and value.strip().lower() == "true"
+            ):
+                return True
+    return False
+
+
+def _xaml_inferred_viewmodel_names(view_name: str | None) -> list[str]:
+    if not view_name:
+        return []
+    names: list[str] = []
+
+    def add(name: str) -> None:
+        if name.endswith("ViewModel") and name not in names:
+            names.append(name)
+
+    if view_name == "MainWindow":
+        add("MainWindowViewModel")
+        add("MainViewModel")
+    for suffix in ("UserControl", "View", "Page", "Control"):
+        if view_name.endswith(suffix) and len(view_name) > len(suffix):
+            add(view_name[:-len(suffix)] + "ViewModel")
+            break
+    return names
+
+
+def _xaml_project_root(path: Path) -> Path:
+    project_markers = (".csproj", ".fsproj", ".vbproj", ".sln", ".slnx")
+    root = path.parent
+    for directory in (path.parent, *path.parent.parents):
+        try:
+            if any(child.suffix in project_markers for child in directory.iterdir()):
+                root = directory
+                break
+        except OSError:
+            continue
+    if _XAML_ACTIVE_EXTRACT_ROOT is None:
+        return root
+    boundary = _XAML_ACTIVE_EXTRACT_ROOT.resolve()
+    try:
+        root.resolve().relative_to(boundary)
+        return root
+    except ValueError:
+        return boundary
+
+
+def _xaml_csharp_class_nodes(path: Path) -> dict[str, list[dict]]:
+    from graphify.detect import _is_ignored, _is_noise_dir, _load_graphifyignore
+    root = _xaml_project_root(path)
+    cache_key = str(root.resolve()) if _XAML_ACTIVE_EXTRACT_ROOT is not None else None
+    if cache_key and cache_key in _XAML_CSHARP_CLASS_CACHE:
+        return _XAML_CSHARP_CLASS_CACHE[cache_key]
+    classes: dict[str, list[dict]] = {}
+    patterns = _load_graphifyignore(root)
+    ignore_cache: dict[Path, bool] = {}
+    # Prune noise/hidden dirs DURING traversal (not after) so the scan never
+    # descends into node_modules/.venv/.git/build/..., and CAP the number of
+    # directories visited. rglob("*.cs") used to walk the entire tree first,
+    # which on a mis-resolved or huge root (e.g. a .xaml under a shared temp dir
+    # or a giant monorepo, where _xaml_project_root climbs to a broad ancestor)
+    # scanned millions of paths and effectively hung. A real .NET project sits
+    # well under the cap; a runaway root is bounded to a fast, partial scan
+    # instead of hanging.
+    import os as _os
+    _DIR_CAP = 20000
+    cs_files: list[Path] = []
+    visited = 0
+    try:
+        for dirpath, dirnames, filenames in _os.walk(root):
+            dirnames[:] = [
+                d for d in dirnames if not d.startswith(".") and not _is_noise_dir(d)
+            ]
+            for fn in filenames:
+                if fn.endswith(".cs"):
+                    cs_files.append(Path(dirpath) / fn)
+            visited += 1
+            if visited >= _DIR_CAP:
+                break
+    except OSError:
+        return classes
+    cs_files.sort()
+    for cs_path in cs_files:
+        if patterns and _is_ignored(cs_path, root, patterns, _cache=ignore_cache):
+            continue
+        result = extract_csharp(cs_path)
+        if result.get("error"):
+            continue
+        for node in result.get("nodes", []):
+            label = str(node.get("label", ""))
+            if not label.endswith("ViewModel") or not _XAML_IDENT_RE.fullmatch(label):
+                continue
+            if node.get("source_file"):
+                classes.setdefault(label, []).append(node)
+    if cache_key:
+        _XAML_CSHARP_CLASS_CACHE[cache_key] = classes
+    return classes
+
+
+def _xaml_pascal_name(name: str) -> str | None:
+    name = name.strip().lstrip("_")
+    if name.startswith("m_"):
+        name = name[2:]
+    return name[:1].upper() + name[1:] if _XAML_IDENT_RE.fullmatch(name) else None
+
+
+_XAML_TOOLKIT_FIELD_RE = re.compile(r"\b(?P<name>_?m?_?[A-Za-z_]\w*)\s*(?:=.*)?;")
+_XAML_TOOLKIT_METHOD_RE = re.compile(r"\b(?P<name>[A-Za-z_]\w*)\s*\(")
+_XAML_ACTIVE_EXTRACT_ROOT: Path | None = None
+_XAML_CSHARP_CLASS_CACHE: dict[str, dict[str, list[dict]]] = {}
+
+
+def _xaml_communitytoolkit_members(vm_node: dict) -> tuple[dict[str, dict], list[dict]]:
+    source_file = vm_node.get("source_file")
+    vm_id = vm_node.get("id")
+    if not source_file or not vm_id:
+        return {}, []
+    try:
+        # errors="replace" so a non-UTF8 code-behind can't raise UnicodeDecodeError
+        # and abort the whole extract_xaml (matches every other reader here).
+        lines = Path(source_file).read_text(encoding="utf-8", errors="replace").splitlines()
+    except OSError:
+        return {}, []
+
+    members: dict[str, dict] = {}
+    edges: list[dict] = []
+
+    def add_member(label: str, line_no: int, context: str) -> None:
+        nid = _make_id(vm_id, label)
+        members[label] = {
+            "id": nid,
+            "label": label,
+            "file_type": "code",
+            "source_file": source_file,
+            "source_location": f"L{line_no}",
+        }
+        edges.append({
+            "source": vm_id,
+            "target": nid,
+            "relation": "defines",
+            "confidence": "INFERRED",
+            "source_file": source_file,
+            "source_location": f"L{line_no}",
+            "weight": 1.0,
+            "context": context,
+        })
+
+    pending: tuple[str, int] | None = None
+    for line_no, line in enumerate(lines, 1):
+        remainder = line.split("]", 1)[1].strip() if "]" in line else ""
+        if "[" in line and "ObservableProperty" in line:
+            pending = ("property", line_no)
+            if not remainder:
+                continue
+            line = remainder
+        if "[" in line and "RelayCommand" in line:
+            pending = ("command", line_no)
+            if not remainder:
+                continue
+            line = remainder
+        if not pending or not line.strip() or line.lstrip().startswith("["):
+            continue
+
+        kind, attr_line = pending
+        pending = None
+        if kind == "property":
+            match = _XAML_TOOLKIT_FIELD_RE.search(line)
+            label = _xaml_pascal_name(match.group("name")) if match else None
+            if label:
+                add_member(label, attr_line, "communitytoolkit_observable_property")
+        else:
+            match = _XAML_TOOLKIT_METHOD_RE.search(line)
+            if match:
+                method = match.group("name").removesuffix("Async")
+                add_member(f"{method}Command", attr_line, "communitytoolkit_relay_command")
+
+    return members, edges
+
+
+def extract_xaml(path: Path) -> dict:
+    """Extract WPF/XAML structure, bindings, x:Class, and event handler references."""
+    import xml.etree.ElementTree as ET
+
+    try:
+        src = path.read_bytes()
+    except OSError:
+        return {"nodes": [], "edges": [], "error": f"cannot read {path}"}
+
+    if len(src) > _PROJECT_XML_MAX_BYTES:
+        return {"nodes": [], "edges": [], "error": "xaml file too large"}
+    if not _project_xml_is_safe(src):
+        return {"nodes": [], "edges": [],
+                "error": "refusing XML with DOCTYPE/ENTITY declaration"}
+
+    try:
+        tree = ET.fromstring(src)
+    except ET.ParseError as e:
+        return {"nodes": [], "edges": [], "error": f"XML parse error: {e}"}
+
+    text = src.decode("utf-8", errors="replace")
+    lines = text.splitlines()
+    str_path = str(path)
+    stem = _file_stem(path)
+    file_nid = _make_id(str(path))
+    root_type = _xml_local_name(tree.tag)
+    root_nid = _make_id(stem, root_type)
+    nodes: list[dict] = []
+    edges: list[dict] = []
+    seen_ids: set[str] = set()
+    seen_edges: set[tuple[str, str, str, str | None]] = set()
+
+    def line_for(value: str | None) -> int:
+        if value:
+            for idx, line in enumerate(lines, 1):
+                if value in line:
+                    return idx
+        return 1
+
+    def add_node(
+        nid: str,
+        label: str,
+        line: int | None,
+        *,
+        file_type: str = "code",
+        source_file: str = str_path,
+    ) -> None:
+        if nid in seen_ids:
+            return
+        seen_ids.add(nid)
+        nodes.append({
+            "id": nid, "label": label, "file_type": file_type,
+            "source_file": source_file,
+            "source_location": f"L{line}" if line else None,
+        })
+
+    def add_existing_node(node: dict | None) -> None:
+        if not node:
+            return
+        nid = node.get("id")
+        if not nid or nid in seen_ids:
+            return
+        seen_ids.add(nid)
+        nodes.append(dict(node))
+
+    def add_edge(
+        src_nid: str,
+        tgt_nid: str,
+        relation: str,
+        line: int,
+        *,
+        context: str | None = None,
+        source_file: str = str_path,
+        confidence: str = "EXTRACTED",
+    ) -> None:
+        key = (src_nid, tgt_nid, relation, context)
+        if key in seen_edges:
+            return
+        seen_edges.add(key)
+        edge = {
+            "source": src_nid, "target": tgt_nid, "relation": relation,
+            "confidence": confidence, "source_file": source_file,
+            "source_location": f"L{line}", "weight": 1.0,
+        }
+        if context:
+            edge["context"] = context
+        edges.append(edge)
+
+    def add_existing_edge(edge: dict) -> None:
+        key = (edge.get("source"), edge.get("target"), edge.get("relation"), edge.get("context"))
+        if key in seen_edges:
+            return
+        seen_edges.add(key)
+        edges.append(dict(edge))
+
+    add_node(file_nid, path.name, 1)
+    add_node(root_nid, root_type, 1)
+    add_edge(file_nid, root_nid, "contains", 1)
+
+    class_name = None
+    for key, value in tree.attrib.items():
+        if _xml_local_name(key) == "Class" and value:
+            class_name = value.strip()
+            break
+
+    class_node, codebehind_methods, class_method_edges = _xaml_codebehind_symbols(path, class_name)
+    if class_name:
+        if class_node:
+            class_nid = class_node["id"]
+            add_existing_node(class_node)
+        else:
+            class_label = class_name.rsplit(".", 1)[-1]
+            class_nid = _make_id(stem, class_label)
+            add_node(class_nid, class_label, line_for(class_name))
+        add_edge(root_nid, class_nid, "references", line_for(class_name), context="x_class")
+
+    has_data_context, vm_names = _xaml_explicit_viewmodel_names(tree)
+    prism_autowire = _xaml_prism_autowire_viewmodel(tree)
+    vm_confidence = "EXTRACTED"
+    if not has_data_context:
+        view_name = class_name.rsplit(".", 1)[-1] if class_name else None
+        view_name = view_name or (path.stem if prism_autowire else None)
+        vm_names = _xaml_inferred_viewmodel_names(view_name)
+        vm_confidence = "INFERRED"
+    generated_members: dict[str, dict] = {}
+    generated_member_edges: list[dict] = []
+    if vm_names:
+        csharp_classes = _xaml_csharp_class_nodes(path)
+        vm_candidates = []
+        for vm_name in vm_names:
+            vm_candidates.extend(csharp_classes.get(vm_name, []))
+        by_id = {node.get("id"): node for node in vm_candidates if node.get("id")}
+        if len(by_id) == 1:
+            vm_node = next(iter(by_id.values()))
+            add_existing_node(vm_node)
+            add_edge(
+                root_nid,
+                vm_node["id"],
+                "references",
+                line_for(vm_node["label"]),
+                context="view_model",
+                confidence=vm_confidence,
+            )
+            generated_members, generated_member_edges = _xaml_communitytoolkit_members(vm_node)
+            for member in generated_members.values():
+                add_existing_node(member)
+            for member_edge in generated_member_edges:
+                add_existing_edge(member_edge)
+
+    for elem in tree.iter():
+        elem_type = _xml_local_name(elem.tag)
+        elem_name = None
+        for key, value in elem.attrib.items():
+            if _xml_local_name(key) == "Name" and value:
+                elem_name = value.strip()
+                break
+        owner_nid = root_nid
+        if elem_name:
+            owner_nid = _make_id(stem, elem_name)
+            add_node(owner_nid, elem_name, line_for(elem_name))
+            add_edge(root_nid, owner_nid, "contains", line_for(elem_name))
+            type_nid = _make_id("xaml", elem_type)
+            add_node(type_nid, elem_type, line_for(elem_name), file_type="concept")
+            add_edge(owner_nid, type_nid, "references", line_for(elem_name), context="type")
+
+        for key, value in elem.attrib.items():
+            value = value or ""
+            # Event wiring: an attribute references a handler only when its local
+            # name isn't a known free-form/identity property, its value is a bare
+            # identifier (a method name, not markup or a sentence), and the matched
+            # code-behind method actually has an event-handler signature (the gate
+            # in _xaml_codebehind_symbols). This stops Content="Save" / Tag="..."
+            # from fabricating event edges against same-named ordinary methods.
+            attr_local = _xml_local_name(key)
+            if attr_local not in _XAML_NON_EVENT_ATTRS and _XAML_IDENT_RE.fullmatch(value):
+                method = codebehind_methods.get(value)
+                if method:
+                    add_existing_node(method)
+                    add_edge(owner_nid, method["id"], "references", line_for(value), context="event")
+                    for method_edge in class_method_edges:
+                        if method_edge.get("target") == method["id"]:
+                            add_existing_node(class_node)
+                            add_existing_edge(method_edge)
+                            break
+            binding_path, binding_converter = _xaml_binding_refs(value)
+            if binding_path:
+                bind_nid = _make_id("binding", binding_path)
+                add_node(bind_nid, binding_path, line_for(value), file_type="concept")
+                binding_context = (
+                    "binding_command"
+                    if attr_local == "Command" or attr_local.endswith(".Command")
+                    else "binding_path"
+                )
+                add_edge(owner_nid, bind_nid, "references", line_for(value), context=binding_context)
+                generated_member = generated_members.get(binding_path)
+                if generated_member:
+                    add_existing_node(generated_member)
+                    add_edge(
+                        owner_nid,
+                        generated_member["id"],
+                        "references",
+                        line_for(value),
+                        context=binding_context,
+                        confidence="INFERRED",
+                    )
+            if binding_converter:
+                converter_nid = _make_id("binding_converter", binding_converter)
+                add_node(converter_nid, binding_converter, line_for(value), file_type="concept")
+                add_edge(owner_nid, converter_nid, "references", line_for(value), context="binding_converter")
+            if elem_type == "Binding" and attr_local == "Path":
+                direct_path = value.strip()
+                if direct_path and "{" not in direct_path and "}" not in direct_path:
+                    bind_nid = _make_id("binding", direct_path)
+                    add_node(bind_nid, direct_path, line_for(value), file_type="concept")
+                    add_edge(owner_nid, bind_nid, "references", line_for(value), context="binding_path")
+            if elem_type == "Binding" and attr_local == "Converter":
+                direct_converter = _xaml_static_resource_key(value)
+                if direct_converter:
+                    converter_nid = _make_id("binding_converter", direct_converter)
+                    add_node(converter_nid, direct_converter, line_for(value), file_type="concept")
+                    add_edge(owner_nid, converter_nid, "references", line_for(value), context="binding_converter")
+
+    return {"nodes": nodes, "edges": edges}
diff --git a/tests/test_extractors_registry.py b/tests/test_extractors_registry.py
index db647201ff..5fe49dcd84 100644
--- a/tests/test_extractors_registry.py
+++ b/tests/test_extractors_registry.py
@@ -42,3 +42,178 @@ def test_terraform_migrated():
 
     assert facade.extract_terraform is extract_terraform
     assert LANGUAGE_EXTRACTORS["terraform"] is extract_terraform
+
+
+def test_lazarus_package_migrated():
+    from graphify.extractors.lazarus_package import extract_lazarus_package
+
+    assert facade.extract_lazarus_package is extract_lazarus_package
+    assert LANGUAGE_EXTRACTORS["lazarus_package"] is extract_lazarus_package
+
+
+def test_slnx_migrated():
+    from graphify.extractors.slnx import extract_slnx
+
+    assert facade.extract_slnx is extract_slnx
+    assert LANGUAGE_EXTRACTORS["slnx"] is extract_slnx
+
+
+def test_csproj_migrated():
+    from graphify.extractors.csproj import extract_csproj
+
+    assert facade.extract_csproj is extract_csproj
+    assert LANGUAGE_EXTRACTORS["csproj"] is extract_csproj
+
+
+def test_objc_migrated():
+    from graphify.extractors.objc import extract_objc
+
+    assert facade.extract_objc is extract_objc
+    assert LANGUAGE_EXTRACTORS["objc"] is extract_objc
+
+
+def test_pascal_migrated():
+    from graphify.extractors.pascal import extract_pascal
+
+    assert facade.extract_pascal is extract_pascal
+    assert LANGUAGE_EXTRACTORS["pascal"] is extract_pascal
+
+
+def test_julia_migrated():
+    from graphify.extractors.julia import extract_julia
+
+    assert facade.extract_julia is extract_julia
+    assert LANGUAGE_EXTRACTORS["julia"] is extract_julia
+
+
+def test_verilog_migrated():
+    from graphify.extractors.verilog import extract_verilog
+
+    assert facade.extract_verilog is extract_verilog
+    assert LANGUAGE_EXTRACTORS["verilog"] is extract_verilog
+
+
+def test_markdown_migrated():
+    from graphify.extractors.markdown import extract_markdown
+
+    assert facade.extract_markdown is extract_markdown
+    assert LANGUAGE_EXTRACTORS["markdown"] is extract_markdown
+
+
+def test_python_migrated():
+    from graphify.extractors.python import extract_python
+
+    assert facade.extract_python is extract_python
+    assert LANGUAGE_EXTRACTORS["python"] is extract_python
+
+
+def test_js_migrated():
+    from graphify.extractors.js import extract_js
+
+    assert facade.extract_js is extract_js
+    assert LANGUAGE_EXTRACTORS["js"] is extract_js
+
+
+def test_svelte_migrated():
+    from graphify.extractors.svelte import extract_svelte
+
+    assert facade.extract_svelte is extract_svelte
+    assert LANGUAGE_EXTRACTORS["svelte"] is extract_svelte
+
+
+def test_astro_migrated():
+    from graphify.extractors.astro import extract_astro
+
+    assert facade.extract_astro is extract_astro
+    assert LANGUAGE_EXTRACTORS["astro"] is extract_astro
+
+
+def test_vue_migrated():
+    from graphify.extractors.vue import extract_vue
+
+    assert facade.extract_vue is extract_vue
+    assert LANGUAGE_EXTRACTORS["vue"] is extract_vue
+
+
+def test_java_migrated():
+    from graphify.extractors.java import extract_java
+
+    assert facade.extract_java is extract_java
+    assert LANGUAGE_EXTRACTORS["java"] is extract_java
+
+
+def test_groovy_migrated():
+    from graphify.extractors.groovy import extract_groovy
+
+    assert facade.extract_groovy is extract_groovy
+    assert LANGUAGE_EXTRACTORS["groovy"] is extract_groovy
+
+
+def test_c_migrated():
+    from graphify.extractors.c import extract_c
+
+    assert facade.extract_c is extract_c
+    assert LANGUAGE_EXTRACTORS["c"] is extract_c
+
+
+def test_cpp_migrated():
+    from graphify.extractors.cpp import extract_cpp
+
+    assert facade.extract_cpp is extract_cpp
+    assert LANGUAGE_EXTRACTORS["cpp"] is extract_cpp
+
+
+def test_ruby_migrated():
+    from graphify.extractors.ruby import extract_ruby
+
+    assert facade.extract_ruby is extract_ruby
+    assert LANGUAGE_EXTRACTORS["ruby"] is extract_ruby
+
+
+def test_csharp_migrated():
+    from graphify.extractors.csharp import extract_csharp
+
+    assert facade.extract_csharp is extract_csharp
+    assert LANGUAGE_EXTRACTORS["csharp"] is extract_csharp
+
+
+def test_kotlin_migrated():
+    from graphify.extractors.kotlin import extract_kotlin
+
+    assert facade.extract_kotlin is extract_kotlin
+    assert LANGUAGE_EXTRACTORS["kotlin"] is extract_kotlin
+
+
+def test_scala_migrated():
+    from graphify.extractors.scala import extract_scala
+
+    assert facade.extract_scala is extract_scala
+    assert LANGUAGE_EXTRACTORS["scala"] is extract_scala
+
+
+def test_php_migrated():
+    from graphify.extractors.php import extract_php
+
+    assert facade.extract_php is extract_php
+    assert LANGUAGE_EXTRACTORS["php"] is extract_php
+
+
+def test_lua_migrated():
+    from graphify.extractors.lua import extract_lua
+
+    assert facade.extract_lua is extract_lua
+    assert LANGUAGE_EXTRACTORS["lua"] is extract_lua
+
+
+def test_swift_migrated():
+    from graphify.extractors.swift import extract_swift
+
+    assert facade.extract_swift is extract_swift
+    assert LANGUAGE_EXTRACTORS["swift"] is extract_swift
+
+
+def test_xaml_migrated():
+    from graphify.extractors.xaml import extract_xaml
+
+    assert facade.extract_xaml is extract_xaml
+    assert LANGUAGE_EXTRACTORS["xaml"] is extract_xaml