@@ -193,7 +193,7 @@ def _declare_check(
         self,
         primary_key: list[str],
         fk_attribute_map: dict[str, tuple[str, str]],
-        foreign_keys: list[tuple[str, dict[str, str], bool]],
+        foreign_keys: list[tuple[str, dict[str, str]]],
     ) -> None:
         """
         Validate FK-only primary key constraint for auto-populated tables.
@@ -209,7 +209,7 @@ def _declare_check(
         fk_attribute_map : dict
             Mapping of child_attr -> (parent_table, parent_attr).
         foreign_keys : list
-            One ``(parent_table, attr_map, nullable)`` entry per foreign key.
+            One ``(parent_table, attr_map)`` entry per foreign key.
             Not used here.
 
         Raises
 
@@ -204,7 +204,7 @@ def compile_foreign_key(
     fk_attribute_map: dict[str, tuple[str, str]] | None = None,
     fk_index_candidates: list[list[str]] | None = None,
     column_comments: dict[str, str] | None = None,
-    foreign_keys: list[tuple[str, dict[str, str], bool]] | None = None,
+    foreign_keys: list[tuple[str, dict[str, str]]] | None = None,
 ) -> None:
     """
     Parse a foreign key line and update declaration components.
@@ -241,7 +241,7 @@ def compile_foreign_key(
         comment, with its core-type marker (e.g. ``:int32:``), is added so the
         child keeps the parent's declared type. Updated in place.
     foreign_keys : list, optional
-        One ``(parent_table, attr_map, nullable)`` entry per foreign key, where
+        One ``(parent_table, attr_map)`` entry per foreign key, where
         ``attr_map`` maps each child attribute to the parent attribute it
         references. Unlike ``fk_attribute_map``, it keeps every reference when
         several share an attribute. Updated in place.
@@ -335,7 +335,7 @@ def compile_foreign_key(
     )
     if foreign_keys is not None:
         attr_map = {attr: ref.heading[attr].original_name for attr in ref.primary_key}
-        foreign_keys.append((ref_table_name, attr_map, is_nullable))
+        foreign_keys.append((ref_table_name, attr_map))
 
     # Supporting index on the foreign-key columns.
     #
@@ -397,7 +397,7 @@ def prepare_declare(
     *,
     table_name: str | None = None,
     config=None,
-    foreign_keys: list[tuple[str, dict[str, str], bool]] | None = None,
+    foreign_keys: list[tuple[str, dict[str, str]]] | None = None,
 ) -> tuple[str, list[str], list[str], list[str], list[str], list[str], dict[str, tuple[str, str]], dict[str, str]]:
     """
     Parse a table definition into its components.
@@ -423,7 +423,7 @@ def prepare_declare(
     config : Config, optional
         Read for ``jobs.add_job_metadata`` and ``provenance.capture``.
     foreign_keys : list, optional
-        Receives one ``(parent_table, attr_map, nullable)`` entry per foreign
+        Receives one ``(parent_table, attr_map)`` entry per foreign
         key; see :func:`compile_foreign_key`. Updated in place.
 
     Returns
@@ -559,7 +559,7 @@ def declare(
     adapter,
     *,
     config=None,
-    foreign_keys: list[tuple[str, dict[str, str], bool]] | None = None,
+    foreign_keys: list[tuple[str, dict[str, str]]] | None = None,
 ) -> tuple[str, list[str], list[str], dict[str, tuple[str, str]], list[str], list[str]]:
     r"""
     Parse a definition and generate SQL CREATE TABLE statement.
@@ -577,7 +577,7 @@ def declare(
     config : Config, optional
         Configuration object. If None, falls back to global config.
     foreign_keys : list, optional
-        Receives one ``(parent_table, attr_map, nullable)`` entry per foreign
+        Receives one ``(parent_table, attr_map)`` entry per foreign
         key; see :func:`compile_foreign_key`. Updated in place.
 
     Returns
 
@@ -44,44 +44,118 @@ def extract_master(part_table: str) -> str | None:
 CHAIN_LEGEND = "each table references the one before it or is the master of the part before it"
 
 
-def group_graph(graph: nx.MultiDiGraph) -> nx.MultiDiGraph:
+def owned_parts(graph: nx.MultiDiGraph) -> set[str]:
     """
-    Copy a dependency graph and add an edge from each part table to its master.
+    Return the part tables that are owned by their masters.
 
-    A master's rows are inserted and deleted together with its parts' rows, so a
-    master depends on everything its parts depend on. With the added edges,
-    ``nx.ancestors`` gives a table's ancestors where reaching a master also
-    reaches all of its parts, and ``nx.descendants`` gives the converse, where
-    reaching a part also reaches its master. These are the same dependencies that
-    :func:`topo_sort` orders.
+    A part is owned by its master when a foreign key in the part's primary key
+    references the master, or references another owned part of the same master.
+    The reference may rename the attributes. Only owned parts form a group with
+    their master; every other part (one with no reference to its master, or only a
+    secondary or nullable one, or only one through a part that is not owned) is
+    treated as a separate table.
 
-    The added edges form a cycle with each part that references its master, so
-    the result is for reachability only, not for sorting.
+    Each foreign key is its own edge, renamed ones included, and carries a
+    ``primary`` flag that is True when all its attributes are in the referencing
+    table's primary key. An edge without the flag, as in a graph built by hand,
+    counts as primary.
 
     Parameters
     ----------
     graph : nx.MultiDiGraph
         Dependency graph.
 
+    Returns
+    -------
+    set[str]
+        Full names of the owned parts.
+    """
+    masters = {extract_master(node) for node in graph.nodes} & set(graph.nodes)
+    owned = set()
+    for master in masters:
+        frontier = [master]
+        while frontier:
+            for _, child, props in graph.out_edges(frontier.pop(), data=True):
+                if child not in owned and extract_master(child) == master and props.get("primary", True):
+                    owned.add(child)
+                    frontier.append(child)
+    return owned
+
+
+def _in_group(table: str, master: str, owned: set[str]) -> bool:
+    """Whether ``table`` is ``master`` or one of its owned parts."""
+    return table == master or (table in owned and extract_master(table) == master)
+
+
+def is_owned(graph: nx.MultiDiGraph, part: str, references: list[tuple[str, bool]]) -> bool:
+    """
+    Tell whether a new part table will be owned by its master (see :func:`owned_parts`).
+
+    Parameters
+    ----------
+    graph : nx.MultiDiGraph
+        Dependency graph of the declared tables, which does not include ``part``.
+    part : str
+        Full name of the part table being declared.
+    references : list[tuple[str, bool]]
+        One ``(parent_table, primary)`` pair per foreign key of the part, where
+        ``primary`` is True when all the foreign key's attributes are in the
+        part's primary key.
+
+    Returns
+    -------
+    bool
+        True if a primary-key reference goes to the master or to an owned part of it.
+    """
+    master = extract_master(part)
+    if master not in graph:
+        return False
+    owned = owned_parts(graph)
+    return any(primary and _in_group(parent, master, owned) for parent, primary in references)
+
+
+def group_graph(graph: nx.MultiDiGraph, owned: set[str] | None = None) -> nx.MultiDiGraph:
+    """
+    Copy a dependency graph and add an edge from each owned part to its master.
+
+    A master's rows are inserted and deleted together with its owned parts' rows,
+    so a master depends on everything its owned parts depend on. With the added
+    edges, ``nx.ancestors`` gives a table's ancestors where reaching a master also
+    reaches all of its owned parts, and ``nx.descendants`` gives the converse,
+    where reaching an owned part also reaches its master. These are the
+    dependencies that :func:`topo_sort` orders. Parts that are not owned are
+    treated as separate tables.
+
+    The added edges form a cycle with each owned part, so the result is for
+    reachability only, not for sorting.
+
+    Parameters
+    ----------
+    graph : nx.MultiDiGraph
+        Dependency graph.
+    owned : set[str], optional
+        The owned parts, if already computed with :func:`owned_parts`.
+
     Returns
     -------
     nx.MultiDiGraph
-        A copy of ``graph`` with an edge from each part to its master.
+        A copy of ``graph`` with an edge from each owned part to its master.
     """
+    owned = owned_parts(graph) if owned is None else owned
     graph = nx.MultiDiGraph(graph)
     for part in list(graph.nodes):
-        if (master := extract_master(part)) in graph:
-            graph.add_edge(part, master, key="master")
+        if part in owned:
+            graph.add_edge(part, extract_master(part), key="master")
     return graph
 
 
 def group_ancestors(graph: nx.MultiDiGraph, table: str) -> set[str]:
     """
-    Return a table and its ancestors, where reaching a master reaches all its parts.
+    Return a table and its ancestors, where reaching a master reaches all its owned parts.
 
     The closure starts from ``table`` and adds the parents of every table in it,
-    and all the parts of every master in it, until nothing new is added. A part
-    reaches its own master through its reference to the master (``-> master``).
+    and all the owned parts of every master in it, until nothing new is added. An
+    owned part reaches its master through its own references.
 
     Parameters
     ----------
@@ -100,24 +174,26 @@ def group_ancestors(graph: nx.MultiDiGraph, table: str) -> set[str]:
 
 def group_cycle(graph: nx.MultiDiGraph, part: str, parents: list[str]) -> list[str] | None:
     """
-    Find the cycle that a new part table's references would close.
+    Find the cycle that the references of a new owned part would close.
 
-    A part may reference its master, another part of the same master, or a table
-    outside its master-part group. A reference to a table outside the group closes
-    a cycle when that table already depends on the part's master (see
-    :func:`group_ancestors`): the group would then depend on itself, and
-    :func:`topo_sort` could no longer order its tables.
+    An owned part may reference its master, an owned part of the same master, or
+    a table outside its master-part group, which includes the master's parts that
+    are not owned. A reference to a table outside the group closes a cycle when
+    that table already depends on the part's master (see :func:`group_ancestors`):
+    the group would then depend on itself, and :func:`topo_sort` could no longer
+    order its tables.
 
-    A new table has no children yet, so only a new part's references to tables
-    outside its group can close such a cycle, and checking them when the part is
-    declared keeps every cycle out.
+    A new table has no children yet, so only the references of a new owned part
+    to tables outside its group can close such a cycle. A part that is not owned
+    is a separate table and closes none (see :func:`is_owned`). Checking owned
+    parts when they are declared therefore keeps every cycle out.
 
     Parameters
     ----------
     graph : nx.MultiDiGraph
         Dependency graph of the declared tables, which does not include ``part``.
     part : str
-        Full name of the part table being declared.
+        Full name of the owned part table being declared.
     parents : list[str]
         Full names of the tables the part references.
 
@@ -130,10 +206,11 @@ def group_cycle(graph: nx.MultiDiGraph, part: str, parents: list[str]) -> list[s
     master = extract_master(part)
     if master not in graph:
         return None
-    outside = [p for p in parents if p in graph and master not in (p, extract_master(p))]
+    owned = owned_parts(graph)
+    outside = [p for p in parents if p in graph and not _in_group(p, master, owned)]
     if not outside:
         return None
-    extended = group_graph(graph)
+    extended = group_graph(graph, owned)
     for parent in outside:
         try:
             path = nx.shortest_path(extended, master, parent)
@@ -190,7 +267,11 @@ def _cycle_error(graph: nx.MultiDiGraph) -> DataJointError:
 
 def topo_sort(graph: nx.MultiDiGraph, nodes=None) -> list[str]:
     """
-    Topological sort keeping part tables with their masters.
+    Topological sort keeping owned part tables with their masters.
+
+    Each owned part (see :func:`owned_parts`) is placed right after its master, so
+    the master is ordered after every table its owned parts reference. Parts that
+    are not owned are sorted as separate tables.
 
     Parameters
     ----------
@@ -205,14 +286,15 @@ def topo_sort(graph: nx.MultiDiGraph, nodes=None) -> list[str]:
     Returns
     -------
     list[str]
-        Table names in topological order with parts following masters.
+        Table names in topological order with owned parts following their masters.
 
     Raises
     ------
     DataJointError
         If the dependencies of the tables to sort form a cycle, for example one
-        that runs through a master and its parts.
+        that runs through a master and its owned parts.
     """
+    owned = owned_parts(graph)
     if nodes is None:
         graph = nx.MultiDiGraph(graph)  # make a mutable copy
     else:
@@ -225,15 +307,14 @@ def topo_sort(graph: nx.MultiDiGraph, nodes=None) -> list[str]:
         subgraph.add_edges_from((u, v) for u, v in graph.edges(keep) if v in keep)
         graph = subgraph
 
-    # Add parts' dependencies to their masters' dependencies
+    # Add owned parts' dependencies to their masters' dependencies
     # to ensure correct topological ordering of the masters.
+    # Parts that are not owned are sorted as separate tables.
     for part in graph:
-        # find the part's master
-        if (master := extract_master(part)) in graph:
-            for edge in graph.in_edges(part):
-                parent = edge[0]
-                if master not in (parent, extract_master(parent)):
-                    # if parent is neither master nor part of master
+        if part in owned and (master := extract_master(part)) in graph:
+            for parent, _ in graph.in_edges(part):
+                if not _in_group(parent, master, owned):
+                    # if parent is neither master nor owned part of master
                     graph.add_edge(parent, master, part=part)
     try:
         sorted_nodes = list(nx.topological_sort(graph))
@@ -245,7 +326,7 @@ def topo_sort(graph: nx.MultiDiGraph, nodes=None) -> list[str]:
     placed = set()
     while pos > 1:
         part = sorted_nodes[pos]
-        if (master := extract_master(part)) not in graph or part in placed:
+        if part not in owned or (master := extract_master(part)) not in graph or part in placed:
             pos -= 1
         else:
             placed.add(part)
 
@@ -24,7 +24,7 @@
 import networkx as nx
 
 from .condition import AndList
-from .dependencies import extract_master, group_graph, topo_sort
+from .dependencies import extract_master, topo_sort
 from .errors import DataJointError
 from .table import Table, lookup_class_name
 from .user_tables import Computed, Imported, Lookup, Manual, Part, _get_tier
@@ -781,12 +781,18 @@ def _propagate_restrictions(self, start_node, mode, part_integrity="enforce"):
 
         # Only propagate through descendants of start_node
         allowed_nodes = {start_node} | set(nx.descendants(self, start_node))
-        # Sort only the tables propagation can reach: part_integrity="cascade" also
-        # reaches the master of every part it reaches, and the master's descendants.
+        # Sort only the tables propagation can reach. With part_integrity="cascade",
+        # propagation also reaches the master of every part it reaches (matched by
+        # name, as in _propagate_part_to_master), and the master's descendants.
+        reachable = set(allowed_nodes)
         if part_integrity == "cascade" and mode == "cascade":
-            reachable = {start_node} | nx.descendants(group_graph(self), start_node)
-        else:
-            reachable = allowed_nodes
+            pending = list(reachable)
+            while pending:
+                master = extract_master(pending.pop())
+                if master in self.nodes and master not in reachable:
+                    added = {master} | nx.descendants(self, master)
+                    pending.extend(added - reachable)
+                    reachable |= added
         sorted_nodes = topo_sort(self, reachable)
         propagated_edges = set()
         # Dedup upward part→master walks by (part, master) PAIR, not by master
 
@@ -219,7 +219,7 @@ def _declare_check(self, primary_key, fk_attribute_map, foreign_keys):
         fk_attribute_map : dict
             Dict mapping child_attr -> (parent_table, parent_attr).
         foreign_keys : list
-            One ``(parent_table, attr_map, nullable)`` entry per foreign key,
+            One ``(parent_table, attr_map)`` entry per foreign key,
             where ``attr_map`` maps child_attr -> parent_attr.
         """
         pass  # Default: no validation