This change fixes a coding error that is triggered when performing a sublayer operation on a layer whose file format is a package. The current implementation which generates fine grained change lists makes use of an anonymous layer to compute a diff against. It is an error to create such a layer with a package file format. To workaround this limitation with the current implementation, we send packages down the "big bang" invalidation path.

(Internal change: 2355629)

Author: matthewcpp

pxr/usd/pcp/changes.cpp

@@ -18,6 +18,7 @@
 #include "pxr/usd/pcp/pathTranslation.h"
 #include "pxr/usd/pcp/utils.h"
 #include "pxr/usd/sdf/changeList.h"
+#include "pxr/usd/sdf/fileFormat.h"
 #include "pxr/usd/sdf/layer.h"
 #include "pxr/usd/ar/resolverContextBinder.h"
 #include "pxr/base/tf/envSetting.h"
@@ -1555,6 +1556,7 @@ PcpChanges::_DidMuteLayer(
     if (!TfGetEnvSetting(PCP_ENABLE_MINIMAL_CHANGES_FOR_LAYER_OPERATIONS) ||
         !mutedLayer ||
         mutedLayer->IsEmpty() ||
+        mutedLayer->GetFileFormat()->IsPackage() ||
         Pcp_LayerMightHaveRelocates(cache, mutedLayer))
     {
         _DidChangeSublayerAndLayerStacks(
@@ -1614,6 +1616,7 @@ PcpChanges::_DidUnmuteLayer(
     if (!TfGetEnvSetting(PCP_ENABLE_MINIMAL_CHANGES_FOR_LAYER_OPERATIONS) ||
         !unmutedLayer ||
         unmutedLayer->IsEmpty() ||
+        unmutedLayer->GetFileFormat()->IsPackage() ||
         Pcp_LayerMightHaveRelocates(cache, unmutedLayer)) 
     {
         _DidChangeSublayerAndLayerStacks(
@@ -2238,6 +2241,7 @@ PcpChanges::_DidAddOrRemoveSublayer(
                     PCP_ENABLE_MINIMAL_CHANGES_FOR_LAYER_OPERATIONS) ||
                 !sublayer ||
                 sublayer->IsEmpty() ||
+                sublayer->GetFileFormat()->IsPackage() ||
                 Pcp_LayerMightHaveRelocates(cache, sublayer)) 
             {
                 bool isSignificant = false;

pxr/usd/usd/CMakeLists.txt

@@ -227,6 +227,7 @@ pxr_test_scripts(
     testenv/testUsdNamespaceEditorTargetPathFixup.py
     testenv/testUsdNotices.py
     testenv/testUsdObjectsChangedNotices.py
+    testenv/testUsdObjectsChangedNoticesSublayerOps.py
     testenv/testUsdOpaqueAttributes.py
     testenv/testUsdPathExpressionAttrs.py
     testenv/testUsdPayloads.py
@@ -621,6 +622,11 @@ pxr_install_test_dir(
     DEST testUsdNamespaceEditorTargetPathFixup
 )
 
+pxr_install_test_dir(
+    SRC testenv/testUsdObjectsChangedNoticesSublayerOps
+    DEST testUsdObjectsChangedNoticesSublayerOps
+)
+
 pxr_install_test_dir(
     SRC testenv/testUsdPrims.testenv
     DEST testUsdPrims
@@ -1202,6 +1208,12 @@ pxr_register_test(testUsdObjectsChangedNotices
     EXPECTED_RETURN_CODE 0
 )
 
+pxr_register_test(testUsdObjectsChangedNoticesSublayerOps
+    PYTHON
+    COMMAND "${CMAKE_INSTALL_PREFIX}/tests/testUsdObjectsChangedNoticesSublayerOps"
+    EXPECTED_RETURN_CODE 0
+)
+
 pxr_register_test(testUsdNamespaceEditor
     PYTHON
     COMMAND "${CMAKE_INSTALL_PREFIX}/tests/testUsdNamespaceEditor"

pxr/usd/usd/testenv/testUsdObjectsChangedNoticesSublayerOps.py

@@ -0,0 +1,103 @@
+#!/pxrpythonsubst
+#
+# Copyright 2025 Pixar
+#
+# Licensed under the terms set forth in the LICENSE.txt file available at
+# https://openusd.org/license.
+
+
+import unittest
+from pxr import Kind, Sdf, Tf, Usd
+
+class TestUsdObjectsChangedNoticesSublayerOps(unittest.TestCase):
+    def _listenForNotices(self, stage):
+        # Each ObjectsChanged notice is converted to a dictionary and appended
+        # to self._notices.
+        self._notices = []
+        self._noticeKey = Tf.Notice.Register(
+            Usd.Notice.ObjectsChanged,
+            self._onObjectsChanged,
+            stage)
+
+    def _onObjectsChanged(self, notice, sender):
+        asDict = {}
+        resynced = notice.GetResyncedPaths()
+        changedInfoOnly = notice.GetChangedInfoOnlyPaths()
+        resolvedAssetPathsResynced = notice.GetResolvedAssetPathsResyncedPaths()
+        if resynced:
+            asDict['Resynced'] = {
+                str(path): notice.GetChangedFields(path)
+                for path in resynced
+            }
+        if changedInfoOnly:
+            asDict['ChangedInfoOnly'] = {
+                str(path): notice.GetChangedFields(path)
+                for path in changedInfoOnly
+            }
+        if resolvedAssetPathsResynced:
+            asDict['ResolvedAssetPathsResynced'] = {
+                str(path): notice.GetChangedFields(path)
+                for path in resolvedAssetPathsResynced
+            }
+        self._notices.append(asDict)
+
+    def test_InsertPackageSublayer(self):
+        stage = Usd.Stage.CreateInMemory()
+        self._listenForNotices(stage)
+        stage.GetRootLayer().subLayerPaths = ["./package.usdz"]
+        self.assertEqual(len(self._notices), 1)
+        self.assertDictEqual(self._notices[0], {
+            'Resynced': {
+                '/': [] 
+            }
+        })
+
+    def test_RemovePackageSublayer(self):
+        root = Sdf.Layer.CreateAnonymous('root.usda')
+        root.ImportFromString("""#usda 1.0
+                                (
+                                    subLayers = [@./package.usdz@]
+                                )
+                            """)
+        stage = Usd.Stage.Open(root)
+        self._listenForNotices(stage)
+        stage.GetRootLayer().subLayerPaths = []
+        self.assertEqual(len(self._notices), 1)
+        self.assertDictEqual(self._notices[0], {
+            'Resynced': {
+                '/': [] 
+            }
+        })
+
+    def test_MutePackageSublayer(self):
+        root = Sdf.Layer.CreateAnonymous('root.usda')
+        root.ImportFromString("""#usda 1.0
+                                (
+                                    subLayers = [@./package.usdz@]
+                                )
+                            """)
+        stage = Usd.Stage.Open(root)
+        self._listenForNotices(stage)
+        stage.MuteLayer('./package.usdz')
+        self.assertEqual(len(self._notices), 1)
+        self.assertDictEqual(self._notices[0], {
+            'Resynced': {
+                '/': [] 
+            }
+        })
+
+    def test_UnmutePackageSublayer(self):
+        stage = Usd.Stage.CreateInMemory()
+        stage.MuteLayer('./package.usdz')
+        stage.GetRootLayer().subLayerPaths = ["./package.usdz"]
+        self._listenForNotices(stage)
+        stage.UnmuteLayer('./package.usdz')
+        self.assertEqual(len(self._notices), 1)
+        self.assertDictEqual(self._notices[0], {
+            'Resynced': {
+                '/': [] 
+            }
+        })
+
+if __name__ == "__main__":
+    unittest.main()