Adding Articulation Root USD data classes and writers

[vidurv-nvidia]

Description

Adds the articulation-root schema-fragment API.

• ArticulationRootFragment marker (core) plus the PhysX / Newton articulation-root fragments — PhysxArticulationCfg (solver iteration counts, sleep / stabilization thresholds, self-collision toggles) and NewtonArticulationCfg (native self-collisions), each in its own namespace. There is no core neutral fragment: UsdPhysics.ArticulationRootAPI carries no attributes, so the writer applies it as a presence-gated anchor and each backend fragment contributes its own namespaced schema.
• apply_articulation_root_properties family writer — resolves the existing UsdPhysics.ArticulationRootAPI root within the prim subtree and tunes that prim; only defines a fresh root on the target prim when the subtree has none. It never duplicates the root (exactly-one-root invariant). The ArticulationRootAPI anchor is applied by the writer, not by any fragment.
• The non-USD fix_root_link flag is a spawner-cfg field (UsdFileCfg.fix_root_link), passed to the writer as a keyword argument — fragments carry USD attributes only. This is additive; the legacy articulation_props.fix_root_link path is untouched.
• Fixing an articulation base is a capability of the active physics backend: PhysicsManager.fix_articulation_root(prim, stage), resolved from cfg.physics.class_type, authors the world-to-root fixed joint and returns the resulting root prim. The base implementation authors a backend-neutral fixed joint and returns the same prim; PhysX overrides it to relocate the articulation root to the parent (parser workaround) and returns the parent. The writer fixes the root before writing fragments, so every fragment lands on the single resulting root regardless of backend — a composed PhysX + Newton fragment list with fix_root_link=True leaves exactly one root. Dispatch is resolved through the normal method-resolution order, so cfg subclasses and every backend inherit the correct behaviour without any per-type registration or import-order dependency.
• The spawner articulation_props slot now also accepts a fragment list (transition bridge routes legacy single cfgs to the existing define_/modify_ writers). The slot is routed by type even when the list is empty, and fix_root_link is honored independently of whether schema properties were supplied.

Purely additive and self-contained: builds only on the schema-fragment base already in develop, existing call sites untouched, depends on no other open PR. Local test_articulation_fragments.py: 20/20 passing (includes PhysX + Newton root-fixing single-root, manager-subclass capability inheritance, empty/topology-only spawn, and end-to-end _spawn_from_usd_file regressions).

Type of change

• New feature (non-breaking change which adds functionality)

Screenshots

N/A — non-visual API change.

Checklist

• I have read and understood the contribution guidelines
• I have run the pre-commit checks with ./isaaclab.sh --format
• I have made corresponding changes to the documentation
• My changes generate no new warnings
• I have added tests that prove my fix is effective or that my feature works
• I have added a changelog fragment under source/<pkg>/changelog.d/ for every touched package (do not edit CHANGELOG.rst or bump extension.toml — CI handles that)
• I have added my name to the CONTRIBUTORS.md or my name already exists there

[greptile-apps]

Greptile Summary

Adds the articulation-root schema-fragment API on top of the existing SchemaFragment infrastructure. The new apply_articulation_root_properties family writer resolves the existing UsdPhysics.ArticulationRootAPI anchor within the prim subtree (tuning the found root rather than stamping a duplicate), dispatches each fragment to that root, and delegates fix_root_link fixed-joint creation to backend-registered creators via the _FIXED_ROOT_JOINT_CREATORS registry — keeping core free of any backend-specific logic.

• ArticulationRootFragment marker in core, plus PhysxArticulationCfg (physxArticulation:*) and NewtonArticulationCfg (newton:*) concrete fragments in their respective backend packages; each backend self-registers its creator on package import, keyed by its PhysxCfg/NewtonCfg physics-cfg type.
• FileCfg.articulation_props broadened to accept a fragment list and a new spawner-level fix_root_link field added; a transition shim in _spawn_from_usd_file routes legacy single-cfg calls to modify_* and new fragment-list calls to apply_*, leaving all existing call sites unchanged.
• create_fixed_root_joint added as a backend-neutral USD helper (no Kit/omni dependency); the PhysX-specific reparenting workaround lives entirely in isaaclab_physx.

