@@ -1251,13 +1251,9 @@ enum ComponentFileFilter {
     StubOnly,
 }
 
-/// Where a candidate sits in the typing specification's module-resolution order.
-///
-/// Variants are declared from highest to lowest precedence so that derived ordering can be used
-/// when traversing candidates. This is a precedence tier rather than a total ordering: the stable
-/// sorts used by the resolver preserve search-path order between candidates in the same tier.
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, get_size2::GetSize)]
-enum CandidatePrecedence {
+/// Where a module resolution candidate originated.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, get_size2::GetSize)]
+enum CandidateOrigin {
     /// A PEP 561 stub-only package named `<package>-stubs`.
     ///
     /// Stub packages take precedence over candidates for `<package>` regardless of where those
@@ -1268,7 +1264,19 @@ enum CandidatePrecedence {
     ///
     /// This includes `.pyi` and `.py` packages and modules from extra paths, first-party code,
     /// editable installs, site-packages, and the standard library.
-    SearchPathOrder,
+    SearchPath,
+}
+
+impl CandidateOrigin {
+    /// Returns the candidate's precedence tier in the typing specification's module-resolution order.
+    ///
+    /// The resolver's stable sort preserves search-path order between candidates in the same tier.
+    fn sort_key(self) -> impl Ord {
+        match self {
+            Self::StubPackage => 0,
+            Self::SearchPath => 1,
+        }
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -1280,28 +1288,28 @@ struct ModuleResolutionCandidate<'db> {
     directory: ModuleDirectory<'db>,
     module: ResolvedModule,
     py_typed: PyTyped,
-    precedence: CandidatePrecedence,
+    origin: CandidateOrigin,
 }
 
 impl<'db> ModuleResolutionCandidate<'db> {
     fn root(context: &ResolverContext<'db>, search_path: &SearchPath) -> Self {
-        Self::with_precedence(context, search_path, CandidatePrecedence::SearchPathOrder)
+        Self::with_origin(context, search_path, CandidateOrigin::SearchPath)
     }
 
     fn stub(context: &ResolverContext<'db>, search_path: &SearchPath) -> Self {
-        Self::with_precedence(context, search_path, CandidatePrecedence::StubPackage)
+        Self::with_origin(context, search_path, CandidateOrigin::StubPackage)
     }
 
-    fn with_precedence(
+    fn with_origin(
         context: &ResolverContext<'db>,
         search_path: &SearchPath,
-        precedence: CandidatePrecedence,
+        origin: CandidateOrigin,
     ) -> Self {
         Self {
             directory: ModuleDirectory::new(context, search_path.to_module_path(), Some(true)),
             module: ResolvedModule::NamespacePackage,
             py_typed: PyTyped::Untyped,
-            precedence,
+            origin,
         }
     }
 
@@ -1414,9 +1422,11 @@ fn resolve_stub_package_in_search_path<'db>(
 /// Orders candidates for the same module name by precedence and removes shadowed namespace packages.
 ///
 /// Regular packages and file modules shadow namespace packages, including legacy namespaces.
-/// When `for_module_name_prefix` is true, partial namespaces with higher precedence than every
-/// competing regular package or file module remain available to supply descendants. Candidates
-/// within the same precedence tier retain their search-path order.
+/// While resolving descendants, stub packages retain ordinary namespace candidates as fallbacks,
+/// and partial namespace stubs remain available alongside ordinary concrete candidates. Within
+/// each precedence tier, concrete candidates still shadow namespace packages. At the final
+/// component, any concrete candidate shadows namespaces. Candidates within the same precedence
+/// tier retain their search-path order.
 fn normalize_candidates<'db>(
     context: &ResolverContext,
     mut candidates: ResolvedNames<'db>,
@@ -1427,13 +1437,19 @@ fn normalize_candidates<'db>(
         return candidates;
     }
 
-    let best_concrete_precedence = candidates
+    let mut has_concrete_stub_package = false;
+    let mut has_concrete_search_path_candidate = false;
+    for candidate in candidates
         .iter()
         .filter(|candidate| !candidate.is_any_namespace_package(context))
-        .map(|candidate| candidate.precedence)
-        .min();
+    {
+        match candidate.origin {
+            CandidateOrigin::StubPackage => has_concrete_stub_package = true,
+            CandidateOrigin::SearchPath => has_concrete_search_path_candidate = true,
+        }
+    }
 
-    candidates.sort_by_key(|candidate| candidate.precedence);
+    candidates.sort_by_key(|candidate| candidate.origin.sort_key());
 
     // Note that we intentionally do *not* filter out ordinary search-path candidates when a stub
     // package is found. Even when a non-namespace, non-partial stub package exists, we keep the
@@ -1445,15 +1461,20 @@ fn normalize_candidates<'db>(
             return true;
         }
 
-        // A higher-precedence partial namespace remains available while resolving its descendants.
-        // At the final component, a concrete package or module shadows it.
-        let preserved_for_descendants = best_concrete_precedence.is_none_or(|precedence| {
-            for_module_name_prefix
-                && candidate.py_typed == PyTyped::Partial
-                && candidate.precedence < precedence
-        });
+        let shadowed = if for_module_name_prefix {
+            match candidate.origin {
+                CandidateOrigin::StubPackage => {
+                    has_concrete_stub_package
+                        || (has_concrete_search_path_candidate
+                            && candidate.py_typed != PyTyped::Partial)
+                }
+                CandidateOrigin::SearchPath => has_concrete_search_path_candidate,
+            }
+        } else {
+            has_concrete_stub_package || has_concrete_search_path_candidate
+        };
 
-        if preserved_for_descendants {
+        if !shadowed {
             return true;
         }
 
 
@@ -30,7 +30,7 @@ use crate::module_name::ModuleName;
 use crate::path::{ModuleDirectory, ModuleDirectoryEntry, ModulePath, SearchPath};
 
 use super::{
-    CandidatePrecedence, ComponentFileFilter, ModuleNameIngredient, ModuleResolutionCandidate,
+    CandidateOrigin, ComponentFileFilter, ModuleNameIngredient, ModuleResolutionCandidate,
     ModuleResolveMode, PyTyped, ResolvedModule, ResolvedNames, ResolverContext, StubPackageIndex,
     StubPackagePaths, normalize_candidates, resolve_component, resolve_stub_package_in_search_path,
     search_paths, stub_package_index,
@@ -509,7 +509,7 @@ struct CachedCandidate {
     path: ModulePath,
     module: ResolvedModule,
     py_typed: PyTyped,
-    precedence: CandidatePrecedence,
+    origin: CandidateOrigin,
 
     /// Stores the result of the symlink policy for enumeration. This prevents
     /// unnecessary cache invalidation of a `ModuleListing`, since the symlink
@@ -529,7 +529,7 @@ impl CachedCandidate {
             enumeration_allowed: candidate.directory.enumeration_allowed(db),
             module: candidate.module,
             py_typed: candidate.py_typed,
-            precedence: candidate.precedence,
+            origin: candidate.origin,
         }
     }
 
@@ -542,7 +542,7 @@ impl CachedCandidate {
             ),
             module: self.module,
             py_typed: self.py_typed,
-            precedence: self.precedence,
+            origin: self.origin,
         }
     }
 }
 
@@ -469,3 +469,189 @@ reveal_type(Both().both)  # revealed: str
 reveal_type(Impl().impl)  # revealed: str
 reveal_type(Fake().fake)  # revealed: Unknown
 ```
+
+## Partial stub for a legacy namespace package
+
+A partial stub package takes precedence over a legacy namespace package for modules it defines.
+Subpackages missing from the stubs still resolve from the runtime package.
+
+Regression test for <https://github.com/astral-sh/ty/issues/4767>.
+
+```toml
+[environment]
+extra-paths = ["/packages"]
+```
+
+`/packages/foo-stubs/py.typed`:
+
+```text
+partial
+```
+
+`/packages/foo-stubs/__init__.pyi`:
+
+```pyi
+x: int
+```
+
+`/packages/foo/__init__.py`:
+
+```py
+__path__ = __import__("pkgutil").extend_path(__path__, __name__)
+x = "runtime"
+```
+
+`/packages/foo/sub/__init__.py`:
+
+```py
+y = 1
+```
+
+`main.py`:
+
+```py
+from foo import x
+from foo.sub import y
+
+reveal_type(x)  # revealed: int
+reveal_type(y)  # revealed: Literal[1]
+```
+
+## Partial stub for an implicit namespace package
+
+The runtime package can also be an implicit namespace package, without an `__init__.py`.
+
+```toml
+[environment]
+extra-paths = ["/packages"]
+```
+
+`/packages/foo-stubs/py.typed`:
+
+```text
+partial
+```
+
+`/packages/foo-stubs/__init__.pyi`:
+
+```pyi
+```
+
+`/packages/foo/impl.py`:
+
+```py
+x = 1
+```
+
+`main.py`:
+
+```py
+from foo.impl import x
+
+reveal_type(x)  # revealed: Literal[1]
+```
+
+## Complete stub with a partial subpackage in a namespace package
+
+Although the root stub package is complete, its `bar` subpackage declares itself partial. Missing
+modules within `bar` still resolve from the runtime package, even when its root is a namespace
+package. Runtime-only siblings of `bar` remain inaccessible through the complete root stub.
+
+```toml
+[environment]
+extra-paths = ["/packages"]
+```
+
+`/packages/foo-stubs/__init__.pyi`:
+
+```pyi
+```
+
+`/packages/foo-stubs/bar/py.typed`:
+
+```text
+partial
+```
+
+`/packages/foo-stubs/bar/__init__.pyi`:
+
+```pyi
+```
+
+`/packages/foo/__init__.py`:
+
+```py
+__path__ = __import__("pkgutil").extend_path(__path__, __name__)
+```
+
+`/packages/foo/bar/__init__.py`:
+
+```py
+```
+
+`/packages/foo/bar/impl.py`:
+
+```py
+x = 1
+```
+
+`/packages/foo/hidden.py`:
+
+```py
+```
+
+`main.py`:
+
+```py
+import foo.hidden  # error: [unresolved-import]
+from foo.bar.impl import x
+
+reveal_type(x)  # revealed: Literal[1]
+```
+
+## Partial stubs preserve runtime package precedence
+
+A regular runtime package shadows a runtime namespace package, even when the namespace comes first
+on the search path. Partial stubs fall back to the regular package without exposing modules from the
+shadowed namespace.
+
+```toml
+[environment]
+extra-paths = ["/first", "/second"]
+```
+
+`/first/foo-stubs/py.typed`:
+
+```text
+partial
+```
+
+`/first/foo-stubs/__init__.pyi`:
+
+```pyi
+```
+
+`/first/foo/hidden.py`:
+
+```py
+```
+
+`/second/foo/__init__.py`:
+
+```py
+```
+
+`/second/foo/impl.py`:
+
+```py
+x = 1
+```
+
+`main.py`:
+
+```py
+import foo.hidden  # error: [unresolved-import]
+from foo.impl import x
+
+reveal_type(x)  # revealed: Literal[1]
+```