1. Improved comment in delta.py:556-558 — now references the path inversion mechanism in model.py

   DiffLevel.path so future developers understand why the keys are swapped.
  2. Added test_moved_and_type_changed — covers the type_changes code path where items both move
  and change type (str -> int), which the original tests didn't exercise.

Author: seperman

deepdiff/delta.py

@@ -553,8 +553,9 @@ def _get_elements_and_details(self, path):
     def _do_values_or_type_changed(self, changes, is_type_change=False, verify_changes=True):
         compare_func_was_used = self.diff.get('_iterable_compare_func_was_used', False)
         for path, value in changes.items():
-            # When iterable_compare_func is used, keys in values_changed/type_changes are
-            # t2 paths and new_path holds the original t1 path. Always apply at t1 so we
+            # When iterable_compare_func is used, DiffLevel.path() inverts use_t2 for
+            # moved items (see model.py DiffLevel.path). This means dict keys here are
+            # actually t2 paths and new_path holds the t1 path. Apply at t1 so we
             # don't access indices that don't exist yet or modify the wrong item.
             apply_path = value['new_path'] if (compare_func_was_used and value.get('new_path')) else path
             elem_and_details = self._get_elements_and_details(apply_path)

tests/test_delta.py

@@ -2993,4 +2993,20 @@ def test_appended_only_no_movement_sanity_check(self):
         result = t1 + Delta(ddiff, force=True, raise_errors=True,
                             log_errors=False)
         assert [item for item in result if "id" not in item] == []
-        assert result == t2
+        assert result == t2
+
+    def test_moved_and_type_changed(self):
+        """Items that both move and change type should apply correctly."""
+        t1 = [{"id": "a", "val": "1"}, {"id": "b", "val": "2"}]
+        t2 = [
+            {"id": "new1", "val": 99},
+            {"id": "a", "val": 1},      # moved [0]->[1], val str->int
+            {"id": "b", "val": 2},      # moved [1]->[2], val str->int
+        ]
+        ddiff = DeepDiff(t1, t2, iterable_compare_func=self.compare_func,
+                        threshold_to_diff_deeper=0)
+        result = t1 + Delta(ddiff, force=True, raise_errors=True,
+                            log_errors=False)
+        assert [item for item in result if "id" not in item] == [], \
+            "Phantom entries (dicts missing 'id') found in result"
+        assert result == t2