Confidence Score: 5/5

Purely additive change — no existing call sites are touched and the legacy modify_* path is unchanged; safe to merge.

The root-resolution and fragment-dispatch logic is correct and well-tested across 9 tests covering the key invariants: exactly-one-root, child-root tuning, joint toggle/create, backend-selection, and error paths. The fixed-joint lifecycle is consistent between PhysX and Newton backends, and no existing call sites are modified.

No files require special attention; the only findings are minor style observations.

Important Files Changed

Filename	Overview
source/isaaclab/isaaclab/sim/schemas/schemas.py	Adds apply_articulation_root_properties and create_fixed_root_joint; root-resolution and fragment-dispatch logic is correct; fix_root_link handling mirrors the legacy writer faithfully.
source/isaaclab_physx/isaaclab_physx/sim/schemas/init.py	Adds _create_fixed_root_joint (PhysX reparenting workaround) and self-registers it; attribute copy uses attr.Get() (composed value), mirroring the pre-existing pattern in the legacy writer.
source/isaaclab_newton/isaaclab_newton/sim/schemas/init.py	Adds Newton fixed-root-joint creator (no reparenting needed) and self-registers it; deferred pxr imports correctly keep the package importable without the USD runtime.
source/isaaclab/isaaclab/sim/spawners/from_files/from_files_cfg.py	Broadens articulation_props type and adds fix_root_link field; docstrings clearly explain the two-path semantics.
source/isaaclab/isaaclab/sim/schemas/_backend_hooks.py	Adds _FIXED_ROOT_JOINT_CREATORS registry with register/resolve helpers; clean dict-based dispatch following the same pattern as the existing joint-drive skip-predicate registry.
source/isaaclab/test/sim/test_articulation_fragments.py	Nine tests cover fragment metadata, namespace writes, root-resolution (existing child root vs fresh apply), fixed-joint toggle/create, backend-selection, and error paths.

Sequence Diagram

%%{init: {'theme': 'neutral'}}%%
sequenceDiagram
    participant S as Spawner (_spawn_from_usd_file)
    participant W as apply_articulation_root_properties
    participant Q as get_first_matching_child_prim
    participant F as Fragment (apply_namespaced)
    participant R as _FIXED_ROOT_JOINT_CREATORS registry
    participant B as Backend creator (PhysX / Newton)

    S->>W: fragments list, fix_root_link
    W->>Q: search prim_path subtree for ArticulationRootAPI
    Q-->>W: articulation_prim (existing child root OR None)
    alt no existing root
        W->>W: ArticulationRootAPI.Apply(prim_path)
    end
    loop each fragment
        W->>F: func(cfg, root_path, stage)
        F->>F: AddAppliedSchema + write namespaced attrs
    end
    alt fix_root_link is not None
        W->>W: find_global_fixed_joint_prim(root_path)
        alt existing fixed joint found
            W->>W: joint.GetJointEnabledAttr().Set(fix_root_link)
        else "fix_root_link=True, no joint"
            W->>R: _resolve_fixed_root_joint_creator(type(sim.cfg.physics))
            R-->>W: backend creator callable
            W->>B: creator(articulation_prim, stage)
            B->>B: create_fixed_root_joint (pure-USD)
            Note over B: PhysX only: copy attrs to parent,<br/>relocate ArticulationRootAPI
        end
    end
    W-->>S: True

Loading

