diff --git a/graphify/extract.py b/graphify/extract.py
index f68757a85..ac8709173 100644
--- a/graphify/extract.py
+++ b/graphify/extract.py
@@ -137,6 +137,7 @@
     _ts_collect_type_refs,
     _ts_heritage_clause_entries,
     _ts_walk_class_members,
+    _sfc_mask_non_script,
     _vue_mask_non_script,
     _walk_js_tree,
     _walk_python_tree,
@@ -1599,16 +1600,40 @@ def _emit_rescued_import(
 
 
 def extract_svelte(path: Path) -> dict:
-    """Extract imports from .svelte files: script-block via JS AST + template regex fallback.
+    """Extract imports, symbols, and type refs from a ``.svelte`` component.
 
-    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.
+    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), mirroring
+    :func:`extract_vue`. Feeding the whole component to the JS grammar makes the
+    markup a top-level ERROR node, so ``import_statement`` and declaration nodes
+    are never reached and everything but a stray symbol is dropped (#713).
+
+    Both script blocks of a Svelte 5 component survive the mask, so a
+    ``<script module>`` block is parsed alongside the instance script.
+
+    A regex pass then recovers ``import('...')`` dynamic imports, which the AST
+    pass does not edge and which legally live in markup-layer template syntax
+    such as ``{#await import('./X.svelte')}`` — outside every script block, and
+    so blanked out of the masked source the AST sees.
     """
-    result = _extract_generic(path, _JS_CONFIG)
     try:
-        import re as _re
         src = path.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return {"nodes": [], "edges": []}
+
+    masked, lang = _sfc_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"))
+
+    try:
+        import re as _re
         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
@@ -1616,39 +1641,19 @@ def extract_svelte(path: Path) -> dict:
         file_node_id = _make_id(str(path))
         aliases = _load_tsconfig_aliases(path.parent)
         base_url = _load_tsconfig_base_url(path.parent)
+        # Scanned over the raw source, not the masked one, so template-layer
+        # dynamic imports are seen. Resolution is shared with the static pass:
+        # 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).
         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
@@ -1735,7 +1740,7 @@ def extract_vue(path: Path) -> dict:
     except OSError:
         return {"nodes": [], "edges": []}
 
-    masked, lang = _vue_mask_non_script(src)
+    masked, lang = _sfc_mask_non_script(src)
     if lang == "tsx":
         config = _TSX_CONFIG
     elif lang in ("js", "jsx"):
diff --git a/graphify/extractors/engine.py b/graphify/extractors/engine.py
index 3c8a0238d..75694ce7c 100644
--- a/graphify/extractors/engine.py
+++ b/graphify/extractors/engine.py
@@ -1912,6 +1912,20 @@ def _find_require_call(value_node):
         return _find_require_call(obj)
     return None
 
+def _is_require_initializer(value_node, source: bytes) -> bool:
+    """True when a declarator's initializer is a literal ``require(...)`` call.
+
+    ``_find_require_call`` matches the call *shape* only — any
+    ``identifier(...)`` — and leaves the callee-name check to its callers, so
+    it must not be used alone to recognise a CJS import.
+    """
+    call = _find_require_call(value_node)
+    if call is None:
+        return False
+    fn = call.child_by_field_name("function")
+    return fn is not None and _read_text(fn, source) == "require"
+
+
 def _require_imports_js(node, source: bytes, importer_nid: str, stem: str, edges: list, str_path: str) -> bool:
     """Detect CommonJS require imports inside lexical_declaration / variable_declaration.
 
@@ -2130,6 +2144,61 @@ def _js_member_assignment_target(left, source: bytes):
                 return ("prototype", inner_obj_name, member_name)
     return None
 
+_JS_PATTERN_TYPES = frozenset({"object_pattern", "array_pattern"})
+
+
+def _js_pattern_bound_names(name_node, source: bytes) -> list[str]:
+    """Return the identifiers a destructuring declarator actually binds.
+
+    ``const { a, b: renamed, c = 1, ...rest } = x`` binds ``a``, ``renamed``,
+    ``c`` and ``rest`` — not the text of the pattern. Reading the declarator's
+    ``name`` field verbatim instead mints one node labelled with the whole
+    pattern source (``{ a, b: renamed, c = 1, ...rest }``), which names no
+    symbol and can never be the target of a reference. Svelte 5 makes the shape
+    universal — every component destructures ``$props()`` — but the same
+    declarator shape is ordinary JS/TS.
+
+    Walks only the binding side: a ``pair_pattern``'s value (``b: renamed``
+    binds ``renamed``, not the property key ``b``) and an assignment pattern's
+    left operand (``c = $bindable()`` binds ``c``, not ``$bindable``). Nested
+    patterns recurse, so ``{ deep: { inner } }`` binds ``inner``. Returns an
+    empty list for a non-pattern node.
+    """
+    if name_node is None or name_node.type not in _JS_PATTERN_TYPES:
+        return []
+    names: list[str] = []
+
+    def visit(node) -> None:
+        t = node.type
+        if t in ("identifier", "shorthand_property_identifier_pattern"):
+            text = _read_text(node, source)
+            if text and text not in names:
+                names.append(text)
+            return
+        if t == "pair_pattern":
+            # `key: target` — only the value side is bound.
+            value = node.child_by_field_name("value")
+            if value is not None:
+                visit(value)
+            return
+        if t in ("object_assignment_pattern", "assignment_pattern"):
+            # `target = default` — the default is an expression, not a binding.
+            left = node.child_by_field_name("left")
+            if left is None:
+                left = node.named_children[0] if node.named_children else None
+            if left is not None:
+                visit(left)
+            return
+        if t in ("rest_pattern", "object_pattern", "array_pattern"):
+            for child in node.named_children:
+                visit(child)
+            return
+        # Anything else (type annotations, holes in `[a, , c]`) binds nothing.
+
+    visit(name_node)
+    return names
+
+
 def _js_extra_walk(node, source: bytes, file_nid: str, stem: str, str_path: str,
                    nodes: list, edges: list, seen_ids: set, function_bodies: list,
                    parent_class_nid: str | None, add_node_fn, add_edge_fn,
@@ -2303,13 +2372,39 @@ def _js_extra_walk(node, source: bytes, file_nid: str, stem: str, str_path: str,
                     ):
                         # Simple exported identifiers are part of the module API
                         # regardless of initializer shape. Keep other scalar noise suppressed.
+                        const_nid = None
                         if name_node:
-                            const_name = _read_text(name_node, source)
                             line = child.start_point[0] + 1
-                            const_nid = _make_id(stem, const_name)
-                            add_node_fn(const_nid, const_name, line)
-                            add_edge_fn(file_nid, const_nid, "contains", line)
-                            const_found = True
+                            # A destructuring declarator binds several names and
+                            # its `name` field is the pattern source, not a
+                            # symbol — node each identifier it actually binds.
+                            const_names = _js_pattern_bound_names(name_node, source)
+                            if const_names and _is_require_initializer(value, source):
+                                # `const { doWork } = require('./lib')` binds an
+                                # IMPORT, not a local definition. `_require_imports_js`
+                                # already edges those names at the file level; noding
+                                # them here would shadow the real cross-file target,
+                                # so a call to `doWork()` would resolve to this file's
+                                # stub instead of the callee's definition.
+                                const_names = []
+                            elif not const_names:
+                                const_names = [_read_text(name_node, source)]
+                            for const_name in const_names:
+                                # A name that normalizes to nothing would collapse
+                                # the id to the absolute file-stem and leak the
+                                # scan path (#1899); skip it, as the arrow branch does.
+                                if not const_name or not normalize_id(const_name):
+                                    continue
+                                nid = _make_id(stem, const_name)
+                                add_node_fn(nid, const_name, line)
+                                add_edge_fn(file_nid, nid, "contains", line)
+                                const_found = True
+                                if const_nid is None:
+                                    # Closures in the initializer are attributed to
+                                    # the first binding; a destructured initializer
+                                    # has no single owning symbol.
+                                    const_nid = nid
+                        if const_nid is not None:
                             # #2552: `const handler = wrapper(async (req) => …)`
                             # created the const node above but, unlike the arrow
                             # branch, never tracked the callback's body — so
diff --git a/graphify/extractors/resolution.py b/graphify/extractors/resolution.py
index 5369637ae..8dbc361a9 100644
--- a/graphify/extractors/resolution.py
+++ b/graphify/extractors/resolution.py
@@ -605,21 +605,29 @@ def _resolve_lua_import_target(raw_module: str, str_path: str) -> str:
             probe = probe.parent
     return _make_id(raw_module)
 
-_VUE_SCRIPT_RE = re.compile(
+_SFC_SCRIPT_RE = re.compile(
     r"""(<script\b(?:"[^"]*"|'[^']*'|[^>"'])*>)([\s\S]*?)(</script\s*>)""",
     re.IGNORECASE,
 )
 
-_VUE_SCRIPT_LANG_RE = re.compile(
+_SFC_SCRIPT_LANG_RE = re.compile(
     r"""\blang\s*=\s*['"]?([A-Za-z]+)['"]?""", re.IGNORECASE
 )
 
-def _vue_mask_non_script(src: str) -> tuple[str, str | None]:
+# Back-compat aliases: these were named for Vue before Svelte shared the masker.
+_VUE_SCRIPT_RE = _SFC_SCRIPT_RE
+_VUE_SCRIPT_LANG_RE = _SFC_SCRIPT_LANG_RE
+
+def _sfc_mask_non_script(src: str) -> tuple[str, str | None]:
     """Blank everything outside ``<script>`` bodies, keeping ``\\r``/``\\n``.
 
-    Replaces template/style/tags with spaces so a JS/TS grammar sees only the
-    script, while preserved newlines keep line numbers accurate. Returns
-    ``(masked_source, lang)``; ``lang`` is the first block's declared ``lang``.
+    Shared by the ``.vue`` and ``.svelte`` extractors: both wrap JS/TS in markup
+    a JS grammar cannot parse. Replaces template/style/tags with spaces so the
+    grammar sees only the script, while preserved newlines keep line numbers
+    accurate. Every ``<script>`` block is kept, so a Svelte 5 ``<script module>``
+    /instance pair (or a Vue ``setup``/options pair) is parsed as one unit.
+    Returns ``(masked_source, lang)``; ``lang`` is the first block's declared
+    ``lang``.
     """
     def _blank(s: str) -> str:
         return re.sub(r"[^\r\n]", " ", s)
@@ -627,19 +635,25 @@ def _blank(s: str) -> str:
     out: list[str] = []
     pos = 0
     lang: str | None = None
-    for m in _VUE_SCRIPT_RE.finditer(src):
+    for m in _SFC_SCRIPT_RE.finditer(src):
         out.append(_blank(src[pos:m.start()]))  # markup/style before this block
         out.append(_blank(m.group(1)))           # <script …> open tag
         out.append(m.group(2))                   # script body, verbatim
         out.append(_blank(m.group(3)))           # </script> close tag
         pos = m.end()
         if lang is None:
-            lang_m = _VUE_SCRIPT_LANG_RE.search(m.group(1))
+            lang_m = _SFC_SCRIPT_LANG_RE.search(m.group(1))
             if lang_m:
                 lang = lang_m.group(1).lower()
     out.append(_blank(src[pos:]))
     return "".join(out), lang
 
+_vue_mask_non_script = _sfc_mask_non_script
+
+# Single-file-component suffixes whose script blocks need masking before a
+# JS/TS grammar can parse them.
+_SFC_SUFFIXES = (".vue", ".svelte")
+
 def _source_key(source_file: str, root: Path) -> str:
     if not source_file:
         return ""
@@ -1104,18 +1118,19 @@ def resolve_exported_origin(target_path: Path, imported_name: str, seen: set[tup
 def _parse_js_tree(path: Path):
     try:
         from tree_sitter import Language, Parser
-        # .vue embeds the script in non-JS markup; mask it out and parse the
-        # <script> with TS.
-        vue_lang: str | None = None
-        if path.suffix == ".vue":
-            masked, vue_lang = _vue_mask_non_script(
+        # .vue and .svelte embed the script in non-JS markup; mask it out and
+        # parse the <script> with TS. Without the mask the whole file is a
+        # top-level ERROR node, so this pass contributes no calls/type refs.
+        sfc_lang: str | None = None
+        if path.suffix in _SFC_SUFFIXES:
+            masked, sfc_lang = _sfc_mask_non_script(
                 path.read_text(encoding="utf-8", errors="replace")
             )
             source = masked.encode("utf-8")
         else:
             source = path.read_bytes()
         use_ts = path.suffix in (".ts", ".mts", ".cts") or (
-            path.suffix == ".vue" and vue_lang not in ("js", "jsx")
+            path.suffix in _SFC_SUFFIXES and sfc_lang not in ("js", "jsx")
         )
         if path.suffix == ".tsx":
             # .tsx must use the JSX-aware TSX grammar, mirroring the engine's
diff --git a/graphify/extractors/rust.py b/graphify/extractors/rust.py
index b663bd625..4adc93ba7 100644
--- a/graphify/extractors/rust.py
+++ b/graphify/extractors/rust.py
@@ -58,6 +58,187 @@ def _rust_collect_type_refs(node, source: bytes, generic: bool, out: list[tuple[
     "ok", "err", "some", "none", "send", "recv", "lock", "read", "write",
 })
 
+# Rust module roots: a file that IS its module (rather than a child of one).
+_RUST_MODULE_ROOT_FILES = ("mod.rs", "lib.rs", "main.rs")
+
+
+def _rust_path_segments(node, source: bytes) -> list[str]:
+    """Flatten a use-path node into its segments.
+
+    ``crate::models::prelude`` parses as nested ``scoped_identifier``s; the
+    leading ``crate``/``super``/``self`` keywords are their own node types, not
+    ``identifier``, so read text rather than filtering on type.
+    """
+    if node is None:
+        return []
+    if node.type == "scoped_identifier":
+        segments: list[str] = []
+        for child in node.children:
+            if child.type == "::":
+                continue
+            segments.extend(_rust_path_segments(child, source))
+        return segments
+    text = _read_text(node, source).strip()
+    return [text] if text else []
+
+
+def _rust_use_leaves(node, source: bytes, prefix: tuple[str, ...] = ()) -> list[tuple[tuple[str, ...], str | None, bool]]:
+    """Flatten a ``use`` tree into ``(path_segments, alias, is_wildcard)`` leaves.
+
+    One declaration can bind many names —  ``use crate::x::{a, b::C, d as D}``
+    is three leaves, and lists nest arbitrarily. The previous string-splitting
+    approach took everything before the first ``{`` and kept the last ``::``
+    segment, so a braced list collapsed to a single edge naming the shared
+    prefix and every name inside it was lost. ``use_as_clause`` was not parsed
+    at all, leaving the alias glued to the symbol (``Entity as Risk``).
+    """
+    if node is None:
+        return []
+    t = node.type
+    if t == "use_as_clause":
+        path_node = node.child_by_field_name("path")
+        alias_node = node.child_by_field_name("alias")
+        if path_node is None or alias_node is None:
+            named = [c for c in node.named_children]
+            path_node = path_node or (named[0] if named else None)
+            alias_node = alias_node or (named[1] if len(named) > 1 else None)
+        segments = tuple(prefix) + tuple(_rust_path_segments(path_node, source))
+        alias = _read_text(alias_node, source).strip() if alias_node is not None else None
+        return [(segments, alias or None, False)] if segments else []
+    if t == "use_wildcard":
+        segments: tuple[str, ...] = tuple(prefix)
+        for child in node.children:
+            if child.type in ("::", "*"):
+                continue
+            segments = segments + tuple(_rust_path_segments(child, source))
+        return [(segments, None, True)] if segments else []
+    if t == "use_list":
+        leaves: list[tuple[tuple[str, ...], str | None, bool]] = []
+        for child in node.named_children:
+            leaves.extend(_rust_use_leaves(child, source, prefix))
+        return leaves
+    if t == "scoped_use_list":
+        inner_prefix = tuple(prefix)
+        list_node = None
+        for child in node.children:
+            if child.type == "::":
+                continue
+            if child.type == "use_list":
+                list_node = child
+            else:
+                inner_prefix = inner_prefix + tuple(_rust_path_segments(child, source))
+        return _rust_use_leaves(list_node, source, inner_prefix) if list_node else []
+    if t in ("scoped_identifier", "identifier", "crate", "super", "self", "metavariable"):
+        segments = tuple(prefix) + tuple(_rust_path_segments(node, source))
+        return [(segments, None, False)] if segments else []
+    return []
+
+
+def _rust_crate_src_root(path: Path) -> Path | None:
+    """The ``src`` directory of the crate owning ``path``, if there is one."""
+    probe = path.parent
+    while True:
+        if (probe / "Cargo.toml").is_file():
+            src = probe / "src"
+            return src if src.is_dir() else probe
+        if probe.parent == probe:
+            return None
+        probe = probe.parent
+
+
+def _rust_module_file(directory: Path, name: str) -> Path | None:
+    """Resolve one module segment inside ``directory``: ``name.rs`` or ``name/mod.rs``."""
+    candidate = directory / f"{name}.rs"
+    if candidate.is_file():
+        return candidate
+    candidate = directory / name / "mod.rs"
+    if candidate.is_file():
+        return candidate
+    return None
+
+
+def _rust_module_dirs(path: Path) -> tuple[Path, Path]:
+    """Return ``(self_dir, super_dir)`` for the module ``path`` defines.
+
+    ``mod.rs``/``lib.rs``/``main.rs`` ARE their module, so their own directory
+    holds their children and the parent directory is ``super``. Any other file
+    ``foo.rs`` is a module whose children live in a sibling ``foo/`` directory,
+    and whose ``super`` is the directory it sits in.
+    """
+    if path.name in _RUST_MODULE_ROOT_FILES:
+        return path.parent, path.parent.parent
+    sibling = path.parent / path.stem
+    return (sibling if sibling.is_dir() else path.parent), path.parent
+
+
+def _resolve_rust_use_path(
+    segments: tuple[str, ...], path: Path
+) -> "tuple[Path, str | None] | None":
+    """Resolve a ``use`` path to ``(module_file, symbol_name)`` on disk.
+
+    Walks ``crate``/``super``/``self``-anchored paths through the crate's module
+    tree. The trailing segment of a ``use`` is usually a SYMBOL rather than a
+    module (``crate::models::prelude::Risk``), so when the full path does not
+    name a file the last segment is retried as a symbol inside the module the
+    rest resolves to. Returns ``None`` for anything not on disk — an external
+    crate (``std``, ``sea_orm``) or a path this resolver cannot follow.
+    """
+    if not segments:
+        return None
+    self_dir, super_dir = _rust_module_dirs(path)
+    src_root = _rust_crate_src_root(path)
+
+    index = 0
+    anchor: Path | None = None
+    first = segments[0]
+    if first == "crate":
+        anchor, index = src_root, 1
+    elif first == "self":
+        anchor, index = self_dir, 1
+    elif first == "super":
+        anchor, index = super_dir, 1
+        # `super::super::x` walks further up one directory per keyword.
+        while index < len(segments) and segments[index] == "super":
+            anchor = anchor.parent if anchor is not None else None
+            index += 1
+    if anchor is None and first not in ("crate", "self", "super"):
+        # 2018-edition paths may be crate-relative without the `crate` prefix;
+        # try the crate root, then the current module. An external crate simply
+        # resolves to nothing at either.
+        for candidate_anchor in (src_root, self_dir):
+            if candidate_anchor is None:
+                continue
+            resolved = _walk_rust_segments(candidate_anchor, segments)
+            if resolved is not None:
+                return resolved
+        return None
+    if anchor is None:
+        return None
+    return _walk_rust_segments(anchor, segments[index:])
+
+
+def _walk_rust_segments(
+    anchor: Path, segments: tuple[str, ...]
+) -> "tuple[Path, str | None] | None":
+    """Walk module segments from ``anchor``; the tail may name a symbol."""
+    if not segments:
+        return None
+    directory = anchor
+    resolved: Path | None = None
+    for position, segment in enumerate(segments):
+        found = _rust_module_file(directory, segment)
+        if found is None:
+            # Not a module. If everything before it resolved, the remainder is a
+            # symbol path inside that module (`…::prelude::Risk` -> `Risk`), and
+            # only a single trailing segment is a name we can attribute.
+            if resolved is not None and position == len(segments) - 1:
+                return resolved, segment
+            return None
+        resolved = found
+        directory = found.parent if found.name == "mod.rs" else found.parent / found.stem
+    return (resolved, None) if resolved is not None else None
+
+
 def extract_rust(path: Path) -> dict:
     """Extract functions, structs, enums, traits, impl methods, and use declarations from a .rs file."""
     try:
@@ -160,6 +341,55 @@ def emit_param_return_refs(func_node, func_nid: str, line: int) -> None:
                 if tgt != func_nid:
                     add_edge(func_nid, tgt, "references", line, context=ctx)
 
+    def emit_use_leaf(segments, alias, is_wildcard: bool, is_reexport: bool, line: int) -> None:
+        """Emit the edges for one resolved leaf of a ``use`` declaration.
+
+        Two edges where the path resolves on disk: a file-level ``imports_from``
+        so the module graph connects, and a symbol-level edge stamped with
+        ``target_file`` so the shared canonicalization repoints it at the real
+        definition. Unresolved paths (external crates) get a sourceless stub
+        rather than a bare-name target — the old code emitted an id no node ever
+        carried, so the edge dangled and was dropped at build time, which is why
+        a prelude showed inbound edges and no outbound ones.
+        """
+        if not segments:
+            return
+        resolution = _resolve_rust_use_path(tuple(segments), path)
+        if resolution is None:
+            # External crate or unresolvable path. Mint a sourceless stub for the
+            # leaf name so the edge has a real endpoint and the corpus-level
+            # rewire can still collapse it onto a definition if one shows up.
+            name = alias or segments[-1]
+            if not is_wildcard and name:
+                add_edge(file_nid, ensure_named_node(name, line), "imports_from",
+                         line, context="import")
+            return
+        module_file, symbol = resolution
+        module_nid = _make_id(str(module_file))
+        file_edge = {
+            "source": file_nid, "target": module_nid, "relation": "imports_from",
+            "confidence": "EXTRACTED", "source_file": str_path,
+            "source_location": f"L{line}", "weight": 1.0, "context": "import",
+            "target_file": str(module_file),
+        }
+        edges.append(file_edge)
+        if symbol is None or is_wildcard:
+            # `use super::risk;` names the module itself, and a glob re-export
+            # (`pub use super::risk::*;`) publishes an unknown set of names —
+            # neither identifies one symbol to point at.
+            return
+        # Build the id the DEFINING file gives its own symbols (`_make_id(stem,
+        # name)`), so this edge lands on that node rather than a look-alike the
+        # corpus rewire has to guess at.
+        symbol_nid = _make_id(_file_stem(module_file), symbol)
+        edges.append({
+            "source": file_nid, "target": symbol_nid,
+            "relation": "re_exports" if is_reexport else "imports",
+            "confidence": "EXTRACTED", "source_file": str_path,
+            "source_location": f"L{line}", "weight": 1.0,
+            "target_file": str(module_file),
+        })
+
     def walk(node, parent_impl_nid: str | None = None) -> None:
         t = node.type
 
@@ -323,12 +553,16 @@ def _emit_enum_type(type_node, at_line):
         if t == "use_declaration":
             arg = node.child_by_field_name("argument")
             if arg:
-                raw = _read_text(arg, source)
-                clean = raw.split("{")[0].rstrip(":").rstrip("*").rstrip(":")
-                module_name = clean.split("::")[-1].strip()
-                if module_name:
-                    tgt_nid = _make_id(module_name)
-                    add_edge(file_nid, tgt_nid, "imports_from", node.start_point[0] + 1, context="import")
+                line = node.start_point[0] + 1
+                # `pub use` is a RE-EXPORT: the module publishes someone else's
+                # symbol under its own path. The corpus-level barrel collapse
+                # keys on this relation to follow consumers through to the
+                # defining file, so a prelude stops being a dead end.
+                is_reexport = any(
+                    child.type == "visibility_modifier" for child in node.children
+                )
+                for segments, alias, is_wildcard in _rust_use_leaves(arg, source):
+                    emit_use_leaf(segments, alias, is_wildcard, is_reexport, line)
             return
 
         for child in node.children:
@@ -404,7 +638,11 @@ def walk_calls(node, caller_nid: str) -> None:
     clean_edges = []
     for edge in edges:
         src, tgt = edge["source"], edge["target"]
-        if src in valid_ids and (tgt in valid_ids or edge["relation"] in ("imports", "imports_from")):
+        # A cross-file import target is not a node this file owns, so these
+        # relations are allowed to point outside `valid_ids` and are resolved
+        # corpus-wide later. `re_exports` belongs with them — a barrel names a
+        # symbol it does not define — and matches the shared engine filter.
+        if src in valid_ids and (tgt in valid_ids or edge["relation"] in ("imports", "imports_from", "re_exports")):
             clean_edges.append(edge)
 
     return {"nodes": nodes, "edges": clean_edges, "raw_calls": raw_calls}
diff --git a/tests/test_js_exported_scalar_bindings.py b/tests/test_js_exported_scalar_bindings.py
index 7b6ca9681..1444627f0 100644
--- a/tests/test_js_exported_scalar_bindings.py
+++ b/tests/test_js_exported_scalar_bindings.py
@@ -94,3 +94,119 @@ def test_exported_scalar_binding_satisfies_named_import_target(tmp_path):
 
     assert import_targets
     assert import_targets <= node_ids
+
+
+def test_destructuring_declarator_nodes_bound_names_not_pattern_text(tmp_path):
+    """A destructuring declarator binds identifiers; its ``name`` field is the
+    pattern source. Reading that field verbatim minted a node labelled
+    ``{ a, b: renamed, c = 1, ...rest }`` — text that names no symbol and can
+    never be a reference target."""
+    source = tmp_path / "patterns.ts"
+    source.write_text(
+        """
+type Cfg = { a: number; b: number; c: number; deep: { inner: number } };
+const { a, b: renamed, c = 1, ...rest } = obj as Cfg;
+const [first, , third] = arr as number[];
+const { deep: { inner } } = obj as Cfg;
+""",
+        encoding="utf-8",
+    )
+
+    result = extract_js(source)
+    labels = {node["label"] for node in result["nodes"]}
+
+    # Each bound identifier is its own node.
+    assert {"a", "renamed", "c", "rest", "first", "third", "inner"} <= labels
+    # The pattern source is never a label.
+    assert not any(label.startswith(("{", "[")) for label in labels)
+    # `b` is a property key, not a binding — `b: renamed` binds only `renamed`.
+    assert "b" not in labels
+    # `deep` is a key too; the nested pattern binds `inner`.
+    assert "deep" not in labels
+    # Array holes bind nothing and must not mint an empty-labelled node.
+    assert "" not in labels
+
+
+def test_destructured_rune_props_do_not_mint_a_pattern_node(tmp_path):
+    """The shape that made this universal: every Svelte 5 component
+    destructures ``$props()``, so the pattern text was one junk node per
+    component."""
+    source = tmp_path / "props.ts"
+    source.write_text(
+        """
+let { levels, selected = $bindable(), ariaLabel, disabled = false } = $props();
+""",
+        encoding="utf-8",
+    )
+
+    result = extract_js(source)
+    labels = {node["label"] for node in result["nodes"]}
+
+    assert {"levels", "selected", "ariaLabel", "disabled"} <= labels
+    # The default expressions are not bindings.
+    assert "$bindable" not in labels
+    assert not any(label.startswith("{") for label in labels)
+
+
+def test_destructuring_initializer_closures_still_tracked(tmp_path):
+    """Closures in a destructured initializer are attributed to the first
+    binding, so their calls are still walked (#2552 behaviour preserved)."""
+    source = tmp_path / "closures.ts"
+    source.write_text(
+        """
+function target() {}
+const { handler } = wrapper(() => { target(); });
+""",
+        encoding="utf-8",
+    )
+
+    result = extract_js(source)
+    labels = {node["label"] for node in result["nodes"]}
+    assert "handler" in labels
+    by_label = {n["label"]: n["id"] for n in result["nodes"]}
+    calls = {
+        (e["source"], e["target"])
+        for e in result["edges"]
+        if e.get("relation") == "calls"
+    }
+    assert (by_label["handler"], by_label["target()"]) in calls
+
+
+def test_destructured_require_binds_the_import_not_a_local_node(tmp_path):
+    """``const { doWork } = require('./lib')`` binds an import. Noding it as a
+    local symbol would shadow the real cross-file definition, so the call in
+    ``run()`` would resolve to this file's stub instead of ``lib.js``."""
+    caller = tmp_path / "caller.js"
+    callee = tmp_path / "lib.js"
+    caller.write_text(
+        "const { doWork } = require('./lib');\n"
+        "function run() { doWork(); }\n",
+        encoding="utf-8",
+    )
+    callee.write_text(
+        "function doWork() { return 1; }\n"
+        "module.exports = { doWork };\n",
+        encoding="utf-8",
+    )
+
+    result = extract([caller, callee], cache_root=tmp_path)
+    nodes = {n["id"]: n for n in result["nodes"]}
+    calls = [
+        e for e in result["edges"]
+        if e["relation"] == "calls"
+        and nodes[e["source"]]["label"] == "run()"
+        and nodes[e["target"]]["label"] == "doWork()"
+    ]
+    assert len(calls) == 1
+    # The call resolves into the callee's file, not a local stub.
+    assert nodes[calls[0]["target"]]["source_file"].endswith("lib.js")
+
+
+def test_non_require_call_initializer_still_binds(tmp_path):
+    """The require exclusion keys on the callee name, not on the call shape —
+    any other ``identifier(...)`` initializer still binds its names."""
+    source = tmp_path / "runes.ts"
+    source.write_text("let { levels, disabled } = $props();\n", encoding="utf-8")
+
+    labels = {n["label"] for n in extract_js(source)["nodes"]}
+    assert {"levels", "disabled"} <= labels
diff --git a/tests/test_rust_use_reexports.py b/tests/test_rust_use_reexports.py
new file mode 100644
index 000000000..ca27b07ef
--- /dev/null
+++ b/tests/test_rust_use_reexports.py
@@ -0,0 +1,280 @@
+"""Tests for Rust ``use`` declaration resolution.
+
+The extractor used to read a ``use`` declaration by string-splitting its text:
+everything before the first ``{``, then the last ``::`` segment. That collapsed
+a braced list to its shared prefix, glued an alias to its symbol
+(``Entity as Risk``), and pointed every edge at a bare-name id no node ever
+carried — so the edge dangled and was dropped at build time. A crate's prelude
+therefore showed inbound edges and no outbound ones, orphaning every module it
+re-exported.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+from graphify.extract import extract
+from graphify.extractors.rust import (
+    _resolve_rust_use_path,
+    _rust_module_dirs,
+    _rust_use_leaves,
+)
+
+
+def _leaves(body: str):
+    from tree_sitter import Language, Parser
+
+    import tree_sitter_rust as tsrust
+
+    source = body.encode("utf-8")
+    root = Parser(Language(tsrust.language())).parse(source).root_node
+    out = []
+    for decl in root.children:
+        if decl.type != "use_declaration":
+            continue
+        out.extend(_rust_use_leaves(decl.child_by_field_name("argument"), source))
+    return out
+
+
+def _crate(tmp_path: Path) -> Path:
+    """A crate laid out like a SeaORM-generated model tree."""
+    (tmp_path / "src" / "models" / "_entities").mkdir(parents=True)
+    (tmp_path / "Cargo.toml").write_text("[package]\nname = \"demo\"\n", encoding="utf-8")
+    (tmp_path / "src" / "lib.rs").write_text("pub mod models;\n", encoding="utf-8")
+    (tmp_path / "src" / "models" / "mod.rs").write_text(
+        "pub mod _entities;\npub mod service;\n", encoding="utf-8"
+    )
+    (tmp_path / "src" / "models" / "_entities" / "mod.rs").write_text(
+        "pub mod prelude;\npub mod risk;\n", encoding="utf-8"
+    )
+    (tmp_path / "src" / "models" / "_entities" / "risk.rs").write_text(
+        "pub struct Entity;\nimpl Entity { pub fn find_risk() -> u32 { 1 } }\n",
+        encoding="utf-8",
+    )
+    return tmp_path
+
+
+def _graph(root: Path):
+    result = extract(sorted(root.rglob("*.rs")), cache_root=root)
+    nodes = {n["id"]: n for n in result["nodes"]}
+    return result, nodes
+
+
+def _edges(result, nodes, relation: str):
+    return {
+        (
+            nodes.get(e["source"], {}).get("label"),
+            nodes.get(e["target"], {}).get("label"),
+        )
+        for e in result["edges"]
+        if e["relation"] == relation
+    }
+
+
+# ── use-tree parsing ──────────────────────────────────────────────────────────
+
+def test_braced_list_yields_one_leaf_per_name():
+    leaves = _leaves("use super::{a, b::C};\n")
+    assert [(segs, alias) for segs, alias, _ in leaves] == [
+        (("super", "a"), None),
+        (("super", "b", "C"), None),
+    ]
+
+
+def test_nested_braces_and_alias_inside_a_list():
+    leaves = _leaves("use crate::x::y::{z::{Deep}, other as O};\n")
+    assert [(segs, alias) for segs, alias, _ in leaves] == [
+        (("crate", "x", "y", "z", "Deep"), None),
+        (("crate", "x", "y", "other"), "O"),
+    ]
+
+
+def test_as_clause_separates_symbol_from_alias():
+    (segments, alias, wildcard), = _leaves("pub use super::risk::Entity as Risk;\n")
+    assert segments == ("super", "risk", "Entity")
+    assert alias == "Risk"
+    assert wildcard is False
+
+
+def test_wildcard_is_flagged_and_keeps_its_module_path():
+    (segments, alias, wildcard), = _leaves("use crate::models::prelude::*;\n")
+    assert segments == ("crate", "models", "prelude")
+    assert alias is None
+    assert wildcard is True
+
+
+# ── module resolution ─────────────────────────────────────────────────────────
+
+def test_module_dirs_for_mod_rs_and_for_a_plain_file(tmp_path):
+    _crate(tmp_path)
+    entities = tmp_path / "src" / "models" / "_entities"
+    # `mod.rs` IS its module: children live beside it, `super` is one level up.
+    self_dir, super_dir = _rust_module_dirs(entities / "mod.rs")
+    assert self_dir == entities
+    assert super_dir == entities.parent
+    # A plain file's `super` is the directory holding it.
+    self_dir, super_dir = _rust_module_dirs(entities / "risk.rs")
+    assert super_dir == entities
+
+
+def test_super_path_resolves_to_sibling_module_and_symbol(tmp_path):
+    _crate(tmp_path)
+    prelude = tmp_path / "src" / "models" / "_entities" / "prelude.rs"
+    prelude.write_text("pub use super::risk::Entity;\n", encoding="utf-8")
+    resolved = _resolve_rust_use_path(("super", "risk", "Entity"), prelude)
+    assert resolved is not None
+    module_file, symbol = resolved
+    assert module_file == tmp_path / "src" / "models" / "_entities" / "risk.rs"
+    assert symbol == "Entity"
+
+
+def test_crate_path_resolves_from_the_crate_root(tmp_path):
+    _crate(tmp_path)
+    service = tmp_path / "src" / "models" / "service.rs"
+    service.write_text("pub fn run() {}\n", encoding="utf-8")
+    resolved = _resolve_rust_use_path(
+        ("crate", "models", "_entities", "risk", "Entity"), service
+    )
+    assert resolved is not None
+    module_file, symbol = resolved
+    assert module_file == tmp_path / "src" / "models" / "_entities" / "risk.rs"
+    assert symbol == "Entity"
+
+
+def test_module_without_symbol_tail_resolves_to_the_module(tmp_path):
+    _crate(tmp_path)
+    service = tmp_path / "src" / "models" / "service.rs"
+    service.write_text("pub fn run() {}\n", encoding="utf-8")
+    resolved = _resolve_rust_use_path(("crate", "models", "_entities", "risk"), service)
+    assert resolved is not None
+    module_file, symbol = resolved
+    assert module_file.name == "risk.rs"
+    assert symbol is None
+
+
+def test_external_crate_does_not_resolve(tmp_path):
+    _crate(tmp_path)
+    service = tmp_path / "src" / "models" / "service.rs"
+    service.write_text("pub fn run() {}\n", encoding="utf-8")
+    assert _resolve_rust_use_path(("std", "collections", "HashMap"), service) is None
+
+
+# ── emitted edges ─────────────────────────────────────────────────────────────
+
+def test_no_use_edge_points_at_a_phantom_node(tmp_path):
+    """Regression: the old id scheme produced targets no node carried, so the
+    edges were silently dropped and the module looked like a dead end."""
+    _crate(tmp_path)
+    (tmp_path / "src" / "models" / "_entities" / "prelude.rs").write_text(
+        "pub use super::risk::Entity as Risk;\n", encoding="utf-8"
+    )
+    (tmp_path / "src" / "models" / "service.rs").write_text(
+        "use std::collections::HashMap;\n"
+        "use crate::models::_entities::{prelude, risk};\n"
+        "pub fn run() -> u32 { 1 }\n",
+        encoding="utf-8",
+    )
+    result, nodes = _graph(tmp_path)
+    dangling = [
+        e for e in result["edges"]
+        if e["target"] not in nodes and e["relation"] in ("imports_from", "imports")
+    ]
+    assert dangling == []
+
+
+def test_prelude_gains_outbound_edges_to_what_it_reexports(tmp_path):
+    """The symptom that started this: 466 inbound edges, 0 outbound."""
+    _crate(tmp_path)
+    prelude = tmp_path / "src" / "models" / "_entities" / "prelude.rs"
+    prelude.write_text("pub use super::risk::Entity as Risk;\n", encoding="utf-8")
+    result, nodes = _graph(tmp_path)
+    # Look the node up by label: the corpus pass canonicalizes absolute-path
+    # prefixes out of ids, so the extraction-time id is not the final one.
+    prelude_nid = next(
+        nid for nid, n in nodes.items()
+        if n.get("label") == "prelude.rs" and str(n.get("source_file", "")).endswith("prelude.rs")
+    )
+    outbound = [e for e in result["edges"] if e["source"] == prelude_nid]
+    assert outbound, "prelude re-exports a module but has no outbound edge"
+    assert ("prelude.rs", "risk.rs") in _edges(result, nodes, "imports_from")
+
+
+def test_pub_use_is_a_reexport_and_lands_on_the_defining_symbol(tmp_path):
+    _crate(tmp_path)
+    (tmp_path / "src" / "models" / "_entities" / "prelude.rs").write_text(
+        "pub use super::risk::Entity as Risk;\n", encoding="utf-8"
+    )
+    result, nodes = _graph(tmp_path)
+    assert ("prelude.rs", "Entity") in _edges(result, nodes, "re_exports")
+
+
+def test_plain_use_is_an_import_not_a_reexport(tmp_path):
+    _crate(tmp_path)
+    (tmp_path / "src" / "models" / "service.rs").write_text(
+        "use crate::models::_entities::risk::Entity;\n"
+        "pub fn run() -> u32 { Entity::find_risk() }\n",
+        encoding="utf-8",
+    )
+    result, nodes = _graph(tmp_path)
+    assert ("service.rs", "Entity") in _edges(result, nodes, "imports")
+    assert not any(
+        src == "service.rs" for src, _ in _edges(result, nodes, "re_exports")
+    )
+
+
+def test_consumer_resolves_through_the_barrel_to_the_definition(tmp_path):
+    """A consumer importing through a prelude reaches the defining symbol, the
+    same way a JS barrel re-export resolves."""
+    _crate(tmp_path)
+    (tmp_path / "src" / "models" / "_entities" / "prelude.rs").write_text(
+        "pub use super::risk::Entity;\n", encoding="utf-8"
+    )
+    (tmp_path / "src" / "models" / "service.rs").write_text(
+        "use crate::models::_entities::prelude::Entity;\n"
+        "pub fn run() -> u32 { Entity::find_risk() }\n",
+        encoding="utf-8",
+    )
+    result, nodes = _graph(tmp_path)
+    imports = _edges(result, nodes, "imports")
+    assert ("service.rs", "Entity") in imports
+    # And the file-level hop through the barrel is kept, not collapsed away.
+    assert ("service.rs", "prelude.rs") in _edges(result, nodes, "imports_from")
+
+
+def test_braced_import_edges_reach_every_named_module(tmp_path):
+    """The old prefix-splitting emitted ONE edge naming the shared prefix."""
+    _crate(tmp_path)
+    (tmp_path / "src" / "models" / "_entities" / "prelude.rs").write_text(
+        "pub use super::risk::Entity;\n", encoding="utf-8"
+    )
+    (tmp_path / "src" / "models" / "service.rs").write_text(
+        "use crate::models::_entities::{prelude, risk};\n"
+        "pub fn run() -> u32 { 1 }\n",
+        encoding="utf-8",
+    )
+    result, nodes = _graph(tmp_path)
+    imports_from = _edges(result, nodes, "imports_from")
+    assert ("service.rs", "prelude.rs") in imports_from
+    assert ("service.rs", "risk.rs") in imports_from
+
+
+def test_glob_reexport_edges_the_module_but_names_no_symbol(tmp_path):
+    _crate(tmp_path)
+    (tmp_path / "src" / "models" / "_entities" / "prelude.rs").write_text(
+        "pub use super::risk::*;\n", encoding="utf-8"
+    )
+    result, nodes = _graph(tmp_path)
+    assert ("prelude.rs", "risk.rs") in _edges(result, nodes, "imports_from")
+    # A glob publishes an unknown set of names, so no single symbol is claimed.
+    assert not _edges(result, nodes, "re_exports")
+
+
+def test_external_crate_import_still_edges_a_named_stub(tmp_path):
+    """`use std::collections::HashMap` cannot resolve on disk, but must still
+    produce a real endpoint rather than a dropped edge."""
+    _crate(tmp_path)
+    (tmp_path / "src" / "models" / "service.rs").write_text(
+        "use std::collections::HashMap;\npub fn run() -> u32 { 1 }\n",
+        encoding="utf-8",
+    )
+    result, nodes = _graph(tmp_path)
+    assert ("service.rs", "HashMap") in _edges(result, nodes, "imports_from")
diff --git a/tests/test_svelte_extraction.py b/tests/test_svelte_extraction.py
new file mode 100644
index 000000000..e48f5fff9
--- /dev/null
+++ b/tests/test_svelte_extraction.py
@@ -0,0 +1,287 @@
+"""Tests for ``.svelte`` component extraction.
+
+Feeding a whole component to the JS grammar produces a top-level ERROR node,
+dropping imports and symbols (#713). :func:`extract_svelte` masks the non-script
+regions and parses the ``<script>`` with the TypeScript grammar, recovering the
+full graph — the same treatment ``.vue`` already gets.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+from graphify.detect import CODE_EXTENSIONS
+from graphify.extract import (
+    _make_id,
+    _sfc_mask_non_script,
+    _vue_mask_non_script,
+    extract,
+    extract_svelte,
+)
+
+
+def _write(path: Path, body: str) -> Path:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(body, encoding="utf-8")
+    return path
+
+
+def _targets(result: dict, *, relation: str | None = None) -> set[str]:
+    return {
+        str(e.get("target") or "")
+        for e in result.get("edges", [])
+        if relation is None or e.get("relation") == relation
+    }
+
+
+def _labels(result: dict) -> set[str]:
+    return {str(n.get("label") or "") for n in result.get("nodes", [])}
+
+
+def test_svelte_is_in_code_extensions():
+    assert ".svelte" in CODE_EXTENSIONS
+
+
+def test_vue_mask_alias_is_the_shared_masker():
+    # The masker was named for Vue before Svelte shared it; the old name is kept
+    # as an alias so existing callers and tests keep working.
+    assert _vue_mask_non_script is _sfc_mask_non_script
+
+
+def test_mask_preserves_line_numbers_and_blanks_markup():
+    src = (
+        '<script lang="ts">\n'
+        "  const msg = 'hi'\n"
+        "</script>\n"
+        "\n"
+        "<div class=\"wrap\">{msg}</div>\n"
+        "\n"
+        "<style>\n"
+        "  .wrap { color: red }\n"
+        "</style>\n"
+    )
+    masked, lang = _sfc_mask_non_script(src)
+    assert lang == "ts"
+    # Same number of lines (newlines preserved) so line numbers are stable.
+    assert masked.count("\n") == src.count("\n")
+    # Markup and style are gone; the script body survives verbatim.
+    assert "div" not in masked
+    assert "color: red" not in masked
+    assert "const msg = 'hi'" in masked
+    # The script body sits on the same line it does in the source (line 2).
+    assert masked.splitlines()[1].strip() == "const msg = 'hi'"
+
+
+def test_static_imports_resolve(tmp_path):
+    _write(tmp_path / "Icon.svelte", "<span />\n")
+    _write(tmp_path / "format.ts", "export const fmt = (s: string) => s\n")
+    component = _write(
+        tmp_path / "Card.svelte",
+        '<script lang="ts">\n'
+        "  import Icon from './Icon.svelte'\n"
+        "  import { fmt } from './format'\n"
+        "</script>\n"
+        "\n"
+        "<Icon />{fmt('x')}\n",
+    )
+    result = extract_svelte(component)
+    targets = _targets(result, relation="imports_from")
+    assert _make_id(str(tmp_path / "Icon.svelte")) in targets
+    # Extensionless specifier probes real on-disk extensions (./format -> .ts).
+    assert _make_id(str(tmp_path / "format.ts")) in targets
+
+
+def test_symbols_extracted_with_correct_lines(tmp_path):
+    component = _write(
+        tmp_path / "Band.svelte",
+        '<script lang="ts">\n'
+        "  type Level = 'low' | 'high'\n"
+        "\n"
+        "  function toggle(level: Level) {\n"
+        "    return level\n"
+        "  }\n"
+        "</script>\n"
+        "\n"
+        "<button onclick={() => toggle('low')}>go</button>\n",
+    )
+    result = extract_svelte(component)
+    labels = _labels(result)
+    assert "Level" in labels
+    assert "toggle()" in labels
+    # Masking keeps newlines, so reported lines match the real source lines.
+    lines = {
+        str(n.get("label")): n.get("line")
+        for n in result.get("nodes", [])
+        if n.get("line") is not None
+    }
+    if "toggle()" in lines:
+        assert lines["toggle()"] == 4
+
+
+def test_module_and_instance_scripts_both_parsed(tmp_path):
+    """Svelte 5 ``<script module>`` sits alongside the instance script."""
+    _write(tmp_path / "shared.ts", "export const shared = 1\n")
+    _write(tmp_path / "local.ts", "export const local = 2\n")
+    component = _write(
+        tmp_path / "Both.svelte",
+        '<script module lang="ts">\n'
+        "  import { shared } from './shared'\n"
+        "  export function helper() { return shared }\n"
+        "</script>\n"
+        "\n"
+        '<script lang="ts">\n'
+        "  import { local } from './local'\n"
+        "  function render() { return local }\n"
+        "</script>\n"
+        "\n"
+        "<p>hi</p>\n",
+    )
+    result = extract_svelte(component)
+    targets = _targets(result, relation="imports_from")
+    assert _make_id(str(tmp_path / "shared.ts")) in targets
+    assert _make_id(str(tmp_path / "local.ts")) in targets
+    labels = _labels(result)
+    assert "helper()" in labels
+    assert "render()" in labels
+
+
+def test_svelte_4_context_module_script_parsed(tmp_path):
+    """Svelte 4 spells the module block ``context="module"``."""
+    _write(tmp_path / "shared.ts", "export const shared = 1\n")
+    component = _write(
+        tmp_path / "Legacy.svelte",
+        '<script context="module" lang="ts">\n'
+        "  import { shared } from './shared'\n"
+        "</script>\n"
+        "\n"
+        "<p>hi</p>\n",
+    )
+    result = extract_svelte(component)
+    assert _make_id(str(tmp_path / "shared.ts")) in _targets(
+        result, relation="imports_from"
+    )
+
+
+def test_dynamic_import_in_template_recovered(tmp_path):
+    """``{#await import('./X.svelte')}`` lives in markup the mask blanks out,
+    so the regex pass must scan the raw source, not the masked one."""
+    _write(tmp_path / "Heavy.svelte", "<span />\n")
+    component = _write(
+        tmp_path / "Lazy.svelte",
+        "<script>\n"
+        "  let show = false\n"
+        "</script>\n"
+        "\n"
+        "{#await import('./Heavy.svelte') then Mod}\n"
+        "  <Mod.default />\n"
+        "{/await}\n",
+    )
+    result = extract_svelte(component)
+    assert _make_id(str(tmp_path / "Heavy.svelte")) in _targets(
+        result, relation="dynamic_import"
+    )
+
+
+def test_typed_props_reference_imported_type(tmp_path):
+    _write(tmp_path / "types.ts", "export type Risk = { id: string }\n")
+    component = _write(
+        tmp_path / "RiskCard.svelte",
+        '<script lang="ts">\n'
+        "  import type { Risk } from './types'\n"
+        "  export function label(risk: Risk): string { return risk.id }\n"
+        "</script>\n",
+    )
+    result = extract_svelte(component)
+    assert _make_id(str(tmp_path / "types.ts")) in _targets(
+        result, relation="imports_from"
+    )
+
+
+def test_plain_js_script_block(tmp_path):
+    """No ``lang`` attribute: the TS grammar is a superset, so JS still parses."""
+    _write(tmp_path / "util.js", "export const u = 1\n")
+    component = _write(
+        tmp_path / "Plain.svelte",
+        "<script>\n"
+        "  import { u } from './util'\n"
+        "  function go() { return u }\n"
+        "</script>\n"
+        "\n"
+        "<b>{go()}</b>\n",
+    )
+    result = extract_svelte(component)
+    assert _make_id(str(tmp_path / "util.js")) in _targets(
+        result, relation="imports_from"
+    )
+    assert "go()" in _labels(result)
+
+
+def test_markup_only_file_does_not_crash(tmp_path):
+    component = _write(tmp_path / "Static.svelte", "<h1>hello</h1>\n")
+    result = extract_svelte(component)
+    assert isinstance(result.get("nodes"), list)
+    assert isinstance(result.get("edges"), list)
+
+
+def test_runes_do_not_break_the_ts_grammar(tmp_path):
+    """Svelte 5 runes (``$state``/``$derived``/``$props``) are syntactically
+    ordinary calls, so the TS grammar walks past them to the real symbols."""
+    component = _write(
+        tmp_path / "Runes.svelte",
+        '<script lang="ts">\n'
+        "  let count = $state(0)\n"
+        "  let doubled = $derived(count * 2)\n"
+        "  function bump() { count += 1 }\n"
+        "</script>\n"
+        "\n"
+        "<button onclick={bump}>{doubled}</button>\n",
+    )
+    result = extract_svelte(component)
+    assert "bump()" in _labels(result)
+
+
+def test_whole_file_to_js_grammar_would_extract_nothing(tmp_path):
+    """Regression guard for #713: the unmasked path loses everything but the
+    file node, which is what made every .svelte file a stub in the graph."""
+    from graphify.extract import _JS_CONFIG, _extract_generic
+
+    component = _write(
+        tmp_path / "Guard.svelte",
+        '<script lang="ts">\n'
+        "  import { thing } from './thing'\n"
+        "  function visible() { return thing }\n"
+        "</script>\n"
+        "\n"
+        "<div class=\"x\">{visible()}</div>\n"
+        "\n"
+        "<style>.x { color: red }</style>\n",
+    )
+    unmasked = _extract_generic(component, _JS_CONFIG)
+    assert "visible()" not in _labels(unmasked)
+
+    masked = extract_svelte(component)
+    assert "visible()" in _labels(masked)
+
+
+def test_svelte_joins_cross_file_symbol_resolution(tmp_path):
+    """A ``.svelte`` calling an imported function wires to the real symbol across
+    files, so the component is a participant in the call graph rather than a
+    leaf stub. Exercises the masked ``_parse_js_tree`` path.
+    """
+    helper = _write(tmp_path / "helper.ts", "export function helper() {}\n")
+    comp = _write(
+        tmp_path / "Caller.svelte",
+        '''<script lang="ts">
+import { helper } from './helper'
+
+function go(): void {
+  helper()
+}
+</script>
+
+<button onclick={go}>go</button>
+''',
+    )
+    result = extract([comp, helper], cache_root=tmp_path)
+    by_label = {n["label"]: n["id"] for n in result["nodes"]}
+    edges = {(e["source"], e["target"], e["relation"]) for e in result["edges"]}
+    assert (by_label["go()"], by_label["helper()"], "calls") in edges