@@ -17,7 +17,10 @@ uses [Semantic Versioning](https://semver.org/).
   field-type, instantiation and call edges. `package:`/relative imports,
   exports and `part` files decide which definition a name resolves to, and
   library-private names never resolve outside their library; names not
-  visible through imports are dropped rather than guessed. Flutter-aware:
+  visible through imports are dropped rather than guessed. Without a
+  `pubspec.yaml` in the analyzed tree, `package:` imports cannot be resolved,
+  so Dart calls fall back to name matching across Dart files (with a
+  warning). Flutter-aware:
   widgets and State classes are typed, instantiations in `build()` become
   widget-to-widget edges, `ref.watch`/`ref.read` link widgets to Riverpod
   providers (including `@riverpod` codegen), and GoRouter routes link to their
 
@@ -65,6 +65,7 @@ def __init__(self):
         self._dart_directives: dict[str, list] = {}
         self._dart_visible: dict[str, set[str]] = {}
         self._dart_library_members: dict[str, set[str]] = {}
+        self._dart_unscoped = False
         self.call_relationships: list[CallRelationship] = []
         self._python_project_modules: set = set()
         self._python_external_import_roots: set = set()
@@ -91,6 +92,7 @@ def analyze_code_files(self, code_files: list[dict], base_dir: str) -> dict:
         self._dart_directives = {}
         self._dart_visible = {}
         self._dart_library_members = {}
+        self._dart_unscoped = False
 
         files_analyzed = 0
         files_failed = 0
@@ -607,14 +609,21 @@ def _build_dart_scopes(self, base_dir: str) -> None:
         files = set(self._dart_directives)
         resolver = DartPackageResolver.from_files(base_dir, files)
         scopes = build_scopes(self._dart_directives, resolver, files)
-        self._dart_visible = scopes.visible
         self._dart_library_members = scopes.library_members
-
-    def _has_dart_scope(self, caller: Node) -> bool:
-        return Path(caller.relative_path).as_posix() in self._dart_visible
+        if resolver.packages:
+            self._dart_visible = scopes.visible
+            return
+        # Without a pubspec.yaml (e.g. only `lib/` was analyzed) `package:`
+        # imports resolve to nothing, and scoping would drop nearly every
+        # cross-file edge. Match names across all Dart files instead.
+        self._dart_unscoped = True
+        logger.warning(
+            "No pubspec.yaml found for the analyzed Dart files; `package:` imports "
+            "cannot be resolved, so Dart calls are matched by name across Dart files."
+        )
 
     def _dart_scope_candidates(
-        self, func_ids: list[str], scope: set[str], caller_file: str | None = None
+        self, func_ids: list[str], scope: set[str] | None, caller_file: str | None = None
     ) -> list[str]:
         from codewiki.src.be.dependency_analyzer.analyzers.dart_imports import (
             is_private_dart_name,
@@ -627,7 +636,7 @@ def _dart_scope_candidates(
             if func_id in candidates or func is None:
                 continue
             func_file = Path(func.relative_path).as_posix()
-            if func_file not in scope:
+            if scope is not None and func_file not in scope:
                 continue
             # A `_`-prefixed segment in the target (`_Ticker.tick`) is private
             # to its library, whatever the callee's own spelling.
@@ -648,12 +657,15 @@ def _resolve_dart_callee(
         if not lang_indexes or "::" in callee:
             return None
         caller_file = Path(caller.relative_path).as_posix()
+        scope: set[str] | None
         if is_private_dart_name(callee):
             scope = self._dart_library_members.get(caller_file, {caller_file})
+        elif self._dart_unscoped:
+            scope = None  # any Dart file
         else:
             scope = self._dart_visible.get(caller_file)
-        if not scope:
-            return None
+            if not scope:
+                return None
         keys = [callee]
         if "." in callee:
             keys.append(callee.split(".")[0])
@@ -730,11 +742,11 @@ def _resolve_call_relationships(self):
         ]
 
     def _is_unresolvable_dart(self, relationship: CallRelationship) -> bool:
-        """A scoped Dart caller's callee that import-aware resolution rejected
-        is external or invisible; drop it so ast_parser's name-only fallback
-        cannot bind it to an unrelated component."""
+        """A Dart caller's callee that Dart resolution rejected is external or
+        invisible; drop it so ast_parser's name-only fallback cannot bind it
+        to an unrelated component."""
         caller = self.functions.get(relationship.caller)
-        return caller is not None and caller.language == "dart" and self._has_dart_scope(caller)
+        return caller is not None and caller.language == "dart"
 
     def _dotted_project_packages(self) -> dict[str, set]:
         """Project packages/namespaces, partitioned by language. Java and C#
@@ -871,17 +883,9 @@ def _resolve_callee(
 
         lang_indexes = indexes["by_lang"].get(caller_language) if caller_language else None
         if caller_language == "dart" and caller is not None:
-            from codewiki.src.be.dependency_analyzer.analyzers.dart_imports import (
-                is_private_dart_name,
-            )
-
-            match = self._resolve_dart_callee(relationship.callee, caller, lang_indexes)
-            if match:
-                return match
-            # Dart resolution is import-driven: a caller with a scope never
-            # falls back to name guessing in other languages or libraries.
-            if is_private_dart_name(relationship.callee) or self._has_dart_scope(caller):
-                return None
+            # Dart resolution is authoritative: it never falls back to name
+            # guessing in other languages or invisible libraries.
+            return self._resolve_dart_callee(relationship.callee, caller, lang_indexes)
         if lang_indexes:
             match = self._resolve_callee_in(
                 relationship, lang_indexes["exact"], lang_indexes["simple"]
 
@@ -505,6 +505,28 @@ def test_top_level_function_wins_over_same_named_method(tmp_path: Path) -> None:
     assert components["lib/main.dart::go"].depends_on == {"lib/util.dart::helper"}
 
 
+def test_missing_pubspec_falls_back_to_dart_name_matching(tmp_path: Path, caplog) -> None:
+    files = {
+        "lib/util.dart": "class Engine {\n  void start() {}\n}\n",
+        "lib/main.dart": (
+            "import 'package:app/util.dart';\n"
+            "class Car {\n  final Engine e = Engine();\n  void go() { e.start(); Size(1, 2); }\n}\n"
+        ),
+        "windows/runner/win32_window.h": "struct Size { int w; int h; };\n",
+    }
+    for relpath, source in files.items():
+        path = tmp_path / relpath
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(source, encoding="utf-8")
+    with caplog.at_level("WARNING"):
+        components = DependencyParser(str(tmp_path)).parse_repository()
+    assert "No pubspec.yaml" in caplog.text
+    assert "lib/util.dart::Engine" in components["lib/main.dart::Car"].depends_on
+    deps = components["lib/main.dart::Car.go"].depends_on
+    assert "lib/util.dart::Engine.start" in deps
+    assert not {d for d in deps if d.startswith("windows/")}
+
+
 def test_barrel_reexport_selects_exported_definition(tmp_path: Path) -> None:
     _write_repo(
         tmp_path,