%%{init: {'theme': 'base', 'themeVariables': {"darkMode": true, "background": "#0d1117", "primaryColor": "#21262d", "primaryTextColor": "#e6edf3", "primaryBorderColor": "#8b949e", "lineColor": "#8b949e", "textColor": "#e6edf3", "edgeLabelBackground": "#161b22", "actorBkg": "#21262d", "actorBorder": "#8b949e", "actorTextColor": "#e6edf3", "actorLineColor": "#8b949e", "signalColor": "#8b949e", "signalTextColor": "#e6edf3", "noteBkgColor": "#373320", "noteBorderColor": "#d4a72c", "noteTextColor": "#f0e6c0", "labelBoxBkgColor": "#21262d", "labelBoxBorderColor": "#8b949e", "labelTextColor": "#e6edf3", "loopTextColor": "#e6edf3", "activationBkgColor": "#30363d", "activationBorderColor": "#8b949e"}}}%%
sequenceDiagram
    participant S as Spawner (_spawn_from_usd_file)
    participant W as apply_articulation_root_properties
    participant Q as get_first_matching_child_prim
    participant F as Fragment (apply_namespaced)
    participant R as _FIXED_ROOT_JOINT_CREATORS registry
    participant B as Backend creator (PhysX / Newton)

    S->>W: fragments list, fix_root_link
    W->>Q: search prim_path subtree for ArticulationRootAPI
    Q-->>W: articulation_prim (existing child root OR None)
    alt no existing root
        W->>W: ArticulationRootAPI.Apply(prim_path)
    end
    loop each fragment
        W->>F: func(cfg, root_path, stage)
        F->>F: AddAppliedSchema + write namespaced attrs
    end
    alt fix_root_link is not None
        W->>W: find_global_fixed_joint_prim(root_path)
        alt existing fixed joint found
            W->>W: joint.GetJointEnabledAttr().Set(fix_root_link)
        else "fix_root_link=True, no joint"
            W->>R: _resolve_fixed_root_joint_creator(type(sim.cfg.physics))
            R-->>W: backend creator callable
            W->>B: creator(articulation_prim, stage)
            B->>B: create_fixed_root_joint (pure-USD)
            Note over B: PhysX only: copy attrs to parent,<br/>relocate ArticulationRootAPI
        end
    end
    W-->>S: True

Loading

_{Reviews (2): Last reviewed commit: "Merge develop to pick up docker install ..." | Re-trigger Greptile}

[greptile-apps]

The Raises section is incomplete. When fix_root_link=True and no creator has been registered (i.e. isaaclab_physx was never imported), the function raises RuntimeError, not one of the two documented exceptions. A caller who catches only ValueError / NotImplementedError will get an unexpected uncaught exception.

Suggested change

	Returns:
	True if the properties were successfully set.
	Raises:
	ValueError: When the prim path is not valid.
	NotImplementedError: When the root prim is not a rigid body and a fixed joint is to be created.
	"""
	Returns:
	True if the properties were successfully set.
	Raises:
	ValueError: When the prim path is not valid.
	NotImplementedError: When the root prim is not a rigid body and a fixed joint is to be created.
	RuntimeError: When ``fix_root_link=True`` and no fixed-root-joint creator has been registered
	(i.e. no physics-backend extension such as ``isaaclab_physx`` has been imported).
	"""

[vidurv-nvidia]

Addressed in b0dcdd8. The per-backend "no creator registered" case is gone with the registry; the remaining RuntimeError is raised only when a fixed joint must be created but there is no active SimulationContext to resolve the backend from, and the Raises section now documents exactly that plus the propagated NotImplementedError.

[ooctipus]

Blocking: this exact-type lookup is not complete for the supported backend/config surface. OvPhysxCfg is a sibling of PhysxCfg, and nothing in isaaclab_ovphysx registers a creator, so fragment mode with fix_root_link=True reaches the RuntimeError. It also misses the in-tree DeformableNewtonCfg(NewtonCfg) and any user subclass. Hook availability additionally depends on importing the matching isaaclab_*.sim.schemas module, rather than on activating that backend, so a Newton run using only the PhysX fragment for articulation_enabled does not register the Newton creator.

The inversion-of-control direction is consistent with #6273, but the cfg class is a brittle dispatch key. SimulationContext.physics_manager already identifies the active implementation and supports inherited backend capabilities; a classmethod/capability there would avoid exact-type and import-order failures. If the registry remains, please resolve through the MRO, register OVPhysX explicitly, make registration occur with backend activation, and test each supported manager plus a cfg subclass.

[ooctipus]

To make the alternative concrete: I do not think we need another factory here, and I would avoid putting this on physics_cfg. The cfg should remain declarative data; SimulationContext has already used cfg.physics.class_type to select the active runtime implementation as sim.physics_manager.

