fix(#1429): address MilagrosMarin review on #1468

- Drop unused `propagated_edges` parameter from `_propagate_part_to_master`
  and its call sites. The parameter was vestigial after the design
  switched from edge-blocking to materialization at the master.

- Document two limitations in the docstring:
  - Single FK path: nx.shortest_path returns one path; non-shortest
    paths are not applied.
  - Memory cost of materialization: to_arrays() pulls matching master
    PKs into Python memory.

- Add test_cascade_three_level_part_chain covering PartC → PartB →
  PartA → Master. Confirms intermediate Parts are restricted at every
  hop, not just the first.

All 36 mysql tests in cascade_delete + cascading_delete + dependencies
+ semantic_matching pass.

Author: dimitri-yatsenko

src/datajoint/diagram.py

@@ -471,7 +471,7 @@ def _propagate_restrictions(self, start_node, mode, part_integrity="enforce"):
             seed_master = extract_master(start_node)
             if seed_master and seed_master in self.nodes() and seed_master not in visited_masters:
                 visited_masters.add(seed_master)
-                if self._propagate_part_to_master(start_node, seed_master, mode, restrictions, propagated_edges):
+                if self._propagate_part_to_master(start_node, seed_master, mode, restrictions):
                     allowed_nodes.add(seed_master)
                     allowed_nodes.update(nx.descendants(self, seed_master))
 
@@ -542,9 +542,7 @@ def _propagate_restrictions(self, start_node, mode, part_integrity="enforce"):
                             master_name = extract_master(target)
                             if master_name and master_name in self.nodes() and master_name not in visited_masters:
                                 visited_masters.add(master_name)
-                                propagated = self._propagate_part_to_master(
-                                    target, master_name, mode, restrictions, propagated_edges
-                                )
+                                propagated = self._propagate_part_to_master(target, master_name, mode, restrictions)
                                 if propagated:
                                     allowed_nodes.add(master_name)
                                     allowed_nodes.update(nx.descendants(self, master_name))
@@ -660,7 +658,7 @@ def _apply_propagation_rule_upward(self, child_ft, child_attrs, parent_node, att
 
         self._restriction_attrs.setdefault(parent_node, set()).update(parent_attrs)
 
-    def _propagate_part_to_master(self, part_node, master_name, mode, restrictions, propagated_edges):
+    def _propagate_part_to_master(self, part_node, master_name, mode, restrictions):
         """
         Walk the FK graph from `part_node` up to `master_name`, applying
         `_apply_propagation_rule_upward` at each real edge along the path.
@@ -681,6 +679,23 @@ def _propagate_part_to_master(self, part_node, master_name, mode, restrictions,
         Materializing converts the restriction into a static value set, so
         the forward cascade generates ``WHERE ... IN (literal-list)`` rather
         than ``WHERE ... IN (SELECT ... FROM <part>)``.
+
+        Limitations
+        -----------
+        - **Single FK path**: ``nx.shortest_path`` returns *one* path from
+          ``master_name`` to ``part_node``. If a Part is reachable from its
+          Master through multiple distinct FK chains (e.g. references two
+          different intermediate Parts), restrictions through the
+          non-shortest paths are not applied. This pattern is unusual; if a
+          schema hits it, the user is responsible for restricting the
+          additional paths explicitly via ``part_integrity="ignore"`` plus
+          manual ``delete()`` calls.
+        - **Memory cost of materialization**: ``master_ft.proj().to_arrays()``
+          pulls the matching master primary keys into Python memory. Cost is
+          bounded by the count of *distinct* master rows referenced by the
+          matching parts — typically small for surgical cascades, but can
+          grow with bulk cascades on tables with many master rows. Cascade
+          *preview* (``Diagram.cascade(...).counts()``) pays the same cost.
         """
         try:
             path = nx.shortest_path(self, master_name, part_node)

tests/integration/test_cascade_delete.py

@@ -392,6 +392,57 @@ class PartB(dj.Part):
     assert counts.get(Master.PartB.full_table_name, 0) == 1
 
 
+def test_cascade_three_level_part_chain(schema_by_backend):
+    """
+    Three-hop chain (#1429 follow-up review): PartC → PartB → PartA → Master.
+    Verify intermediate Parts (PartA, PartB) are restricted at every hop, not
+    just the first, and the master cascades back down to all siblings.
+    """
+
+    @schema_by_backend
+    class Master(dj.Manual):
+        definition = """
+        master_id : int32
+        """
+
+        class PartA(dj.Part):
+            definition = """
+            -> master
+            part_a_id : int32
+            """
+
+        class PartB(dj.Part):
+            definition = """
+            -> Master.PartA
+            part_b_id : int32
+            """
+
+        class PartC(dj.Part):
+            definition = """
+            -> Master.PartB
+            part_c_id : int32
+            """
+
+    Master.insert([(1,), (2,)])
+    Master.PartA.insert([(1, 10), (1, 11), (2, 20)])
+    Master.PartB.insert([(1, 10, 100), (1, 11, 110), (2, 20, 200)])
+    Master.PartC.insert([(1, 10, 100, 1000), (1, 11, 110, 1100), (2, 20, 200, 2000)])
+
+    counts = dj.Diagram.cascade(
+        Master.PartC & {"master_id": 1, "part_a_id": 10, "part_b_id": 100, "part_c_id": 1000},
+        part_integrity="cascade",
+    ).counts()
+
+    # Master pulled in via the 3-hop upward walk
+    assert counts.get(Master.full_table_name, 0) == 1, (
+        "Master restriction lost across 3-hop chain — the per-edge upward walk " "did not reach Master through PartA + PartB."
+    )
+    # Master forward-cascades back down to all rows under master_id=1
+    assert counts.get(Master.PartA.full_table_name, 0) == 2  # both PartA rows under master 1
+    assert counts.get(Master.PartB.full_table_name, 0) == 2  # both PartB rows under master 1
+    assert counts.get(Master.PartC.full_table_name, 0) == 2  # both PartC rows under master 1
+
+
 def test_cascade_part_of_part_actual_delete(schema_by_backend):
     """
     End-to-end: actually run delete() with part_integrity="cascade" through