The call could therefore be:

sim = SimulationContext.instance()
final_root = sim.physics_manager.fix_articulation_root(articulation_prim, stage)

with a classmethod capability on PhysicsManager, implemented by each backend. Newton would author the fixed joint and return the same prim; PhysX would author the joint, perform its parser-specific relocation, and return the parent/new root; OVPhysX would provide its own implementation. Returning the final root is important so the family writer can apply every fragment to the actual resulting root.

final_root = sim.physics_manager.fix_articulation_root(articulation_prim, stage)
for fragment in fragments:
    apply_fragment(fragment, final_root, stage)

The relocation path must also migrate/remove pre-existing articulation-root family schemas so the former child cannot remain a second root. This keeps runtime USD mutation on the manager, keeps property ownership in the family writer, inherits naturally for manager subclasses, and removes the parallel cfg-type registry plus its import-order dependency.

[vidurv-nvidia]

Implemented as suggested in b0dcdd8. Fixing the base is now a capability on the manager:

final_root = sim.physics_manager.fix_articulation_root(articulation_prim, stage)
for cfg in fragments:
    func(cfg, final_root.GetPath().pathString, stage)

PhysicsManager.fix_articulation_root (base) authors the backend-neutral fixed joint and returns the same prim; PhysxManager overrides it to relocate the root to the parent and return the parent. The cfg stays declarative — dispatch is resolved from cfg.physics.class_type, so it inherits through the MRO with no parallel registry. The former child is no longer left as a second root because fragments are applied to the returned root (see the property-completeness thread).

One deviation: the enable/disable of an existing fixed joint stays in the writer (a backend-neutral JointEnabledAttr toggle, no relocation); only the create/relocate path is delegated to the manager.

[vidurv-nvidia]

Fixed in b0dcdd8. The exact-type cfg registry is gone, replaced by PhysicsManager.fix_articulation_root resolved through cfg.physics.class_type. Because dispatch is by manager class and inheritance is by MRO, a subclassed cfg like DeformableNewtonCfg(NewtonCfg) resolves NewtonManager and inherits the base capability, OvPhysxManager inherits the base default instead of hitting a RuntimeError, and there is no import-order dependency (the active manager class always exists). Added test_fix_articulation_root_capability_inherited_by_manager_subclass covering a subclass inheriting an overriding backend, and a base-default test for the Newton/OVPhysx path.

[ooctipus]

Blocking property-completeness bug: this relocation moves only the USD/PhysX pieces. For the documented composition [PhysxArticulationCfg(...), NewtonArticulationCfg(...)] with fix_root_link=True, NewtonArticulationRootAPI and newton:* remain on the old child. Because NewtonArticulationRootAPI itself includes PhysicsArticulationRootAPI, removing the directly applied USD API here does not remove the composed root API: the parent and child both remain articulation roots.

That violates the exactly-one-root invariant and leaves newton:selfCollisionEnabled on the wrong root. The current composition test misses it because it never combines fragments with root fixing. Please make the backend operation return/identify the resulting root and let the family writer preserve or reapply every supplied articulation fragment, then add a PhysX + Newton + fix_root_link=True test asserting one root and the Newton value on that root. This is also important for URDF/MJCF assets that already carry the Newton API.

[vidurv-nvidia]

Fixed in b0dcdd8. Root fixing now happens before any fragment is written, and each fragment is applied to the root returned by fix_articulation_root. So after PhysX relocates the root to the parent, both the PhysX and the Newton fragments land on that parent — nothing is stranded on the former child, and there is exactly one root. The PhysX override no longer copies attributes at all (there are none to copy at relocation time). Added test_physx_and_newton_fragments_fix_root_link_keeps_single_root asserting one root with the Newton value on it; verified it fails on the old ordering (2 == 1, the composed NewtonArticulationRootAPI kept the child a root).

[vidurv-nvidia]

Follow-up in 3b9cf1c: the write-fragments-after-fix reorder covered composed fragments but not the URDF/MJCF case you mentioned — an asset that ships with NewtonArticulationRootAPI already authored on the root link would still have kept a second root through schema composition, and pre-authored physxArticulation:* values were dropped instead of moving with the root as the legacy writer did. The PhysX relocation now migrates any directly authored API schema that the USD schema registry reports as composing PhysicsArticulationRootAPI (backend-agnostic, no backend names) plus the PhysxArticulationAPI companion, together with their authored attributes. Two regression tests added (test_physx_fix_root_link_migrates_preauthored_newton_root_api, ..._preauthored_physx_attrs); both verified to fail without the migration (the Newton one with the same 2-roots signature).

[ooctipus]

The field has moved out of the USD fragment, which is the right ownership, but the behavior is still coupled to a non-empty property list here. articulation_props=[] fails this guard and is sent to the legacy writer as a cfg, where dataclasses.fields([]) raises TypeError. With articulation_props=None, the spawner-level fix_root_link is silently ignored. That means a caller needs a dummy backend fragment just to request a topology-only operation; there is no core articulation fragment to use instead. The direct writer tests at lines 268 and 298 already treat [] as valid, so the two entry points disagree.

Please route fragment collections by type even when empty, and preferably process the topology flag independently from whether schema properties were supplied. An end-to-end _spawn_from_usd_file regression test is important here; unlike #5976 and #6254, all new tests bypass this transition bridge.

[vidurv-nvidia]

Fixed in b0dcdd8. articulation_props is now routed by type: a list (including []) goes to the fragment writer, only a legacy single cfg goes to modify_*, so an empty list no longer reaches dataclasses.fields([]). fix_root_link is read as a spawner-level flag independently of whether properties were supplied. Added end-to-end _spawn_from_usd_file regressions for both articulation_props=[] + fix_root_link=True and articulation_props=None + fix_root_link=True.

[ooctipus]

Please pass stage=stage here. The root and fragment writes above honor the explicit stage argument, but this lookup falls back to the current global stage. When the supplied stage is not current, this can either raise because root_path is absent there or toggle a same-path joint on the wrong stage. The current tests all make the supplied stage current, so they do not cover the advertised explicit-stage behavior.

[vidurv-nvidia]

Fixed in b0dcdd8 — find_global_fixed_joint_prim(root_path, stage=stage). Added test_apply_articulation_root_properties_honors_explicit_stage, which authors on a non-current in-memory stage and asserts nothing leaks onto the current stage.

[ooctipus]

I reviewed this against the runtime schemas and the same author history used for the earlier fragment reviews:

• #5275 established the core/base versus backend-package split. This PR follows that ownership correctly.
• #5276 established the explicit schema-property audit standard. Against Kit 110.1.11, the inventory here is complete: OpenUSD ArticulationRootAPI has no attributes; PhysxArticulationCfg has all six PhysxArticulationAPI attributes; NewtonArticulationCfg has the sole Newton articulation attribute.
• #5976 established fragment composition and tested the real spawner transition. The PhysX relocation here breaks that composition, and this PR has no end-to-end spawner test.
• #6273 is the closest precedent for moving a non-USD behavior flag to UsdFileCfg and using backend hooks. Moving fix_root_link out of schema fragments is correct; the remaining plumbing is not yet clean because it is still conditional on a non-empty property list and dispatches through an exact cfg type/import side effect.

I am requesting changes for two blocking correctness/completeness issues:

1. PhysX root relocation leaves NewtonArticulationRootAPI on the old child. Since that schema includes PhysicsArticulationRootAPI, a composed PhysX + Newton asset ends with two articulation roots after fix_root_link=True, with newton:selfCollisionEnabled on the wrong root.
2. Backend dispatch is incomplete: OVPhysX has no registration, cfg subclasses miss the exact lookup, and the matching creator may be absent solely because its schema subpackage was not imported.

The empty-list/spawner behavior and explicit-stage bug are also called out inline. I would add a real UsdFileCfg spawn test covering the fragment bridge, each supported physics manager, a cfg subclass, empty fragments/topology-only use, and combined PhysX + Newton fragments with root fixing.

The cleanest design in the current architecture is to make fixed-root authoring a capability of the active SimulationContext.physics_manager, and have that operation return the resulting articulation-root prim. Core can then retain ownership of fragment application/migration across every namespace, while each backend owns only its topology/parser difference. This removes cfg-type and registration-order coupling. A smaller acceptable fix is MRO-aware lookup, activation-time registration for every backend including OVPhysX, and a hook contract that lets core preserve all composed fragments.

Non-blocking cleanup: the PR description still promises a core UsdPhysicsArticulationRootCfg that is not present, and the new public symbols are absent from the API RST. The two failing CI jobs appear unrelated: OVPhysX failed while downloading a wheel due to a SHA mismatch, and rendering timed out in the Shadow Hand test.

[ooctipus]

there is one usage of this, maybe remove the shim helper

[vidurv-nvidia]

Removed in b0dcdd8 — the shim (_resolve_fixed_root_joint_creator) and the whole creator registry are gone with the move to the PhysicsManager.fix_articulation_root capability.

[vidurv-nvidia]

Addressed the two non-blocking notes from the review summary:

• Description mismatch: corrected. There is no core UsdPhysicsArticulationRootCfg — UsdPhysics.ArticulationRootAPI has no attributes, so core contributes the ArticulationRootFragment marker + the writer (which applies the anchor) and the concrete fragments are PhysxArticulationCfg / NewtonArticulationCfg. The PR description now reflects this and the new PhysicsManager.fix_articulation_root capability design.
• API RST: the fragment API is currently absent from the RST framework-wide (the base SchemaFragment, every apply_* writer, and the sibling Physx*/Newton* fragment classes already merged are all undocumented; the hand-curated schema pages list only the multi-namespace *PropertiesCfg names). Rather than half-document the module here, the full fragment-API RST sweep will land in the docs PR Document schema fragment framework in API reference #6286. Happy to pull it into this PR instead if you would prefer it co-located.

The two failing CI jobs (OVPhysX wheel SHA mismatch, Shadow Hand render timeout) are unrelated to this change, as you noted.

[ooctipus]

I re-reviewed the latest head against the same author's merged schema-fragment precedents. The field split itself is complete (PhysX 6/6, Newton 1/1, and UsdPhysics.ArticulationRootAPI has no configurable attributes), and manager-based dispatch is the right separation boundary. I am requesting changes for the independently reproduced correctness gaps below. All 24 targeted tests pass locally, which means these cases need explicit regression coverage.

[ooctipus]

Blocking: this base implementation is not sufficient for OVPhysX. OvPhysxManager inherits it, but OVPhysX uses the PhysX parser and does not recognize the resulting topology as fixed-base when ArticulationRootAPI remains on the rigid link. I reproduced this with the official ovphysx==0.4.13 parser: root API on the parent gives is_fixed_base=True, while the topology produced here gives is_fixed_base=False.

The new “Newton/OVPhysX” test only invokes PhysicsManager directly and checks authored USD; it never runs the OVPhysX parser. Please give OVPhysX the PhysX-style relocation/migration behavior (a shared pure-USD helper would avoid duplication) and add a real backend test asserting is_fixed_base.

[ooctipus]

Blocking: an existing joint does not make relocation unnecessary. If a pre-authored fixed joint exists while ArticulationRootAPI is still on the rigid link, this branch enables the joint but bypasses physics_manager.fix_articulation_root; PhysX/OVPhysX therefore retain the same floating/maximal-coordinate topology.

The backend capability should own the complete “ensure fixed” operation, including normalizing root placement when the joint already exists (without creating a duplicate). Please cover at least disabled-existing-joint -> fix_root_link=True with the real parser; the current test only covers True -> False.

[ooctipus]

Blocking: resolving only the first matching child silently skips sibling articulations. I reproduced /World/A and /World/B, both carrying ArticulationRootAPI: the fragment was authored on A and absent from B. The legacy @apply_nested writer processes every non-nested sibling root, and multi-articulation USD files are valid inputs.

Please resolve and process all top-level/non-nested articulation roots, creating an anchor on prim_path only when no root exists, and aggregate the per-root result.

[ooctipus]

Blocking: this does not preserve valid authored USD data. The source schema is removed before this read, and attr.Get() reads only the default time. I reproduced physxArticulation:sleepThreshold authored only at times 1 and 2: relocation fails with Type mismatch ... expected 'float', got 'void'. If a default is present, the operation succeeds but silently drops the time samples.

Please capture/copy before removing the schema and preserve the authored default, all time samples, metadata, and connections; property/spec-level copying is safer than reducing each attribute to one Get()/Set().

[ooctipus]

Blocking for the advertised legacy transition: NewtonArticulationRootPropertiesCfg(articulation_enabled=False, self_collision_enabled=True) routed here raises ValueError instead of authoring both fields. The root cause is NewtonArticulationRootPropertiesCfg._usd_field_exceptions = {}, which shadows the inherited mapping required for articulation_enabled.

This breaks the base-field-through-backend-subclass invariant established in the same author's merged #5275. Please inherit/merge the base exception mapping and add a regression comparing this legacy cfg with the equivalent PhysX + Newton fragment list.

[ooctipus]

The fragment result is discarded, so the family writer returns True even when an applier returns False; I reproduced that with a failing stub cfg.func. This contradicts the documented return contract and the aggregate-result semantics established by the same author's merged #5976 follow-up (2a8b8e7). Please accumulate bool(func(...)) across fragments/roots and add the same failing-applier regression used by the other family writers.

[ooctipus]

Re-reviewed head d55e0ed against the same property-inventory, backend-ownership, and fragment-composition precedents used in the earlier review. Approved: the fragment inventory remains complete (PhysX 6/6, Newton 1/1), and the direct fixes now cover every top-level root, instance proxies, return-value propagation, existing disabled joints, PhysX/OVPhysX parent-root normalization, lossless authored USD property migration, Newton legacy routing, and explicit-stage isolation. The joint authoring helper is private and the shared relocation boundary carries no backend imports. Local verification: pre-commit and changelog gates passed; 229 focused/neighboring tests passed. The OVPhysX result was also parsed directly as one fixed-base articulation; full local OV reset remains blocked by the pre-existing pinned-wheel set_cpu_mode mismatch, unrelated to this PR.

[vidurv-nvidia]

CI triage for the failures on 280c20a (isaaclab_tasks [2/3], isaaclab_rl):

Both are the config-import purity tests (test_env_cfg_no_forbidden_imports, test_template_generator). Root cause: the module-level from pxr import ... that came in with the import hoisting — manager_base imports PhysicsManager while environment configs load, so the hoist makes every registered env cfg pull pxr before the app starts, which those tests forbid. Reproduced locally on this head (Isaac-Ant fails with the pxr violation) and fixed in f6fd754 by re-deferring only the pxr imports into the two methods that use them, mirroring the local-import pattern the last commit already used for the SimulationContext cycle.

The module-level from isaaclab.sim.utils.stage import get_current_stage is fine to keep now: I merged latest develop, and #6275 defers the Isaac Sim stage-context integration, so that path no longer reaches isaacsim/carb at import time (it was the second half of the CI failure — the July 4 run predated #6275). After the merge + re-deferral: test_env_cfg_no_forbidden_imports 96/96 and test_articulation_fragments 26/26 locally.

test-curobo and rendering-correctness look unrelated — the rendering failure is in the golden-image comparison path (rendering_test_utils.py:638, flaky-retry involved) and develop just churned goldens; worth a re-run now that develop is merged in.

[vidurv-nvidia]

Install-CI note: the Installation Tests (x86) failure on 10ecaf9 is develop-wide, not from this branch. Both of develop's own Installation Tests runs today fail with the identical signature — the Cartpole camera smoke hits AssertionError: render width must be a multiple of tile_width inside newton/_src/sensors/warp_raytrace/render_context.py:277. It appeared with the Newton pin bump in #6366 (newton==1.4.0.dev0 @ c7ae7c76), whose raytrace context now asserts tile alignment that the camera env render width does not satisfy. This branch touches nothing in the renderer/camera stack, and the same job was green on the previous head before today's develop merge.