diff --git a/houdini/CMakeLists.txt b/houdini/CMakeLists.txt
index 35376d4..1130096 100644
--- a/houdini/CMakeLists.txt
+++ b/houdini/CMakeLists.txt
@@ -14,9 +14,10 @@ install(FILES
 install(DIRECTORY
         otls
         soho
+        toolbar
         python2.7libs
         python3.9libs
+        python3.11libs
     DESTINATION
         plugin/houdini
 )
-
diff --git a/houdini/docs/moonray_render_settings_lop_audit.md b/houdini/docs/moonray_render_settings_lop_audit.md
new file mode 100644
index 0000000..b4c1a30
--- /dev/null
+++ b/houdini/docs/moonray_render_settings_lop_audit.md
@@ -0,0 +1,990 @@
+# MoonRay Render Settings LOP Audit
+
+## Scope
+
+This is a technical development/audit note for the MoonRay Render Settings LOP work in Houdini Solaris. It is not a polished public user manual.
+
+- Validation target for this pass: Houdini 20.5 only.
+- Custom node name: `moonrayrendersettings1`.
+- Custom HDA/operator: `Lop::DW_MOONRAY::moonrayrendersettings::1`.
+- Repo source path: `moonray/moonray_dcc_plugins/houdini/python3.11libs/moonray_render_settings.py`.
+- HDA path: `moonray/moonray_dcc_plugins/houdini/otls/Lop::DW_MOONRAY::moonrayrendersettings::1.hda`.
+- Installed runtime module path used by Houdini 20.5 validation: `/Applications/MoonRay/installs/openmoonray/plugin/houdini/python3.11libs/moonray_render_settings.py`.
+- Houdini 21 evidence is out of scope for this pass and should not be mixed with the Houdini 20.5 results below.
+
+## Evidence-Gated Development Policy
+
+Every important Render Settings, AOV, viewport/IPR, render-buffer, or backend lifecycle claim must be classified as one of:
+
+- `PROVEN`: backed by exact source path/function, command output, exported USD/RDLA, log, installed-runtime provenance, render output, or EXR stats.
+- `OBSERVED`: directly seen in Houdini/runtime behavior, but not fully explained.
+- `HYPOTHESIS`: plausible explanation with a named test that can prove or disprove it.
+- `UNKNOWN`: not enough evidence.
+- `OUT OF SCOPE`: intentionally deferred.
+
+Rules:
+
+1. No claim without evidence.
+2. No recommendation without a reproducer, source-path proof, exported USD proof, log proof, RDLA proof, render proof, or EXR proof.
+3. Do not infer that something is working because a UI folder, parameter, channel, RenderVar, or SceneObject exists.
+4. If the render is black, the path is functionally broken until render proof says otherwise.
+5. Authored USD alone is not render proof.
+6. RDLA/RenderOutput declaration alone is not image-buffer proof.
+7. Debug renderer success is not production renderer success.
+8. Houdini 21 behavior does not prove Houdini 20.5 behavior.
+9. UI cleanup must not hide backend lifecycle, dirtying, render-buffer, AOV binding, or viewport/IPR refresh bugs.
+10. If evidence conflicts, report the conflict instead of choosing the convenient explanation.
+
+Primary source-of-truth hierarchy:
+
+1. Local runtime behavior in the target Houdini version, currently H20.5.
+2. Exported USD from the exact scene state being tested.
+3. Installed hdMoonray source and binaries currently loaded by Houdini.
+4. MoonRay native metadata: `/Applications/MoonRay/installs/openmoonray/coredata/SceneVariables.json` and `/Applications/MoonRay/installs/openmoonray/coredata/RenderOutput.json`.
+5. MoonRay docs and source.
+6. OpenUSD RenderSettings/Product/Var schemas.
+7. SideFX Houdini/HDK docs and local Houdini headers.
+8. Local project docs and prior audit notes.
+
+Track A is DCC/UI/USD-contract work: custom Render Settings LOP generator, regenerated HDA, validation scripts, docs, and installed/runtime source alignment.
+
+Track B is backend forensic work: backend source tracing, temporary diagnostics, logs, render proof, EXR stats, viewport/IPR lifecycle proof, and runtime symptom proof.
+
+Track A and Track B may run in parallel when UI/USD authoring and backend runtime behavior are coupled. Parallel work is allowed. Unsupported blending is not. DCC/USD evidence and backend/runtime evidence must be separated in reports. Commits should stay separate unless the backend root cause is proven, the fix is narrow, and the diff explains why UI/USD and backend behavior must change together.
+
+Backend files are not forbidden. They may be inspected or temporarily instrumented when runtime evidence points there, especially `RenderBuffer.cc`, `ArrasRenderer.cc`, `RenderPass.cc`, `RenderDelegate.cc`, `UsdRenderers.json`, Beauty/AOV binding lifecycle, render settings dirtying/versioning, and viewport/IPR refresh behavior. Backend behavioral changes require source-path proof, exported USD proof, log proof, and render/EXR or runtime symptom proof before implementation.
+
+Do not flip `aovsupport` because it appears related. Do not broaden non-beauty AOV transport. Do not ship UI-only cleanup as a substitute for backend/runtime proof.
+
+## References Consulted
+
+### OpenUSD RenderSettings / RenderProduct / RenderVar
+
+- [usdRender overview](https://openusd.org/dev/user_guides/schemas/usdRender/overview.html): Used for the RenderSettings, RenderProduct, and RenderVar schema relationship model.
+- [RenderSettings schema](https://openusd.org/dev/user_guides/schemas/usdRender/RenderSettings.html): Used to confirm the render settings prim is the global render invocation/configuration prim.
+- [RenderProduct schema](https://openusd.org/dev/user_guides/schemas/usdRender/RenderProduct.html): Used to confirm product/output path and ordered render variable ownership.
+- [RenderVar schema](https://openusd.org/dev/user_guides/schemas/usdRender/RenderVar.html): Used to confirm output variable/AOV authoring expectations.
+- [Render settings proposal](https://openusd.org/release/wp_render_settings.html): Used as background for the USD RenderSettings/Product/Var design.
+- [USD render user guide](https://openusd.org/dev/user_guides/render_user_guide.html): Used for the broader USD rendering workflow context.
+
+### SideFX Solaris / USD Render ROP
+
+- [Render Settings LOP](https://www.sidefx.com/docs/houdini/nodes/lop/rendersettings.html): Primary Houdini/Solaris authoring reference.
+- [Render Product LOP](https://www.sidefx.com/docs/houdini/nodes/lop/renderproduct.html): Used to compare productName/productType/orderedVars authoring.
+- [Render Var LOP](https://www.sidefx.com/docs/houdini/nodes/lop/rendervar.html): Used to compare Beauty RenderVar authoring and driver parameter extras.
+- [USD Render ROP](https://www.sidefx.com/docs/houdini/nodes/out/usdrender.html): Used to confirm the USD Render ROP execution/wiring model.
+
+### SideFX HOM / LOP Python
+
+- [hou.LopNode](https://www.sidefx.com/docs/houdini/hom/hou/LopNode.html): Used for Python LOP/HDA stage access and validation.
+- [hou.lop](https://www.sidefx.com/docs/houdini/hom/hou/lop.html): Used for Solaris/HOM context.
+
+### SideFX HDK / USD / Hydra
+
+- [HDK USD Hydra customization](https://www.sidefx.com/docs/hdk/_h_d_k__u_s_d_hydra.html): Used for Houdini/Hydra integration context.
+- [LOP_Node header/source](https://www.sidefx.com/docs/hdk/_l_o_p___node_8h_source.html): Used for LOP implementation and cooking context.
+
+### SideFX Houdini Digital Asset / UI References
+
+- [Asset UI](https://www.sidefx.com/docs/houdini/assets/asset_ui.html): Used for HDA parameter UI conventions.
+- [Editing assets](https://www.sidefx.com/docs/houdini/assets/edit.html): Used for HDA/source-of-truth considerations.
+- [Operator Type Properties](https://www.sidefx.com/docs/houdini/ref/windows/optype.html): Used for HDA operator definition behavior.
+- [Edit Properties LOP](https://www.sidefx.com/docs/houdini/nodes/lop/editproperties.html): Used as context for Houdini's generic USD property authoring model.
+
+### OpenMoonRay / HdMoonRay
+
+- [HdMoonRay Render Settings](https://docs.openmoonray.org/user-reference/tools/hydra/render-settings/): Used for the MoonRay/Hydra render settings path.
+- [HdMoonRay setup](https://docs.openmoonray.org/user-reference/tools/hydra/hdmoonray-setup/): Used for plugin/runtime environment context.
+- [HdMoonRay commands](https://docs.openmoonray.org/user-reference/tools/hydra/commands/): Used for `husk`/Hydra command-line context.
+- [HdMoonRay Houdini](https://docs.openmoonray.org/user-reference/tools/hydra/hdmoonray-houdini/): Used for Houdini integration context.
+- [HdMoonRay features](https://docs.openmoonray.org/user-reference/tools/hydra/hdmoonray-features/): Used for feature support context.
+- [MoonRay scene objects](https://docs.openmoonray.org/user-reference/scene-objects/): Used for RDL scene object context.
+- [SceneVariables](https://docs.openmoonray.org/user-reference/scene-objects/scene-variables/SceneVariables/): Used to classify MoonRay SceneVariables.
+- [RenderOutput](https://docs.openmoonray.org/user-reference/scene-objects/render-output/RenderOutput/): Used for MoonRay-side output/AOV realization.
+- [Render outputs guide](https://docs.openmoonray.org/user-reference/how-to-guides/render-outputs/): Used for MoonRay RenderOutput workflow context.
+- [OpenMoonRay developer reference](https://docs.openmoonray.org/developer-reference/): Used for developer-level source/library context.
+
+### Autodesk / Arnold AOV References
+
+These were treated only as practical renderer/AOV workflow references, not as MoonRay truth.
+
+- [arnold-usd](https://github.com/Autodesk/arnold-usd)
+- [Arnold expression AOVs](https://help.autodesk.com/cloudhelp/ENU/AR-Core/files/ac-output-aovs/arnold_user_guide_ac_output_aovs_ac_expression_aovs_html.html)
+- [Arnold AOV shaders](https://help.autodesk.com/cloudhelp/ENU/AR-Core/files/ac-shading/arnold_user_guide_ac_shading_ac_aov_shaders_html.html)
+- [Arnold for Cinema 4D AOVs](https://help.autodesk.com/cloudhelp/JPN/AR-Cinema4D/files/ci-arnold-render-settings/arnold_for_cinema_4d_ci_Arnold_Render_Settings_ci_AOVs_html.html)
+- [Arnold for 3ds Max AOVs](https://help.autodesk.com/view/3DSMAX/2024/ENU/?guid=arnold_for_3ds_max_ax_render_setup_ax_aovs_html)
+
+## Source of Truth and Runtime Import Rules
+
+The repo `moonray_render_settings.py` is the source of truth for the custom MoonRay Render Settings LOP. The HDA UI and cook-time Python must come from the same definition list. The generated HDA imports `moonray_render_settings` at cook time, so the module imported by Houdini must match the source used to generate the HDA.
+
+Runtime import path used by Houdini 20.5 validation:
+
+```text
+/Applications/MoonRay/installs/openmoonray/plugin/houdini/python3.11libs/moonray_render_settings.py
+```
+
+Verification commands inside Houdini 20.5 `hython`:
+
+```python
+import moonray_render_settings
+print(moonray_render_settings.__file__)
+print(len(moonray_render_settings.SCENE_VARIABLES))
+print(any(name == "enable_dof" for name, _ in moonray_render_settings.SCENE_VARIABLES))
+print(any(name == "light_sampling_mode" for name, _ in moonray_render_settings.SCENE_VARIABLES))
+```
+
+The drift bug happened because the visible HDA UI was newer than the installed Python module that Houdini imported at cook time. The repo source and HDA contained newer settings, but Houdini 20.5 loaded the stale installed module from the plugin install tree.
+
+The local install-tree sync used during validation copied the repo source and regenerated HDA into the installed plugin tree. That was a validation step, not a final manual-install solution. Future repo/install tooling must keep the HDA and runtime Python module aligned reproducibly.
+
+## Proven Drift Bug
+
+Before the source/install sync:
+
+- HDA UI showed `Enable DOF`.
+- Installed runtime module had only 18 SceneVariables.
+- `enable_dof` was missing from the installed runtime module.
+- Custom USD did not author `moonray:sceneVariable:enable_dof`.
+- Custom RDLA kept camera `["dof"] = true`.
+
+After the source/install sync:
+
+- Installed runtime module has 50 SceneVariables.
+- `enable_dof` is present.
+- `light_sampling_mode` is present.
+- Custom USD authors `custom bool moonray:sceneVariable:enable_dof = 0`.
+- Custom RDLA contains `["enable_dof"] = false`.
+
+## USD RenderSettings / RenderProduct / RenderVar Contract
+
+The USD render contract is:
+
+- `RenderSettings` owns render invocation/global render settings.
+- `RenderSettings` has the render camera relationship.
+- `RenderSettings` has the products relationship.
+- `RenderProduct` owns `productName`, `productType`, and `orderedVars`.
+- `RenderVar` describes an AOV/output variable.
+- AOVs flow through `RenderSettings -> RenderProduct -> orderedVars -> RenderVar`.
+- The MoonRay backend realizes render outputs as MoonRay `RenderOutput` objects.
+
+Current custom authored paths:
+
+```text
+/Render/rendersettings
+/Render/Products/renderproduct
+/Render/Products/Vars/beauty
+```
+
+## Render Product and Output Path Rules
+
+`RenderProduct.productName` is the USD fallback image output path authored by the custom LOP. `$HIP`, `$HIPNAME`, `$OS`, and `$F4` are valid Houdini path tokens, but plain `husk` does not have the same node/project context as a Houdini USD Render ROP. The default custom LOP path escapes the frame token as `\$F4` so the filename remains frame-expandable for husk/ROP execution without making the Render Settings LOP itself time-dependent on the current Houdini frame.
+
+For the owned MoonRay USD Render ROP, the ROP `outputimage` parameter is the primary output authority. It is linked to the LOP `product_name` parameter with a raw backtick HScript string expression so Houdini evaluates `$HIP`, `$HIPNAME`, and `$OS` in the ROP/HIP context while preserving the escaped frame token for husk frame expansion.
+
+When the USD Render ROP `outputimage` override is blank, the RenderProduct output path wins. A Houdini 20.5 smoke test wrote:
+
+```text
+/tmp/moonray_render_settings_alignment_after/rop_product.0001.exr
+```
+
+That earlier smoke render was black, so it proved USD Render ROP wiring, RenderProduct output creation, and resolution/output path behavior only. The current H20.5 disk-output contract adds the default Beauty RenderVar/`orderedVars` path and has filled EXR proof; this evidence is scoped to Beauty and does not prove non-beauty AOV support.
+
+2026 output-path regression evidence:
+
+- Manual `husk -o /tmp/moonray_manual_husk_test2.exr` with `--settings /Render/rendersettings` writes a valid nonconstant 512x512 RGB float EXR.
+- Manual `husk` with an absolute `RenderProduct.productName = "/tmp/moonray_product_abs.exr"` and no `-o` writes a valid nonconstant EXR.
+- Manual `husk` with `RenderProduct.productName = "$HIP/render/$HIPNAME.$OS.$F4.exr"` and no `-o` writes `./render/untitled..0001.exr`, proving the fallback path is evaluated without the Houdini ROP/node context.
+- A Houdini LOP `usdrender_rop` with blank `outputimage` and absolute `RenderProduct.productName = "/tmp/moonray_product_fallback.exr"` writes a valid nonconstant EXR, proving productName fallback still works when the path is concrete.
+- The owned MoonRay ROP now links `outputimage` to the LOP `product_name`; a saved-HIP test wrote `/tmp/moonray_saved_hip_test/render/moonray_test.0001.exr`, not `untitled`.
+- A later time-dependency audit showed that raw `$F4` in the custom LOP `product_name` makes the Render Settings LOP time-dependent. Escaping the default as `\$F4` keeps the frame placeholder for the ROP/husk filename but prevents unintended LOP time dependency. The owned ROP uses raw backtick strings such as `` `chs("<owning LOP>/product_name")` `` rather than `parm.setExpression()`, so repair/creation does not create expression keyframes on the owned ROP parms.
+
+## Generic Houdini Render Settings Boundary
+
+The generic Houdini Render Settings LOP with a MoonRay folder is UI integration evidence only. It is not complete render proof.
+
+If flattened USDA has empty `rel products` and no `RenderProduct`, `productName`, or `productType`, generic Render Settings alone is not a complete MoonRay output setup. If it renders black, it is functionally broken until render proof says otherwise.
+
+Generic Render Settings may still be useful as raw/advanced reference UI, but it should not be advertised as the primary working workflow without product/output proof and filled render proof.
+
+## Resolution Behavior
+
+The custom MoonRay Render Settings LOP uses manual resolution only.
+
+Earlier prototypes mirrored Karma's computed camera-aperture modes:
+
+- Set Width, Compute Height from Camera.
+- Set Height, Compute Width from Camera.
+
+Those computed modes were removed in the H20.5 UI/lifecycle cleanup pass to reduce callback and lifecycle complexity. The node now exposes a simple `Manual Resolution` note plus a directly editable `Resolution` integer pair.
+
+Validated dimensions:
+
+- Manual: `512 x 256`.
+
+The custom LOP authors final numeric resolution as `RenderSettings.resolution`. It must not author `moonray:sceneVariable:image_width` or `moonray:sceneVariable:image_height`.
+
+## SceneVariables and Render Settings
+
+MoonRay render settings that target RDL `SceneVariables` are authored as `moonray:sceneVariable:*` custom attributes on the `RenderSettings` prim where appropriate.
+
+`image_width` and `image_height` should not be authored by the custom LOP. They appear in RDLA from Hydra/render-pass framing, not from custom USD SceneVariable attributes.
+
+Current custom USD now authors:
+
+- `moonray:sceneVariable:enable_dof`.
+- `moonray:sceneVariable:light_sampling_mode`.
+- Tile order settings.
+- `moonray:sceneVariable:roughness_clamping_factor`.
+- `moonray:sceneVariable:target_adaptive_error`.
+
+RDLA proves MoonRay receives `enable_dof`, `light_sampling_mode`, `target_adaptive_error`, and `roughness_clamping_factor`.
+
+| UI label | USD attr | USD type | RDLA key | Current status |
+|---------|----------|----------|----------|----------------|
+| Enable DOF | `moonray:sceneVariable:enable_dof` | bool | `enable_dof` | working after drift fix |
+| Light Sampling Mode | `moonray:sceneVariable:light_sampling_mode` | token/string | `light_sampling_mode` | working after drift fix |
+| Target Adaptive Error | `moonray:sceneVariable:target_adaptive_error` | float | `target_adaptive_error` | working after drift fix |
+| Roughness Clamping Factor | `moonray:sceneVariable:roughness_clamping_factor` | float | `roughness_clamping_factor` | working after drift fix |
+| Image Width | do not author | n/a | `image_width` | render-pass-derived |
+| Image Height | do not author | n/a | `image_height` | render-pass-derived |
+
+## Parameter Location Classification
+
+The Render Settings LOP must not absorb every MoonRay or USD setting. Not every `moonray:*` attribute belongs on `RenderSettings`.
+
+| Area | Example | Correct USD location | USD kind | MoonRay/RDL target | Should this Render Settings LOP author it? | Correct authoring path | Status |
+|------|---------|----------------------|----------|--------------------|--------------------------------------------|------------------------|--------|
+| Render settings | pixel samples | RenderSettings prim | `moonray:sceneVariable:*` attr | SceneVariables | yes | custom Render Settings LOP | verify/working |
+| Render output/AOV | beauty/color | RenderProduct plus Beauty RenderVar by default for H20.5 disk output | UsdRenderProduct / UsdRenderVar | Hydra color AOV mapped to MoonRay beauty framebuffer | yes for disk output beauty; diagnostic disable path only | Output / Product | default Beauty RenderVar |
+| Geometry settings | `moonray:mesh_resolution` | geometry prim | primvar or namespaced prim attr | RDL geometry setting | no | LOP wrangle / geometry settings node | document only |
+| Camera/DOF settings | DOF enable/focus/aperture depending on native behavior | camera prim or RenderSettings depending on proven path | camera attr or SceneVariable | Camera / SceneVariables | only if native path proves it | match H20.5 generic/native | audit |
+| Light settings | MoonRay light attrs | light prim | namespaced attrs | RDL light | no | light LOP / light-specific UI | document only |
+| Material settings | material/shader attrs | material/shader prim | shader inputs | RDL material | no | material network | document only |
+| Debug/RDLA output | RDLA dump path/options | RenderSettings/delegate setting if proven | renderer/debug setting | hdMoonRay/debug | yes, Advanced/Debug only | custom Render Settings LOP | verify |
+
+Do not expose `moonray:mesh_resolution` in the Render Settings LOP as a global render setting. Geometry, light, material, and camera prim-level settings belong on their own prims unless Houdini 20.5 native/generic behavior proves otherwise.
+
+### Sampling Mode Contract
+
+The current H20.5 source and documentation split sampling controls by mode:
+
+- MoonRay `sampling_mode` is a native SceneVariables enum. Local `SceneVariables.json`
+  and the public SceneVariables reference define `uniform = 0` and `adaptive = 2`.
+- The custom LOP authors token strings, `uniform` and `adaptive`, as
+  `moonray:sceneVariable:sampling_mode`; `hdMoonray::ValueConverter` maps those
+  enum tokens to the native MoonRay enum values.
+- MoonRay `pixel_samples` is the uniform sampling control.
+- MoonRay `min_adaptive_samples`, `max_adaptive_samples`, and
+  `target_adaptive_error` are adaptive sampling controls.
+- MoonRay `light_sampling_mode` uses `uniform = 0` and `adaptive = 1`;
+  `light_sampling_quality` is active only in adaptive light sampling mode.
+
+Houdini menu conditionals for this generated HDA use the custom LOP menu token
+strings, not native MoonRay enum integer values. The HDA menu items are
+`("uniform", "adaptive")`. The custom LOP therefore disables:
+
+- `Pixel Samples` when `sceneVariable_sampling_mode != "uniform"`.
+- `Min Adaptive Samples`, `Max Adaptive Samples`, and `Target Adaptive Error`
+  when `sceneVariable_sampling_mode != "adaptive"`.
+- `Light Sampling Quality` when `sceneVariable_light_sampling_mode != "adaptive"`.
+
+The installed hdMoonray viewport DS uses integer parameters and numeric
+disable-when expressions for Display Options. Do not blindly copy those numeric
+conditions into the generated custom HDA: the previous numeric-condition attempt
+passed a headless HOM probe but regressed the graphical H20.5 custom LOP UI.
+
+Headless Hython validation can inspect the conditional strings, but it does not
+prove the graphical disabled/greyed-out state. Fresh H20.5 GUI validation should
+still be used before claiming viewport/UI parity with Solaris Display Options.
+
+The LOP currently authors the curated SceneVariables consistently even when a
+control is inactive for the selected mode. Validation shows changing sampling
+values and toggling `Sampling Mode` updates the exported USD without requiring a
+manual dropdown refresh. The inactive values are retained as SceneVariables, but
+the UI now communicates which controls are relevant for the selected mode.
+
+Do not add sampling `moonray:sceneVariable:*` keys to
+`hdMoonray::RenderSettings::addDescriptors()` as a live-update workaround.
+OpenUSD's `HdRenderSettingDescriptor` is a renderer-exported setting descriptor
+used by hosts for UI/defaults, and adding these descriptors regressed Houdini
+Display Options initialization. The custom LOP should author the USD
+RenderSettings attrs; the viewport Display Options should continue to use the
+existing DS-declared `sceneVariable_*` controls.
+
+## Native MoonRay SpotLight Toggle Time Dependency
+
+The Light LOP MoonRay tab exposes `Enable Native MoonRay SpotLight` from the
+Houdini renderer-property DS files:
+
+```text
+houdini/soho/parameters/HdMoonrayRendererPlugin_Light.ds
+houdini/soho/parameters/moonray_Light.ds
+```
+
+That toggle is a convenience wrapper around the generated MoonRay class override
+parameters:
+
+```text
+xn__moonrayclass_control_o8a = set
+xn__moonrayclass_nva = SpotLight
+```
+
+`xn__moonrayclass_nva` has a generated Python-expression default that derives the
+MoonRay light class from the Houdini light type. The native-SpotLight callback
+must replace that generated expression with a static `SpotLight` token without
+leaving keyframes, expressions, helper user data, or USD time samples behind.
+Earlier callback variants also wrote `moonray_native_spotlight_helper` node user
+data; that bookkeeping was removed because Houdini can draw green network badges
+for non-keyframe node data as well as for true time-dependency. H20.5 hython
+validation executes the exact callback text and checks:
+
+- the Light LOP remains non-time-dependent;
+- the native SpotLight toggle, class-control parm, and class parm have static
+  values after enable;
+- `xn__moonrayclass_nva` has no expression and no keyframes after enable;
+- no `moonray_native_spotlight_helper` user data is written;
+- the flattened USD layer has no time-sampled attributes before or after enable.
+
+The static class value is ignored when the control parm is reset to `none`, so
+disabling the helper does not author a MoonRay class override.
+
+## Beauty RenderVar and AOV Status
+
+The H20.5 USD Render ROP / husk disk-output workflow now authors a Beauty RenderVar by default. A
+custom LOP export with `aov_beauty = 0`, `RenderProduct.productName`, `productType = "raster"`, and
+empty `orderedVars` failed in production `husk` with `No orderedVars to specify channels for
+/Render/Products/renderproduct`. The same scene with the Beauty RenderVar produced a filled,
+nonconstant EXR.
+
+Current default custom LOP contract:
+
+- `aov_beauty = 1`.
+- Beauty RenderVar authored by default for disk output.
+- `UsdRender.Settings`.
+- `UsdRender.Product`.
+- `settings.products`.
+- `settings.camera`.
+- `settings.resolution`.
+- `product.productName`.
+- `product.productType = "raster"`.
+- `orderedVars` targets `/Render/Products/Vars/beauty`.
+- Curated `moonray:sceneVariable:*`.
+
+The Beauty control preserves the internal parameter name `aov_beauty` for compatibility. Its label is
+`Beauty RenderVar / Disk Output Path`, and it belongs with Render Product/output controls. Disabling
+it is a diagnostic viewport/default-framebuffer test path, not the production disk-output default.
+
+This Beauty/default-output contract is separate from non-beauty AOV support. It is the minimal proven
+H20.5 disk-output beauty contract.
+
+Custom Beauty RenderVar when `aov_beauty` is enabled:
+
+```text
+Path: /Render/Products/Vars/beauty
+sourceName = color
+sourceType = raw
+dataType = color4f
+driver:parameters:aov:name = color
+driver:parameters:aov:format = color4f
+driver:parameters:aov:multiSampled = 0
+driver:parameters:aov:clearValue = 0
+```
+
+Generic Houdini 20.5 RenderVar extras now aligned:
+
+- `sourceType = raw`.
+- `driver:parameters:aov:format = color4f` for the custom MoonRay Beauty RenderVar.
+- `driver:parameters:aov:multiSampled = 0`.
+- `driver:parameters:aov:clearValue = 0`.
+
+Houdini `customData` appears to be UI/editor metadata and should not be hand-copied unless the integration deliberately adopts the generic/Edit Properties infrastructure.
+
+Native non-beauty AOV status:
+
+- A first native AOV set is exposed as opt-in checkboxes under the `AOVs` tab.
+- The exposed set is limited to existing hdMoonray `RenderBuffer.cc` mappings with production filled-pixel proof after the RenderBuffer allocation/channel-count fix: `alpha`, `depth`, `Z`, `N`, `Ng`, `P`, `Wp`, `St`, and `weight`.
+- Product-facing depth outputs are `depth` and `Z`.
+- The historical diagnostic depth token is not exposed by the custom MoonRay Render Settings LOP in this pass.
+- Material AOVs, LPE/light AOVs, visibility AOVs, primitive-attribute AOVs, Cryptomatte, display filters, auxiliary adaptive buffers, and motion vectors remain deferred.
+- Debug/local path filling is still not enough for artist UI exposure; future AOVs require production `HdMoonrayRendererPlugin` filled-pixel proof through USD Render ROP/husk or equivalent production path.
+- If a production path produces zero-filled buffers again, classify that as backend payload unresolved, not UI-ready.
+
+Do not remove the default Beauty RenderVar for the custom LOP disk-output path unless fresh H20.5
+viewport/IPR, USD Render ROP/husk, and filled image/EXR output prove a replacement contract. Do not
+extend this evidence to non-beauty AOVs.
+
+Do not claim AOV support from authored RenderVars, metadata, EXR channels, RDLA RenderOutput declarations, or debug renderer success alone.
+
+Current native AOV RenderVar contract:
+
+| UI toggle | RenderVar | sourceName | sourceType | dataType | Status |
+|-----------|-----------|------------|------------|----------|--------|
+| Beauty RenderVar / Disk Output Path | `beauty` | `color` | `raw` | `color4f` | default on; production Beauty/disk output |
+| Alpha | `alpha` | `alpha` | `raw` | `float` | opt-in native AOV |
+| Depth | `depth` | `depth` | `raw` | `float` | opt-in native AOV; follows hdMoonray depth mapping |
+| Z | `Z` | `Z` | `raw` | `float` | opt-in native state-variable depth |
+| N | `N` | `N` | `raw` | `normal3f` | opt-in native state variable |
+| Ng | `Ng` | `Ng` | `raw` | `normal3f` | opt-in native state variable |
+| P | `P` | `P` | `raw` | `point3f` | opt-in native state variable |
+| Wp | `Wp` | `Wp` | `raw` | `point3f` | opt-in native state variable |
+| St | `St` | `St` | `raw` | `float2` | opt-in native state variable |
+| Weight | `weight` | `weight` | `raw` | `float` | opt-in native RenderOutput; simple fixture produced a constant sample-count value |
+
+All selected native AOVs also author matching `driver:parameters:aov:name`, `driver:parameters:aov:format`, `driver:parameters:aov:multiSampled = 0`, and `driver:parameters:aov:clearValue = 0` attrs. These attrs match the working Beauty path and the H20.5 RenderVar metadata shape, but the source of truth for renderer data remains the `sourceName`/`sourceType` pair consumed by hdMoonray.
+
+Manual H20.5 validation showed `color3f` Beauty output could produce vertical RGB/bayer-like EXR corruption in the explicit Beauty RenderVar path. Switching the custom Beauty RenderVar to `color4f` fixed that corruption by matching the RGBA beauty buffer contract. Copernicus and Nuke both read the resulting EXR channels correctly; an earlier Nuke channel-view issue was user selection error, not file corruption.
+
+## Material / Denoise AOV Contract
+
+Official MoonRay evidence:
+
+- The [moonray_gui documentation](https://docs.openmoonray.org/user-reference/tools/moonray-gui/) states that denoiser auxiliary buffers must be represented by `RenderOutput` objects tagged with `denoiser_input`; names and filenames are not important to the denoiser.
+- The documented OIDN albedo auxiliary contract is `result = material aov`, `material aov = D.albedo`, and `denoiser_input = as albedo`.
+- The documented OIDN normal auxiliary contract is `result = state variable`, `state variable = N`, `channel_suffix_mode = rgb`, and `denoiser_input = as normal`.
+- The [Material AOV guide](https://docs.openmoonray.org/user-reference/how-to-guides/render-outputs/material-aovs/) defines material AOVs as diagnostic material-property outputs with syntax `[('<Label>')+\\.][(SS | R | T | D | G | M)+\\.][fresnel\\.]<property>`.
+- `/Applications/MoonRay/installs/openmoonray/coredata/RenderOutput.json` lists the relevant RenderOutput attrs: `result`, `material_aov`, `state_variable`, `channel_format`, `channel_suffix_mode`, and `denoiser_input`.
+
+hdMoonray bridge evidence:
+
+- `RenderBuffer.cc::aovNameFromSettings()` maps `sourceType = shader` to the internal `shader:<sourceName>` form.
+- `RenderBuffer.cc::bind()` maps the `shader:` prefix to MoonRay `RESULT_MATERIAL_AOV` and copies `parameters:moonray:<RenderOutput attr>` AOV settings onto the created MoonRay `RenderOutput`.
+- Therefore the custom LOP authors material AOV RenderVars with `sourceType = shader` and authors denoiser/channel metadata as `parameters:moonray:*` attrs on the RenderVar.
+
+Current exposed Material / Denoise AOV set:
+
+| UI toggle | RenderVar | sourceName | sourceType | dataType | Extra MoonRay RenderOutput attrs | Status |
+|-----------|-----------|------------|------------|----------|----------------------------------|--------|
+| Denoise Albedo | `denoise_albedo` | `D.albedo` | `shader` | `color3f` | `denoiser_input = as albedo`, `channel_suffix_mode = rgb`, `channel_format = float` | production H20.5 EXR proof; required OIDN auxiliary |
+| Denoise Normal | `denoise_normal` | `N` | `raw` | `normal3f` | `denoiser_input = as normal`, `channel_suffix_mode = rgb`, `channel_format = float` | production H20.5 EXR proof; required OIDN auxiliary |
+| Material Albedo | `material_albedo` | `albedo` | `shader` | `color3f` | none | production H20.5 EXR proof |
+| Material Emission | `material_emission` | `emission` | `shader` | `color3f` | none | production H20.5 EXR proof |
+| Material Normal | `material_normal` | `normal` | `shader` | `normal3f` | `channel_suffix_mode = rgb` | production H20.5 EXR proof |
+| Material Roughness | `material_roughness` | `roughness` | `shader` | `float2` | none | production H20.5 EXR proof |
+| Material PBR Validity | `material_pbr_validity` | `pbr_validity` | `shader` | `color3f` | none | production H20.5 EXR proof |
+
+The expected OIDN auxiliary set is Beauty/color plus Denoise Albedo plus Denoise Normal. Beauty remains the `color4f` default disk-output RenderVar; the denoise auxiliaries are opt-in and default off.
+
+Discovered but not exposed in this pass:
+
+| Candidate | Official/local status | Reason not exposed |
+|-----------|----------------------|--------------------|
+| `color` | Listed as a material AOV property in official docs/metadata. | The H20.5 production proof scene did not produce a distinct `color` subimage through the current hdMoonray material-AOV bridge. |
+| `factor` | Listed as a material AOV property in official docs/metadata. | The proof scene produced a constant zero output; no meaningful production proof yet. |
+| `radius` | Listed as a material AOV property in official docs/metadata. | The proof scene produced a constant zero output; likely needs a subsurface-specific material setup and separate proof. |
+
+Cryptomatte, LPE/light AOVs, visibility AOVs, primitive-attribute AOVs, arbitrary primvars, display-filter outputs, auxiliary adaptive buffers, and motion vectors remain deferred. The historical diagnostic depth token is not product-facing and is not exposed by this LOP.
+
+## USD Render ROP Integration
+
+Houdini 20.5 USD Render ROP parameter names for both LOP `usdrender_rop` and OUT `usdrender`:
+
+- `renderer`.
+- `loppath`.
+- `rendersettings`.
+- `outputimage`.
+
+Houdini 20.5 `husk --list-renderers` sees:
+
+- `HdMoonrayRendererPlugin (Moonray)`.
+- `HdMoonrayRendererDebugPlugin (Moonray (debug))`.
+
+Houdini 20.5 USD Render ROP menu shows Moonray. The repaired owned LOP `usdrender_rop` path uses:
+
+```text
+renderer = HdMoonrayRendererPlugin
+loppath expression = opinput(".", 0)
+rendersettings expression = chs("<owning MoonRay Render Settings LOP>/render_settings_prim")
+outputimage raw string = `chs("<owning MoonRay Render Settings LOP>/product_name")`
+```
+
+Validated output paths:
+
+```text
+/tmp/moonray_rop_output_override.exr
+/tmp/moonray_saved_hip_test/render/moonray_test.0001.exr
+```
+
+Both outputs were valid nonconstant 512x512 RGB float EXRs in H20.5. The socket disconnect message after successful file write remains shutdown noise for these batch renders, not an output-path failure.
+
+## USD Render ROP Auto-Creation Policy
+
+The MoonRay Render Settings LOP intentionally auto-creates a matching USD Render ROP LOP node on node creation. This is part of the desired integrated artist workflow: creating the render settings node should immediately leave the offline render path ready to use.
+
+The custom LOP authors `/Render/rendersettings` and `RenderProduct.productName`. The auto-created `usdrender_rop` LOP is an execution wrapper connected below the settings LOP and pointed at that authored RenderSettings prim. The ROP `outputimage` parameter is linked to the LOP `product_name` parameter so Houdini evaluates `$HIP`, `$HIPNAME`, and `$OS` in a real Houdini ROP/HIP context before launching `husk`; the default frame token is escaped as `\$F4` so it stays scoped to filename/frame expansion and does not mark the custom LOP itself time-dependent.
+
+Houdini 20.5 ROP details:
+
+```text
+Context: same LOP network as the MoonRay Render Settings LOP
+Node type: usdrender_rop
+renderer = HdMoonrayRendererPlugin
+loppath = opinput(".", 0)
+rendersettings = chs("<current MoonRay Render Settings LOP>/render_settings_prim")
+outputimage raw string = `chs("<current MoonRay Render Settings LOP>/product_name")`
+```
+
+Ownership is recorded on the ROP with userData:
+
+```text
+moonray_render_settings_lop = <owning LOP path>
+moonray_render_settings_operator = Lop::DW_MOONRAY::moonrayrendersettings::1
+moonray_render_settings_lop_session_id = <owning LOP session id>
+```
+
+The deterministic LOP ROP node name is based on the MoonRay Render Settings LOP node name:
+
+```text
+/stage/moonrayrendersettings1_usdrender
+```
+
+The creation/update helper is idempotent and non-destructive:
+
+- If the owned `usdrender_rop` exists, update it.
+- If it does not exist, create it in the same LOP network.
+- Running the helper repeatedly must not create duplicates.
+- Do not overwrite unrelated user-created USD Render ROP LOPs.
+- If the deterministic name already exists but is not owned by the MoonRay Render Settings LOP, create a unique safe name instead.
+- Multiple MoonRay Render Settings LOPs should each create a distinct owned ROP.
+
+Rename behavior:
+
+- During the current Houdini session, the helper stores the owning LOP session id and can update the owned ROP after a LOP rename.
+- Across saved/reloaded sessions, robust rename recovery may be limited if the old path and session id no longer identify the owner. In that case, the repair helper should avoid overwriting unrelated ROPs and create/update only clearly owned ROPs.
+
+An optional `Create / Update USD Render ROP` repair button calls the same helper used by the HDA `OnCreated` event. It is a secondary repair/update affordance, not a replacement for automatic ROP creation.
+
+Do not auto-create or update ROPs during normal cook or ordinary parameter changes.
+
+## Design Guidelines
+
+- Native Solaris first.
+- Use Houdini 20.5 Generic Render Settings as UX/layout reference.
+- Expose curated artist controls, not raw metadata dumps.
+- Group by task, not JSON order.
+- Do not show broken or unverified controls in main artist tabs.
+- Put debug/RDLA/internal controls in Advanced/Debug.
+- AOV tabs should expose only production-proven outputs.
+- Defaults should match Houdini 20.5 Generic/Native or MoonRay defaults unless deliberately changed.
+- No node creation Python errors.
+- No callback errors on missing camera/path.
+- No source/install drift between HDA UI and cook-time Python.
+
+Suggested grouping:
+
+- Output / Product.
+- Camera / Resolution.
+- Sampling.
+- Ray Depth / Path.
+- Lighting.
+- Volumes.
+- Filtering / Textures.
+- Clamping / Fireflies.
+- AOVs.
+- Advanced / Debug.
+
+## MoonRay Parameter Discovery
+
+Parameter discovery for this pass used Houdini 20.5 only. Houdini 21 behavior is intentionally out of scope.
+
+Sources inspected:
+
+- `/Applications/MoonRay/installs/openmoonray/coredata/SceneVariables.json`
+- `/Applications/MoonRay/installs/openmoonray/coredata/RenderOutput.json`
+- `/Applications/MoonRay/installs/openmoonray/plugin/houdini/soho/parameters/HdMoonrayRendererPlugin_Global.ds`
+- `moonray/hydra/hdMoonray/lib/hydramoonray/RenderSettings.cc`
+- `moonray/hydra/hdMoonray/lib/hydramoonray/RenderBuffer.cc`
+- `moonray/hydra/hdMoonray/lib/hydramoonray/RenderDelegate.cc`
+- `moonray/moonray_dcc_plugins/houdini/python3.11libs/moonray_render_settings.py`
+- The generated `Lop::DW_MOONRAY::moonrayrendersettings::1` parameter template.
+- Houdini 20.5 `rendersettings`, `karmarenderproperties`, `usdrender_rop`, and `usdrender` parameter templates through HOM.
+
+Inventory counts:
+
+- `SceneVariables.json`: 112 attributes.
+- `RenderOutput.json`: 37 attributes.
+- Current custom MoonRay Render Settings LOP: 50 curated SceneVariable parameters plus default RenderSettings, RenderProduct, productName, productType, and Beauty RenderVar authoring for H20.5 disk output. The `aov_beauty` internal parameter is preserved; disabling it is diagnostic only.
+
+Method:
+
+- Use `SceneVariables.json` as the authoritative MoonRay type/default/enum source for RDL `SceneVariables`.
+- Use `HdMoonrayRendererPlugin_Global.ds` as the Houdini 20.5 UI grouping/label/help source where it exposes global render settings.
+- Use `RenderSettings.cc` to prove the supported USD render-settings path: `moonray:sceneVariable:<name>` or `sceneVariable_<name>` on the RenderSettings prim, excluding `camera`, `motion_steps`, `enable_motion_blur`, `layer`, `image_width`, and `image_height`.
+- Use USD Render docs to decide whether a setting belongs on `RenderSettings`, `RenderProduct`, or `RenderVar`.
+- Use `RenderBuffer.cc` and `RenderOutput.json` to classify AOV/output settings. Expose only the native and material/denoise outputs with production-filled proof; keep unproven material candidates plus LPE/light, visibility, primitive-attribute, Cryptomatte, auxiliary, and motion-vector AOV families deferred.
+
+Important boundary:
+
+Not every MoonRay parameter belongs in this LOP. This node authors a Solaris render contract plus curated MoonRay global renderer settings. Geometry, light, camera-prim, and material/shader settings remain outside this node even if they use `moonray:*` names elsewhere.
+
+## Parameter Inventory
+
+This table is a summarized inventory of the parameters relevant to the MoonRay Render Settings LOP decision. The complete raw discovery set is the 112 `SceneVariables` plus 37 `RenderOutput` attributes listed in the metadata files above.
+
+| Source | Raw name | Label | Type | Default | Menu/range | Docs/help | MoonRay/RDL target | USD location | Current custom LOP status | Recommended UI status | Recommended tab | Notes |
+|--------|----------|-------|------|---------|------------|-----------|--------------------|--------------|---------------------------|-----------------------|-----------------|-------|
+| SceneVariables.json | `sampling_mode` | Sampling Mode | Int enum | `uniform=0` | `uniform=0`, `adaptive=2` | Controls uniform/adaptive sampling. | SceneVariables | RenderSettings prim | exposed/authored as token menu | expose main UI; keep H20.5 token/int validation note | Sampling | RDLA prints enum token; metadata type is Int. |
+| SceneVariables.json | `light_sampling_mode` | Light Sampling Mode | Int enum | `uniform=0` | `uniform=0`, `adaptive=1` | Controls light sampling scheme. | SceneVariables | RenderSettings prim | exposed/authored as token menu | expose main UI | Sampling | RDLA-proven in current prototype. |
+| SceneVariables.json | `light_sampling_quality` | Light Sampling Quality | Float | `0.5` | `0..1` artist range | Adaptive light sampling quality. | SceneVariables | RenderSettings prim | newly exposed | expose main UI | Sampling | Disabled unless Light Sampling Mode is adaptive. |
+| SceneVariables.json | `pixel_samples` | Pixel Samples | Int | `8` | positive int | Primary samples in uniform mode. | SceneVariables | RenderSettings prim | exposed | expose main UI | Sampling | Existing curated control. |
+| SceneVariables.json | `light_samples` | Light Samples | Int | `2` | positive int | Samples per light at primary intersection. | SceneVariables | RenderSettings prim | exposed | expose main UI | Sampling | Existing curated control. |
+| SceneVariables.json | `bsdf_samples` | BSDF Samples | Int | `2` | positive int | BSDF lobe samples. | SceneVariables | RenderSettings prim | exposed | expose main UI | Sampling | Existing curated control. |
+| SceneVariables.json | `bssrdf_samples` | BSSRDF Samples | Int | `2` | positive int | BSSRDF samples. | SceneVariables | RenderSettings prim | exposed | expose main UI | Sampling | Existing curated control. |
+| SceneVariables.json | `min_adaptive_samples` | Min Adaptive Samples | Int | `16` | positive int | Adaptive-only min samples. | SceneVariables | RenderSettings prim | exposed | expose main UI | Sampling | Disabled unless Sampling Mode is adaptive. |
+| SceneVariables.json | `max_adaptive_samples` | Max Adaptive Samples | Int | `4096` | positive int | Adaptive-only max samples. | SceneVariables | RenderSettings prim | exposed | expose main UI | Sampling | Disabled unless Sampling Mode is adaptive. |
+| SceneVariables.json | `target_adaptive_error` | Target Adaptive Error | Float | `10.0` | positive float | Adaptive target error. | SceneVariables | RenderSettings prim | exposed/RDLA-proven | expose main UI | Sampling | Keep float typed to avoid old long-long issue. |
+| SceneVariables.json | `lock_frame_noise` | Lock Frame Noise | Bool | `false` | toggle | Locks RNG seed across frames. | SceneVariables | RenderSettings prim | newly exposed | expose main UI | Sampling | Useful animation/render setting. |
+| SceneVariables.json | `batch_tile_order` | Batch Tile Order | Int enum | `morton=4` | tile order enum | Batch tile scheduling. | SceneVariables | RenderSettings prim | exposed/authored as token menu | expose main UI | Tile Order | RDLA enum tokens acceptable in current path. |
+| SceneVariables.json | `progressive_tile_order` | Progressive Tile Order | Int enum | `morton=4` | tile order enum | Progressive tile scheduling. | SceneVariables | RenderSettings prim | exposed/authored as token menu | expose main UI | Tile Order | Existing curated control. |
+| SceneVariables.json | `checkpoint_tile_order` | Checkpoint Tile Order | Int enum | `morton=4` | tile order enum | Checkpoint tile scheduling. | SceneVariables | RenderSettings prim | exposed/authored as token menu | expose main UI | Tile Order | Existing curated control; checkpoint controls otherwise deferred. |
+| SceneVariables.json | `max_depth` family | Max Ray Depth family | Int | metadata defaults | positive int | Ray/path depth limits. | SceneVariables | RenderSettings prim | exposed | expose main UI | Ray Depth / Path | Includes diffuse/glossy/mirror/presence/hair/volume. |
+| SceneVariables.json | `max_subsurface_per_path` | Max Subsurface Per Path | Int | `1` | positive int | Subsurface path limit. | SceneVariables | RenderSettings prim | exposed | expose main UI | Ray Depth / Path | Existing curated control. |
+| SceneVariables.json | `russian_roulette_threshold` | Russian Roulette Threshold | Float | `0.0375` | positive float | Path continuation threshold. | SceneVariables | RenderSettings prim | exposed | expose main UI | Ray Depth / Path | Existing curated control. |
+| SceneVariables.json | `transparency_threshold` | Transparency Threshold | Float | `1.0` | positive float | Transparency stop threshold. | SceneVariables | RenderSettings prim | exposed | expose main UI | Ray Depth / Path | Existing curated control. |
+| SceneVariables.json | `presence_threshold` | Presence Threshold | Float | `0.999` | positive float | Presence stop threshold. | SceneVariables | RenderSettings prim | exposed | expose main UI | Ray Depth / Path | Existing curated control. |
+| SceneVariables.json | `presence_quality` | Presence Quality | Float | `0.75` | positive float | Stochastic presence threshold. | SceneVariables | RenderSettings prim | exposed | expose main UI | Ray Depth / Path | Existing curated control. |
+| SceneVariables.json | `disable_optimized_hair_sampling` | Disable Optimized Hair Sampling | Bool | `false` | toggle | Forces independent hair BSDF lobe sampling. | SceneVariables | RenderSettings prim | newly exposed | expose Advanced | Advanced / Debug | Useful but not core artist first-pass. |
+| SceneVariables.json | `sample_clamping_value` | Sample Clamping Value | Float | `10.0` | positive float | Radiance sample clamp. | SceneVariables | RenderSettings prim | exposed | expose main UI | Clamping / Fireflies | Existing curated control. |
+| SceneVariables.json | `sample_clamping_depth` | Sample Clamping Depth | Int | `1` | positive int | Clamp after depth. | SceneVariables | RenderSettings prim | exposed | expose main UI | Clamping / Fireflies | Existing curated control. |
+| SceneVariables.json | `roughness_clamping_factor` | Roughness Clamping Factor | Float | `0.0` | `0..10` artist range | Indirect roughness clamp/firefly reduction. | SceneVariables | RenderSettings prim | exposed/RDLA-proven | expose main UI | Clamping / Fireflies | Mirrored from generic MoonRay tab. |
+| SceneVariables.json | `volume_*` curated group | Volume settings | Float/Int/enum | metadata defaults | metadata enums | Global volume quality/overlap/indirect settings. | SceneVariables | RenderSettings prim | exposed | expose main UI | Volumes | Artist-useful volume group only; deep output separate. |
+| SceneVariables.json | `texture_blur`, `pixel_filter_width`, `pixel_filter` | Filtering / Textures | Float/enum | metadata defaults | metadata enum | Texture/pixel filtering. | SceneVariables | RenderSettings prim | exposed | expose main UI | Filtering / Textures | Existing curated controls. |
+| SceneVariables.json | `enable_dof` | Enable DOF | Bool | `true` | toggle | Global DOF enable. | SceneVariables | RenderSettings prim | exposed/RDLA-proven | expose main UI | Global Toggles | Camera focus/aperture remain camera prim settings. |
+| SceneVariables.json | `enable_displacement`, `enable_subsurface_scattering`, `enable_shadowing`, `enable_presence_shadows`, `lights_visible_in_camera`, `propagate_visibility_bounce_type`, `shadow_terminator_fix` | Global toggles | Bool/enum | metadata defaults | metadata enum | Global production toggles. | SceneVariables | RenderSettings prim | exposed | expose main UI | Global Toggles | Keep curated; do not include all debug/internal toggles. |
+| SceneVariables.json | `image_width`, `image_height` | Image dimensions | Int | `1920`, `1080` | n/a | Image dimensions. | SceneVariables | do not author here | not exposed | do not include in this LOP | n/a | Excluded by `RenderSettings.cc`; use USD RenderSettings resolution. |
+| SceneVariables.json | `scene_scale` | Scene Scale | Float | `0.01` | n/a | World unit scale. | SceneVariables | do not author here | not exposed | document only | n/a | Unit-policy work deferred. |
+| SceneVariables.json | `enable_motion_blur`, `motion_steps`, `fps`, `slerp_xforms` | Motion blur settings | Bool/Float/Vector | metadata defaults | n/a | Motion sampling. | SceneVariables | unknown/special-case | hidden | hide/defer | n/a | `enable_motion_blur` and `motion_steps` are special-cased/excluded in hdMoonRay. |
+| SceneVariables.json | checkpoint/resume/deep settings | Checkpoint/deep output | mixed | metadata defaults | mixed | Output/deep/checkpoint internals. | SceneVariables | RenderSettings prim or output workflow | hidden | hide/defer | n/a | Needs separate render execution/deep/checkpoint pass. |
+| SceneVariables.json | `output_file`, `primary_aov` | MoonRay native output linkage | String/SceneObject* | metadata defaults | n/a | Native MoonRay output path/AOV linkage. | RenderOutput/SceneVariables | do not author here | hidden | do not include in this LOP | n/a | Use USD RenderProduct.productName and RenderVars. |
+| RenderOutput.json / RenderBuffer.cc | `alpha`, `depth`, `Z`, `N`, `Ng`, `P`, `Wp`, `St`, `weight` | Native RenderOutput/state-variable AOVs | mixed | off in UI | fixed native mappings | AOV/output realization. | RenderOutput | RenderVar prim / backend output path | exposed as opt-in native set | production filled proof exists for this set | AOVs | Broader AOV families remain deferred. |
+| RenderOutput.json | `material_aov`, `lpe`, `visibility_aov`, primitive attributes, Cryptomatte, auxiliary outputs, motion vectors | Deferred AOV families | mixed | metadata defaults | metadata enums | AOV/output realization. | RenderOutput | RenderVar prim / backend output path | hidden | needs separate production proof | future AOV pass | Do not expose from guessed names. |
+| hdMoonRay delegate | `rdlOutput` | Debug RDL/RDLA Output | String | blank | file path | Debug scene export. | delegate/debug setting | delegate/debug setting | exposed debug-only | expose Debug | Advanced / Debug | Not final image output. |
+| Geometry prim attrs | `moonray:mesh_resolution` etc. | Geometry settings | mixed | n/a | n/a | Geometry tessellation/subdivision. | RDL geometry | geometry prim | not applicable | do not include in this LOP | n/a | Belongs to Render Geometry Settings. |
+| Light prim attrs | per-light `moonray:*` | Light settings | mixed | n/a | n/a | Per-light MoonRay attrs. | RDL light | light prim | not applicable | do not include in this LOP | n/a | Belongs to light-specific UI. |
+| Material/shader attrs | shader inputs | Material settings | mixed | n/a | n/a | Material behavior. | RDL material | material/shader prim | not applicable | do not include in this LOP | n/a | Belongs to material networks. |
+
+## Exposed Parameters
+
+Current exposed/custom-authored settings after discovery:
+
+| Tab | Label | Parm name | USD attr / relationship | USD type | Default | Source for type/default | Validation status |
+|-----|-------|-----------|-------------------------|----------|---------|-------------------------|------------------|
+| Output / Product | RenderSettings Primitive Path | `render_settings_prim` | RenderSettings prim path | path | `/Render/rendersettings` | H20.5 Generic/Karma pattern | validated previously |
+| Output / Product | RenderProducts Parent Primitive Path | `render_products_parent_prim` | RenderProduct parent path | path | `/Render/Products` | H20.5 Karma pattern | validated previously |
+| Output / Product | RenderVars Parent Primitive Path | `render_vars_parent_prim` | RenderVar parent path | path | `/Render/Products/Vars` | H20.5 Karma pattern | validated previously |
+| Output / Product | Output Picture | `product_name` | `RenderProduct.productName` | token | `$HIP/render/$HIPNAME.$OS.\$F4.exr` | USD RenderProduct / H20.5 Karma pattern | Escaped frame token prevents unintended LOP time dependency while preserving frame expansion for ROP/husk. |
+| Camera / Resolution | Camera | `camera` | `RenderSettings.camera` relationship | rel | `/cameras/camera1` | H20.5 Karma pattern | validated previously |
+| Camera / Resolution | Resolution Mode | `resolution_mode_note` | UI note only | n/a | Manual Resolution | H20.5 lifecycle cleanup decision | computed modes intentionally removed |
+| Camera / Resolution | Resolution | `resolution` | `RenderSettings.resolution` | `int2` | `1920, 1080` | USD RenderSettings | validated previously |
+| Output / Product | Beauty RenderVar / Disk Output Path | `aov_beauty` | `RenderProduct.orderedVars` + Beauty RenderVar | RenderVar | enabled | H20.5 `husk`/EXR evidence | Default disk-output path validated; disabled state is diagnostic only |
+| Sampling | Sampling Mode | `sceneVariable_sampling_mode` | `moonray:sceneVariable:sampling_mode` | token-authored enum | `uniform` | SceneVariables metadata | RDLA token path proven for enum style |
+| Sampling | Light Sampling Mode | `sceneVariable_light_sampling_mode` | `moonray:sceneVariable:light_sampling_mode` | token-authored enum | `uniform` | SceneVariables metadata | RDLA-proven |
+| Sampling | Light Sampling Quality | `sceneVariable_light_sampling_quality` | `moonray:sceneVariable:light_sampling_quality` | float | `0.5` | SceneVariables metadata | RDLA-proven; disabled unless Light Sampling Mode is adaptive |
+| Sampling | Pixel/Light/BSDF/BSSRDF Samples | `sceneVariable_*_samples` | `moonray:sceneVariable:*` | int | metadata defaults | SceneVariables metadata | validated for authoring; Pixel Samples disabled unless Sampling Mode is uniform |
+| Sampling | Min/Max Adaptive Samples, Target Adaptive Error | `sceneVariable_min_adaptive_samples`, etc. | `moonray:sceneVariable:*` | int/float | metadata defaults | SceneVariables metadata | validated for authoring/toggle updates; adaptive controls disabled unless Sampling Mode is adaptive |
+| Sampling | Lock Frame Noise | `sceneVariable_lock_frame_noise` | `moonray:sceneVariable:lock_frame_noise` | bool | false | SceneVariables metadata | newly added; needs RDLA validation |
+| Tile Order | Batch/Progressive/Checkpoint Tile Order | `sceneVariable_*_tile_order` | `moonray:sceneVariable:*` | token-authored enum | `morton` | SceneVariables metadata | validated previously for authored attrs |
+| Ray Depth / Path | Ray depth/path controls | `sceneVariable_max_*`, thresholds | `moonray:sceneVariable:*` | int/float | metadata defaults | SceneVariables metadata | validated previously for representative attrs |
+| Clamping / Fireflies | Sample/Roughness clamps | `sceneVariable_sample_clamping_*`, `sceneVariable_roughness_clamping_factor` | `moonray:sceneVariable:*` | int/float | metadata defaults | SceneVariables metadata / generic MoonRay tab | roughness RDLA-proven |
+| Volumes | Volume group | `sceneVariable_volume_*` | `moonray:sceneVariable:*` | int/float/token | metadata defaults | SceneVariables metadata / Global.ds | authored; representative validation needed |
+| Filtering / Textures | Texture blur / pixel filter controls | `sceneVariable_texture_blur`, etc. | `moonray:sceneVariable:*` | float/token | metadata defaults | SceneVariables metadata / Global.ds | authored; representative validation needed |
+| Global Toggles | Production toggles | `sceneVariable_enable_*`, etc. | `moonray:sceneVariable:*` | bool/token | metadata defaults | SceneVariables metadata / Global.ds | `enable_dof` RDLA-proven |
+| Advanced / Debug | Disable Optimized Hair Sampling | `sceneVariable_disable_optimized_hair_sampling` | `moonray:sceneVariable:disable_optimized_hair_sampling` | bool | false | SceneVariables metadata | newly added; needs RDLA validation |
+| Advanced / Debug | Debug RDL/RDLA Output | `rdlOutput` | `rdlOutput` | string | blank | hdMoonRay delegate setting | validated previously |
+
+## Hidden / Deferred Parameters
+
+| Parameter/group | Reason | Correct authoring location | Future work |
+|-----------------|--------|----------------------------|-------------|
+| `image_width`, `image_height` | Excluded in hdMoonRay `RenderSettings.cc`; dimensions are driven by USD RenderSettings/Hydra framing. | `RenderSettings.resolution`, not `moonray:sceneVariable:*` | none for this LOP |
+| `scene_scale` | Unit policy is not settled; broad risk to lights, SSS, camera, materials. | renderer/unit-policy task | dedicated units pass |
+| `motion_steps`, `enable_motion_blur`, `fps`, `slerp_xforms` | hdMoonRay has special handling/exclusions; motion blur path not validated for this UI. | future motion blur/settings pass | audit and implement separately |
+| Checkpoint/resume settings | Execution/output behavior, not first-pass RenderSettings authoring. | future ROP/execution workflow | checkpoint pass |
+| Deep output settings | Deep output is AOV/output-system work. | future AOV/deep pass | defer |
+| Texture cache/file handles | Performance/cache policy and environment-sensitive. | Advanced only after validation | defer |
+| `output_file`, `primary_aov`, `two_stage_output` | Native MoonRay output wiring conflicts with USD RenderProduct model unless carefully designed. | RenderProduct/ROP/backend output design | defer |
+| `machine_id`, `num_machines`, `task_distribution_type`, `athena_debug` | Arras/internal/debug. | backend/Arras context | do not include |
+| `max_geometry_resolution`, `enable_max_geometry_resolution`, `fast_geometry_update` | Geometry/procedural behavior, not artist render contract. | geometry/procedural settings | document only |
+| Deferred RenderOutputs/AOVs | Unproven material candidates plus LPE/light, visibility, primitive-attribute, Cryptomatte, auxiliary, display-filter, and motion-vector paths are not part of the exposed proven set. | RenderVar + backend AOV pipeline | future AOV pass |
+
+## Geometry / Camera / Light / Material Boundaries
+
+- `moonray:mesh_resolution` is geometry-level and must not be exposed in this Render Settings LOP.
+- Per-light MoonRay attributes belong on light prims or light-specific tooling.
+- Material/shader attributes belong in material networks.
+- Camera focal/aperture/focus settings belong on camera prims unless Houdini 20.5 native/generic behavior proves a different RenderSettings-level path.
+- The global `enable_dof` SceneVariable is included because it is a real SceneVariable and RDLA-proven through `moonray:sceneVariable:enable_dof`; it does not replace camera prim DOF controls.
+
+## Final Tab Architecture
+
+| Final tab | Purpose | Parameters to include | Parameters explicitly excluded | Notes |
+|----------|---------|-----------------------|-------------------------------|-------|
+| Output / Product | USD render contract and output path | RenderSettings path, products parent, vars parent, output picture, optional advanced product/beauty names | Native MoonRay `output_file`, `primary_aov` | RenderProduct.productName remains final image output source. |
+| Camera / Resolution | Render camera and offline resolution | Camera, manual resolution note, resolution | computed width/height modes, `image_width`, `image_height`, camera lens/focus attrs | Uses USD RenderSettings resolution and camera rel. |
+| Sampling | Main sampling controls | sampling mode, light sampling mode/quality, sample counts, adaptive controls, lock frame noise | unrelated debug RNG/internal controls | Adaptive controls disabled when inactive. |
+| Ray Depth / Path | Path limits and thresholds | max depth family, subsurface per path, russian roulette, transparency/presence threshold/quality | geometry resolution limits | SceneVariables only. |
+| Lighting | Global lighting behavior if it remains useful as a separate tab | currently no separate tab; light sampling lives in Sampling and lights visibility in Global Toggles | per-light attrs | Keep per-light UI elsewhere. |
+| Volumes | Global volume controls | volume quality/shadow/illumination/opacity/overlap/factors/indirect samples | deep output settings | Uses useful volume group from metadata/DS. |
+| Filtering / Textures | Texture/pixel filtering | texture blur, pixel filter width/type | texture cache/file handles for now | Cache controls deferred. |
+| Clamping / Fireflies | Firefly reduction | sample clamp value/depth, roughness clamping factor | none currently | Roughness clamp mirrored from generic MoonRay tab. |
+| AOVs | Artist AOV checkboxes | alpha, depth, Z, N, Ng, P, Wp, St, weight | material/LPE/light/visibility/primitive-attribute/Cryptomatte/motion-vector families | Native set only; all toggles default off. |
+| Advanced / Debug | Troubleshooting/low-level controls | disable optimized hair sampling, debug RDL/RDLA output | Arras/internal/debug dumps and default Beauty disk-output controls | Keep sparse. |
+
+## What Still Remains
+
+- Broader AOV backend/UI work beyond the first native RenderBuffer set.
+- Possible separate geometry settings LOP or expanded geometry tooling.
+- Possible light/material-specific UI passes.
+- Production filled Beauty proof, distinct from output-file smoke proof.
+- Install/runtime tooling to prevent HDA UI and cook-time Python drift.
+
+## HDA Lifecycle and Node Graph Mutation Policy
+
+The MoonRay Render Settings LOP has a small amount of node-graph automation: when the LOP is created, it creates a connected LOP `usdrender_rop` configured for `HdMoonrayRendererPlugin`. This lifecycle policy documents where node graph mutation is allowed and where it is forbidden.
+
+Validation target:
+
+```bash
+/Applications/Houdini/Houdini20.5.584/Frameworks/Houdini.framework/Versions/20.5/Resources/bin/hython \
+  /Applications/MoonRay/openmoonray/moonray/moonray_dcc_plugins/houdini/tests/dev_validate_moonray_render_settings_lop.py
+```
+
+Current validation summary:
+
+```text
+PASS=44
+FAIL=0
+SKIP=6
+```
+
+Skipped tests:
+
+- `raw_hom_copy_lop_only`: Houdini HOM copy of an existing node does not run `OnCreated`; press the repair button on the copied LOP.
+- `moonray_menu_tool_creation_path`: requires graphical Houdini 20.5 `hou.ui` interaction; hython cannot exercise the real MoonRay Tab/shelf UI path.
+- `digital_assets_creation_path`: requires graphical Houdini 20.5 Tab menu interaction; hython can report the operator definition but cannot click the Digital Assets entry.
+- `mixed_menu_path_two_node_sharing`: requires graphical Houdini 20.5 creation from both menu presentation paths.
+- `undo_redo_creation`: Hython does not provide a reliable UI undo/redo event test for this lifecycle; validate manually in Houdini UI if needed.
+- `rdla_scenevariable_receipt`: The optional RDLA smoke test timed out in the dev harness. This is not a lifecycle failure and should be rerun manually when render/RDLA timing is stable.
+
+### Python Entry Points
+
+| Entry point | File/location | When it runs | What it mutates | Safe? | Notes |
+|------------|---------------|--------------|-----------------|-------|-------|
+| HDA `OnCreated` | `Lop::DW_MOONRAY::moonrayrendersettings::1.hda` section `OnCreated` | Fresh MoonRay Render Settings LOP creation | Creates or updates one owned connected LOP `usdrender_rop` | Yes | Does not run on file load or HDA definition reload in H20.5 validation. |
+| `author_from_node()` | `houdini/python3.11libs/moonray_render_settings.py` | HDA Python cook/export | USD stage only | Yes | Must not create, delete, rename, or wire Houdini nodes. |
+| `create_or_update_usd_render_rop()` | `houdini/python3.11libs/moonray_render_settings.py` | HDA `OnCreated` and explicit repair button | Owned LOP `usdrender_rop` only | Yes | Idempotent; preserves unrelated ROPs. |
+| `resolution_mode_note` label | generated HDA parameter | Display only | Nothing | Yes | Computed resolution mode callbacks were removed; manual resolution only. |
+| resolution preset callback | generated HDA parameter tag | Resolution preset menu use | Resolution parameter values only | Yes | No ROP creation. |
+| `Create / Update USD Render ROP` button callback | generated HDA parameter tag | Explicit user button press | Owned LOP `usdrender_rop` only | Yes | Repair/update affordance. |
+| `MoonRayTools.shelf` tool | `houdini/toolbar/MoonRayTools.shelf` | Shelf/tab tool creation | Creates MoonRay Render Settings LOP via `loptoolutils.genericTool` | Yes | Shelf/tool behavior only; not cook-time behavior. |
+| Module import | `moonray_render_settings.py` | Python import | Nothing | Yes | Import-time code must remain side-effect free. |
+| `regenerate_hda()` | `moonray_render_settings.py` | Explicit developer regeneration | Creates temporary source node and HDA definition | Yes for dev only | Not a runtime artist action. |
+
+### Allowed Mutation Points
+
+- HDA `OnCreated` may create one owned LOP `usdrender_rop` for a fresh MoonRay Render Settings LOP.
+- The explicit `Create / Update USD Render ROP` button may create, repair, or reconnect the owned LOP `usdrender_rop`.
+- Shelf/tool creation may create the MoonRay Render Settings LOP through Houdini's `loptoolutils.genericTool`.
+
+### Forbidden Mutation Points
+
+- Cook/export must not create, delete, rename, connect, or rewire Houdini nodes.
+- Ordinary parameter changes must not create ROPs.
+- File load must not create extra ROPs.
+- HDA definition reload must not create extra ROPs.
+- Import-time code must not mutate the scene.
+- Unrelated user-created `usdrender_rop` nodes must never be overwritten.
+
+### Owned USD Render ROP Model
+
+The owned ROP is a LOP `usdrender_rop`, not an `/out/usdrender` node.
+
+Owned ROP values:
+
+```text
+renderer = HdMoonrayRendererPlugin
+loppath = opinput(".", 0)
+rendersettings = chs("<owning MoonRay Render Settings LOP>/render_settings_prim")
+outputimage raw string = `chs("<owning MoonRay Render Settings LOP>/product_name")`
+```
+
+Ownership userData keys:
+
+```text
+moonray_render_settings_lop = <owning LOP path>
+moonray_render_settings_operator = Lop::DW_MOONRAY::moonrayrendersettings::1
+moonray_render_settings_lop_session_id = <owning LOP session id>
+```
+
+The helper uses the owner path, owner operator type, and session id to identify the owned ROP. The session id lets repair recover after renaming the owning LOP during the same Houdini session. A comment is also written on the ROP for human inspection.
+
+### Operator Registration / Menu Entry Policy
+
+Houdini 20.5 HOM sees one MoonRay Render Settings LOP operator definition:
+
+| Menu entry | Operator type | Label | Definition path | Source mechanism | Creates node type | Stale/duplicate? | Recommended action |
+|------------|---------------|-------|-----------------|------------------|-------------------|------------------|--------------------|
+| Digital Assets entry | `Lop::DW_MOONRAY::moonrayrendersettings::1` | MoonRay Render Settings | `/Applications/MoonRay/installs/openmoonray/plugin/houdini/otls/Lop::DW_MOONRAY::moonrayrendersettings::1.hda` | Houdini generic HDA fallback/category listing | Same operator type | Not a second definition | Document; do not delete. |
+| MoonRay shelf/tab entry | `Lop::DW_MOONRAY::moonrayrendersettings::1` | MoonRay Render Settings | same installed HDA path | `MoonRayTools.shelf` using `loptoolutils.genericTool` | Same operator type | Intended renderer-specific tool path | Keep. |
+
+The observed `Digital Assets` and `MoonRay` entries are menu presentation paths for the same installed operator definition, not two separate MoonRay Render Settings operators. Do not remove the generic Digital Assets entry blindly. Users should prefer the MoonRay shelf/tab entry, but both creation paths must create the same operator type and should be lifecycle-safe.
+
+Known installed/generated HDA paths observed during this work:
+
+```text
+/Applications/MoonRay/installs/openmoonray/plugin/houdini/otls/Lop::DW_MOONRAY::moonrayrendersettings::1.hda
+/Applications/MoonRay/source/openmoonray/moonray/moonray_dcc_plugins/houdini/otls/Lop::DW_MOONRAY::moonrayrendersettings::1.hda
+```
+
+The H20.5 validation runtime used the installed plugin HDA path.
+
+### USD Render ROP Initial Creation Policy
+
+Initial creation and the repair button use the same idempotent helper, `create_or_update_usd_render_rop()`.
+
+In graphical Houdini, `OnCreated` schedules only one deferred helper call through `hdefereval.executeDeferred`. The deferred pass exists because shelf/tool creation can finalize node naming, wiring, and placement after the HDA `OnCreated` hook starts. This avoids creating an incorrect intermediate ROP and then repairing it. The deferred call uses the same idempotent helper and the owning node session id, so it creates the final owned ROP in the same state as the explicit repair button. Hython does not provide `hdefereval`, so H20.5 command-line validation uses the immediate fallback path only.
+
+Manual graphical Houdini 20.5 validation is still required before claiming the MoonRay shelf/menu path and the Digital Assets menu path are fully fixed. The command-line harness proves direct HDA/HOM behavior and records UI-only creation paths as skipped, not passed.
+
+Expected initial creation behavior:
+
+- Create exactly one owned connected LOP `usdrender_rop`.
+- Connect it below the owning MoonRay Render Settings LOP.
+- Set `renderer = HdMoonrayRendererPlugin`.
+- Set `loppath` to `opinput(".", 0)`, normalized by validation to the owning MoonRay Render Settings LOP path.
+- Set `rendersettings` to `chs("<owning LOP>/render_settings_prim")`.
+- Set `outputimage` to the raw string `` `chs("<owning LOP>/product_name")` `` so the owned ROP follows the LOP output path without creating expression keyframes.
+- Do not create `/out/usdrender`.
+- Do not overwrite unrelated `usdrender_rop` nodes.
+
+The repair button is only a repair/update affordance. It should not be required after normal creation. H20.5 hython validation confirms initial creation already matches repair behavior for direct HDA node creation; manual UI validation should still be used for shelf/menu presentation quirks.
+
+Current validation also confirms:
+
+- ROP graph comparisons include `moonray_render_settings_lop`, `moonray_render_settings_operator`, and `moonray_render_settings_lop_session_id`.
+- Two MoonRay Render Settings LOPs do not share the same owned `usdrender_rop`.
+- Beauty remains the default disk-output RenderVar. The AOV tab exposes only the first native, production-filled RenderBuffer set with toggles defaulting off.
+- Computed resolution mode parms and `loputils.computeResolutionParameter` / `loputils.updateResolutionParameters` callback references are absent.
+- `image_width` and `image_height` are absent from the curated `SCENE_VARIABLES` list and are not authored as custom USD SceneVariables.
+
+### Frame Range and ROP Handoff
+
+SideFX USD Render ROP documentation separates authored USD time metadata from
+the ROP's actual render frame range. A layer can contain `startTimeCode`,
+`endTimeCode`, `framesPerSecond`, and `timeCodesPerSecond`, but the USD Render
+ROP still needs its `Valid Frame Range`/`trange` mode to request a sequence from
+`husk`.
+
+The owned MoonRay `usdrender_rop` keeps the native USD Render ROP default of
+rendering the current frame. To render a sequence, set the ROP to a frame-range
+mode, such as `Render Specific Frame Range`, or to the stage-driven mode when
+that is the desired native USD Render ROP behavior.
+
+H20.5 headless validation using the owned ROP, the committed output-path wiring,
+and an existing proven MoonRay USD scene rendered frames `1-5` in explicit frame
+range mode to:
+
+```text
+/tmp/moonray_frame_range_existing_usd/render/moonray_seq.0001.exr
+/tmp/moonray_frame_range_existing_usd/render/moonray_seq.0002.exr
+/tmp/moonray_frame_range_existing_usd/render/moonray_seq.0003.exr
+/tmp/moonray_frame_range_existing_usd/render/moonray_seq.0004.exr
+/tmp/moonray_frame_range_existing_usd/render/moonray_seq.0005.exr
+```
+
+All five files were valid nonconstant RGB float EXRs. The render launched a
+separate `syncId:1` render per frame and did not reproduce the reported
+single-render `syncId:1`, resolution-change, `syncId:2/3/4` restart sequence.
+That restart sequence remains a GUI/runtime observation to investigate with a
+normal H20.5 session, especially with viewport/IPR active versus inactive.
+
+Stage-driven range mode was also checked against
+`/Users/j7s/houdini-projects/simple-render-test/stage/stagetest-2.usda`, whose
+root layer metadata contains `startTimeCode = 1` and `endTimeCode = 5`. With
+the owned ROP set to `trange = stage`, H20.5 rendered frames `1-5`, wrote no
+frames `6-7`, and produced valid nonconstant RGB float EXRs.
+
+### EXR Metadata Observations
+
+Current MoonRay/Husk output still records only generic color metadata such as
+`oiio:ColorSpace = "Linear"` for the tested EXRs. It does not currently prove
+specific ACEScg, Linear Rec.709, or Linear Rec.2020 EXR chromaticities/OCIO
+metadata in the DCC wrapper layer.
+
+Several tested EXRs also contain suspicious `renderTime_s` and `renderMemory_s`
+values, such as render times far longer than the observed render wall time. Local
+source inspection points to MoonRay/Husk/image-writing metadata paths rather than
+the custom DCC ROP wrapper, so this audit records the issue but does not patch it
+in the DCC layer.
+
+### Lifecycle Scenario Summary
+
+| Scenario | Result | Notes |
+|----------|--------|-------|
+| Create one MoonRay Render Settings LOP | PASS | One owned connected `usdrender_rop` is created. |
+| Click repair button twice | PASS | No duplicate ROPs. |
+| Initial graph equals post-repair graph | PASS | Direct HDA creation matches repair state, including placement. |
+| Create two MoonRay Render Settings LOPs | PASS | Two distinct owned ROPs. |
+| Settings nodes share one ROP | PASS | They do not share; each settings node owns one distinct ROP. |
+| Rename owning LOP, then repair | PASS | Owned ROP updates by session id. |
+| Rename owned `usdrender_rop`, then repair | PASS | Renamed ROP is preserved and updated in place. |
+| Delete owned `usdrender_rop`, then repair | PASS | Owned ROP is recreated. |
+| Disconnect owned `usdrender_rop`, then repair | PASS | Owned ROP is rewired. |
+| Raw HOM copy of LOP only | SKIP/limitation | `OnCreated` does not run for raw HOM copy; repair is required. |
+| Duplicate LOP+ROP pair | PASS with limitation | Non-destructive; copied ROP may have stale ownership until repair refreshes it. |
+| Unrelated colliding ROP | PASS | Existing unrelated Karma/usdrender ROP is preserved. |
+| Fake/stale ownership ROP | PASS | Stale/fake ROP is preserved; new owned ROP is created. |
+| Save/reopen file | PASS | No extra ROPs are created. |
+| HDA definition reload | PASS | No extra ROPs are created. |
+| Parameter change + cook | PASS | No node graph mutation. |
+| `/out/usdrender` creation | PASS | None created. |
+| MoonRay menu/tool path | SKIP | Requires graphical Houdini 20.5. |
+| Digital Assets menu path | SKIP | Requires graphical Houdini 20.5. |
+| One node from each menu path | SKIP | Requires graphical Houdini 20.5. |
+| Undo/redo | SKIP | Needs manual UI validation; not reliable in hython. |
+
+### MoonRayTools.shelf Justification
+
+The `MoonRayTools.shelf` change is intentional and should be kept. It updates shelf/tab creation behavior so the tool is available in LOP viewer/network contexts and creates the node with Houdini's `loptoolutils.genericTool`, matching Solaris tool conventions better than direct `kwargs["node"].createNode(...)`.
+
+This shelf change:
+
+- Affects shelf/tab creation only.
+- Is not cook-time behavior.
+- Is not backend/AOV behavior.
+- Is not responsible for `usdrender_rop` mutation during cook.
+
+### Known Accepted Limitations
+
+- Raw HOM copy/paste of only the MoonRay Render Settings LOP does not auto-create a ROP because `OnCreated` is not run; press the repair button.
+- Duplicating a LOP+ROP pair can leave stale ownership userData on the copied ROP until repair is pressed.
+- Undo/redo lifecycle behavior still needs manual UI validation.
+- MoonRay shelf/menu creation and Digital Assets menu creation still need real graphical Houdini 20.5 validation. Do not claim those menu paths are fully fixed from hython evidence alone.
+- These limitations are non-destructive and accepted for now.
+
+## Validation Checklist
+
+Future passes should validate:
+
+- [ ] Confirm Houdini 20.5 `hython` path.
+- [ ] Confirm Houdini 20.5 `husk` path.
+- [ ] Confirm `moonray_render_settings.__file__`.
+- [ ] Confirm SceneVariables count.
+- [ ] Confirm `enable_dof` is present.
+- [ ] Regenerate HDA from repo source.
+- [ ] Sync/install through a reproducible mechanism.
+- [ ] Launch a fresh normal Houdini 20.5 GUI session after install sync.
+- [ ] Confirm fresh GUI custom LOP defaults `aov_beauty` on and labels it `Beauty RenderVar / Disk Output Path`.
+- [ ] Confirm fresh GUI custom LOP viewport/IPR and USD Render ROP render with the default Beauty RenderVar enabled.
+- [ ] Export generic/native USD.
+- [ ] Export custom USD.
+- [ ] Diff RenderSettings/Product/Var.
+- [ ] Export RDLA.
+- [ ] Verify `enable_dof` in RDLA.
+- [ ] Verify `image_width` and `image_height` are not authored as USD SceneVariables.
+- [ ] Verify manual resolution.
+- [ ] Verify computed resolution modes remain removed.
+- [ ] Verify no computed resolution callback tags remain.
+- [ ] Verify USD Render ROP `renderer`, `loppath`, `rendersettings`, and `outputimage` wiring.
+- [ ] Verify RenderProduct `$F4` output path behavior.
+- [ ] Treat black/zero-filled renders as output-wiring evidence only, not filled-pixel Beauty/AOV proof.
diff --git a/houdini/otls/Lop::DW_MOONRAY::moonrayrendersettings::1.hda b/houdini/otls/Lop::DW_MOONRAY::moonrayrendersettings::1.hda
new file mode 100644
index 0000000..521a97f
Binary files /dev/null and b/houdini/otls/Lop::DW_MOONRAY::moonrayrendersettings::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::AttributeMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::AttributeMap::1.hda
index 48ef3d7..c176f1c 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::AttributeMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::AttributeMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::AxisAngleMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::AxisAngleMap::1.hda
index eefaec8..19450eb 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::AxisAngleMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::AxisAngleMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::BarnDoorLightFilter::1.hda b/houdini/otls/Vop::DW_MOONRAY::BarnDoorLightFilter::1.hda
new file mode 100644
index 0000000..dab0542
Binary files /dev/null and b/houdini/otls/Vop::DW_MOONRAY::BarnDoorLightFilter::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::BaseMaterial::1.hda b/houdini/otls/Vop::DW_MOONRAY::BaseMaterial::1.hda
index 11e8108..1e8b4b0 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::BaseMaterial::1.hda and b/houdini/otls/Vop::DW_MOONRAY::BaseMaterial::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::BaseVolume::1.hda b/houdini/otls/Vop::DW_MOONRAY::BaseVolume::1.hda
index ba16411..c5654e2 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::BaseVolume::1.hda and b/houdini/otls/Vop::DW_MOONRAY::BaseVolume::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::BlendDisplayFilter::1.hda b/houdini/otls/Vop::DW_MOONRAY::BlendDisplayFilter::1.hda
index 8950f08..ac9f457 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::BlendDisplayFilter::1.hda and b/houdini/otls/Vop::DW_MOONRAY::BlendDisplayFilter::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::BlendMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::BlendMap::1.hda
index 7edbff3..b6bf553 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::BlendMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::BlendMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::CheckerboardMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::CheckerboardMap::1.hda
index b78d672..b8bc6c9 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::CheckerboardMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::CheckerboardMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ClampDisplayFilter::1.hda b/houdini/otls/Vop::DW_MOONRAY::ClampDisplayFilter::1.hda
index bcac244..842d117 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ClampDisplayFilter::1.hda and b/houdini/otls/Vop::DW_MOONRAY::ClampDisplayFilter::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ClampMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::ClampMap::1.hda
index 45590bf..79546d5 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ClampMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::ClampMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ColorCorrectContrastMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::ColorCorrectContrastMap::1.hda
index 75015d8..ddc69b1 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ColorCorrectContrastMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::ColorCorrectContrastMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ColorCorrectDisplayFilter::1.hda b/houdini/otls/Vop::DW_MOONRAY::ColorCorrectDisplayFilter::1.hda
index 8ad319e..a5580ed 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ColorCorrectDisplayFilter::1.hda and b/houdini/otls/Vop::DW_MOONRAY::ColorCorrectDisplayFilter::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ColorCorrectGainOffsetMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::ColorCorrectGainOffsetMap::1.hda
index e53391c..1091a51 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ColorCorrectGainOffsetMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::ColorCorrectGainOffsetMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ColorCorrectGammaMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::ColorCorrectGammaMap::1.hda
index 7372c3a..a32e00f 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ColorCorrectGammaMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::ColorCorrectGammaMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ColorCorrectHsvMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::ColorCorrectHsvMap::1.hda
index b5b1d15..d1ebc40 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ColorCorrectHsvMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::ColorCorrectHsvMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ColorCorrectHueShiftMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::ColorCorrectHueShiftMap::1.hda
index 7588cad..ecd4d8f 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ColorCorrectHueShiftMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::ColorCorrectHueShiftMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ColorCorrectLegacyMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::ColorCorrectLegacyMap::1.hda
index 781d5ea..6323aa9 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ColorCorrectLegacyMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::ColorCorrectLegacyMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ColorCorrectMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::ColorCorrectMap::1.hda
index d99ea04..af36219 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ColorCorrectMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::ColorCorrectMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ColorCorrectNukeMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::ColorCorrectNukeMap::1.hda
index 5cbb1a6..8939bb1 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ColorCorrectNukeMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::ColorCorrectNukeMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ColorCorrectSaturationMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::ColorCorrectSaturationMap::1.hda
index e920c36..7625c85 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ColorCorrectSaturationMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::ColorCorrectSaturationMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ColorCorrectTMIMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::ColorCorrectTMIMap::1.hda
index 89912a0..7ed8b14 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ColorCorrectTMIMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::ColorCorrectTMIMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ColorRampLightFilter::1.hda b/houdini/otls/Vop::DW_MOONRAY::ColorRampLightFilter::1.hda
new file mode 100644
index 0000000..db7a44e
Binary files /dev/null and b/houdini/otls/Vop::DW_MOONRAY::ColorRampLightFilter::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::CombineDisplacement::1.hda b/houdini/otls/Vop::DW_MOONRAY::CombineDisplacement::1.hda
index 3df4ed0..ec2ca8b 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::CombineDisplacement::1.hda and b/houdini/otls/Vop::DW_MOONRAY::CombineDisplacement::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::CombineLightFilter::1.hda b/houdini/otls/Vop::DW_MOONRAY::CombineLightFilter::1.hda
new file mode 100644
index 0000000..50a8e0c
Binary files /dev/null and b/houdini/otls/Vop::DW_MOONRAY::CombineLightFilter::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::CombineNormalMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::CombineNormalMap::1.hda
index 22bb66f..57b34f4 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::CombineNormalMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::CombineNormalMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ConstantColorMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::ConstantColorMap::1.hda
index d7c1409..bbb2b09 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ConstantColorMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::ConstantColorMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ConstantDisplayFilter::1.hda b/houdini/otls/Vop::DW_MOONRAY::ConstantDisplayFilter::1.hda
index 29d087d..0d71122 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ConstantDisplayFilter::1.hda and b/houdini/otls/Vop::DW_MOONRAY::ConstantDisplayFilter::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ConstantScalarMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::ConstantScalarMap::1.hda
index d894050..383470e 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ConstantScalarMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::ConstantScalarMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ConvolutionDisplayFilter::1.hda b/houdini/otls/Vop::DW_MOONRAY::ConvolutionDisplayFilter::1.hda
index dc8641b..59d7329 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ConvolutionDisplayFilter::1.hda and b/houdini/otls/Vop::DW_MOONRAY::ConvolutionDisplayFilter::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::CookieLightFilter::1.hda b/houdini/otls/Vop::DW_MOONRAY::CookieLightFilter::1.hda
new file mode 100644
index 0000000..d9d8172
Binary files /dev/null and b/houdini/otls/Vop::DW_MOONRAY::CookieLightFilter::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::CookieLightFilter_v2::1.hda b/houdini/otls/Vop::DW_MOONRAY::CookieLightFilter_v2::1.hda
new file mode 100644
index 0000000..d486c7a
Binary files /dev/null and b/houdini/otls/Vop::DW_MOONRAY::CookieLightFilter_v2::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::CurvatureMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::CurvatureMap::1.hda
index c6061ec..4946876 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::CurvatureMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::CurvatureMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::CutoutVolume::1.hda b/houdini/otls/Vop::DW_MOONRAY::CutoutVolume::1.hda
index a0b8257..7762623 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::CutoutVolume::1.hda and b/houdini/otls/Vop::DW_MOONRAY::CutoutVolume::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::DebugMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::DebugMap::1.hda
index 8905753..2ac5377 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::DebugMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::DebugMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::DecayLightFilter::1.hda b/houdini/otls/Vop::DW_MOONRAY::DecayLightFilter::1.hda
new file mode 100644
index 0000000..6c141e4
Binary files /dev/null and b/houdini/otls/Vop::DW_MOONRAY::DecayLightFilter::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::DeformationMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::DeformationMap::1.hda
index e964981..95605f4 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::DeformationMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::DeformationMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::DirectionalMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::DirectionalMap::1.hda
index 23a5871..d230846 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::DirectionalMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::DirectionalMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::DiscretizeDisplayFilter::1.hda b/houdini/otls/Vop::DW_MOONRAY::DiscretizeDisplayFilter::1.hda
index 1d4dbe4..b5e7184 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::DiscretizeDisplayFilter::1.hda and b/houdini/otls/Vop::DW_MOONRAY::DiscretizeDisplayFilter::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::DistortNormalMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::DistortNormalMap::1.hda
index c36d086..6698df5 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::DistortNormalMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::DistortNormalMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::DofDisplayFilter::1.hda b/houdini/otls/Vop::DW_MOONRAY::DofDisplayFilter::1.hda
index 12c12f2..ddd4003 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::DofDisplayFilter::1.hda and b/houdini/otls/Vop::DW_MOONRAY::DofDisplayFilter::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::DwaAdjustMaterial::1.hda b/houdini/otls/Vop::DW_MOONRAY::DwaAdjustMaterial::1.hda
index 6f8f994..b09cc11 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::DwaAdjustMaterial::1.hda and b/houdini/otls/Vop::DW_MOONRAY::DwaAdjustMaterial::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::DwaBaseMaterial::1.hda b/houdini/otls/Vop::DW_MOONRAY::DwaBaseMaterial::1.hda
index 9921b1f..175808f 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::DwaBaseMaterial::1.hda and b/houdini/otls/Vop::DW_MOONRAY::DwaBaseMaterial::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::DwaColorCorrectMaterial::1.hda b/houdini/otls/Vop::DW_MOONRAY::DwaColorCorrectMaterial::1.hda
index f6358a1..5b7a478 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::DwaColorCorrectMaterial::1.hda and b/houdini/otls/Vop::DW_MOONRAY::DwaColorCorrectMaterial::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::DwaEmissiveMaterial::1.hda b/houdini/otls/Vop::DW_MOONRAY::DwaEmissiveMaterial::1.hda
index 1f0abf0..a687ef0 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::DwaEmissiveMaterial::1.hda and b/houdini/otls/Vop::DW_MOONRAY::DwaEmissiveMaterial::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::DwaFabricMaterial::1.hda b/houdini/otls/Vop::DW_MOONRAY::DwaFabricMaterial::1.hda
index 10f8f1d..f4765d9 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::DwaFabricMaterial::1.hda and b/houdini/otls/Vop::DW_MOONRAY::DwaFabricMaterial::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::DwaLayerMaterial::1.hda b/houdini/otls/Vop::DW_MOONRAY::DwaLayerMaterial::1.hda
index ed64936..5942397 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::DwaLayerMaterial::1.hda and b/houdini/otls/Vop::DW_MOONRAY::DwaLayerMaterial::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::DwaMetalMaterial::1.hda b/houdini/otls/Vop::DW_MOONRAY::DwaMetalMaterial::1.hda
index 609f0a7..e948cf7 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::DwaMetalMaterial::1.hda and b/houdini/otls/Vop::DW_MOONRAY::DwaMetalMaterial::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::DwaMixMaterial::1.hda b/houdini/otls/Vop::DW_MOONRAY::DwaMixMaterial::1.hda
index f5785de..bb5b680 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::DwaMixMaterial::1.hda and b/houdini/otls/Vop::DW_MOONRAY::DwaMixMaterial::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::DwaRefractiveMaterial::1.hda b/houdini/otls/Vop::DW_MOONRAY::DwaRefractiveMaterial::1.hda
index 98ceb76..c864a63 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::DwaRefractiveMaterial::1.hda and b/houdini/otls/Vop::DW_MOONRAY::DwaRefractiveMaterial::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::DwaSkinMaterial::1.hda b/houdini/otls/Vop::DW_MOONRAY::DwaSkinMaterial::1.hda
index bdd63c2..b393330 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::DwaSkinMaterial::1.hda and b/houdini/otls/Vop::DW_MOONRAY::DwaSkinMaterial::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::DwaSolidDielectricMaterial::1.hda b/houdini/otls/Vop::DW_MOONRAY::DwaSolidDielectricMaterial::1.hda
index e55d0a8..6dcc18d 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::DwaSolidDielectricMaterial::1.hda and b/houdini/otls/Vop::DW_MOONRAY::DwaSolidDielectricMaterial::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::DwaSwitchMaterial::1.hda b/houdini/otls/Vop::DW_MOONRAY::DwaSwitchMaterial::1.hda
index b0251f6..282e997 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::DwaSwitchMaterial::1.hda and b/houdini/otls/Vop::DW_MOONRAY::DwaSwitchMaterial::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::DwaToonMaterial::1.hda b/houdini/otls/Vop::DW_MOONRAY::DwaToonMaterial::1.hda
index 7daf4fe..d2e6a86 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::DwaToonMaterial::1.hda and b/houdini/otls/Vop::DW_MOONRAY::DwaToonMaterial::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::DwaTwoSidedMaterial::1.hda b/houdini/otls/Vop::DW_MOONRAY::DwaTwoSidedMaterial::1.hda
index 6c83934..adb8273 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::DwaTwoSidedMaterial::1.hda and b/houdini/otls/Vop::DW_MOONRAY::DwaTwoSidedMaterial::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::DwaVelvetMaterial::2.hda b/houdini/otls/Vop::DW_MOONRAY::DwaVelvetMaterial::2.hda
index 330efe9..d11187c 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::DwaVelvetMaterial::2.hda and b/houdini/otls/Vop::DW_MOONRAY::DwaVelvetMaterial::2.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ExtraAovMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::ExtraAovMap::1.hda
index a8837eb..3fa28d0 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ExtraAovMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::ExtraAovMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::FloatToRgbMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::FloatToRgbMap::1.hda
index 56e0645..3286cd9 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::FloatToRgbMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::FloatToRgbMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::GlitterFlakeMaterial::2.hda b/houdini/otls/Vop::DW_MOONRAY::GlitterFlakeMaterial::2.hda
index 0ddaac5..87adba5 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::GlitterFlakeMaterial::2.hda and b/houdini/otls/Vop::DW_MOONRAY::GlitterFlakeMaterial::2.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::GradientMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::GradientMap::1.hda
index 1871cd9..b90e17e 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::GradientMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::GradientMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::HairColorCorrectMaterial::1.hda b/houdini/otls/Vop::DW_MOONRAY::HairColorCorrectMaterial::1.hda
index bafd8fd..4554a05 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::HairColorCorrectMaterial::1.hda and b/houdini/otls/Vop::DW_MOONRAY::HairColorCorrectMaterial::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::HairColorPresetsMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::HairColorPresetsMap::1.hda
index afd136c..56569b9 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::HairColorPresetsMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::HairColorPresetsMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::HairColumnMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::HairColumnMap::1.hda
index 343ab8f..91d3693 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::HairColumnMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::HairColumnMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::HairDiffuseMaterial::1.hda b/houdini/otls/Vop::DW_MOONRAY::HairDiffuseMaterial::1.hda
index 716b29d..31cbe25 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::HairDiffuseMaterial::1.hda and b/houdini/otls/Vop::DW_MOONRAY::HairDiffuseMaterial::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::HairLayerMaterial::1.hda b/houdini/otls/Vop::DW_MOONRAY::HairLayerMaterial::1.hda
index 986b8c0..16a6f59 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::HairLayerMaterial::1.hda and b/houdini/otls/Vop::DW_MOONRAY::HairLayerMaterial::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::HairMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::HairMap::1.hda
index b9ff9c8..18dad16 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::HairMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::HairMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::HairMaterial::3.hda b/houdini/otls/Vop::DW_MOONRAY::HairMaterial::3.hda
index 34ed2c7..6b393d3 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::HairMaterial::3.hda and b/houdini/otls/Vop::DW_MOONRAY::HairMaterial::3.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::HairToonMaterial::1.hda b/houdini/otls/Vop::DW_MOONRAY::HairToonMaterial::1.hda
index a74016f..8e3db2f 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::HairToonMaterial::1.hda and b/houdini/otls/Vop::DW_MOONRAY::HairToonMaterial::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::HalftoneDisplayFilter::1.hda b/houdini/otls/Vop::DW_MOONRAY::HalftoneDisplayFilter::1.hda
index 8c76fb3..b1ccdc4 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::HalftoneDisplayFilter::1.hda and b/houdini/otls/Vop::DW_MOONRAY::HalftoneDisplayFilter::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::HsvToRgbMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::HsvToRgbMap::1.hda
index 84f1af9..8ab12b9 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::HsvToRgbMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::HsvToRgbMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ImageDisplayFilter::1.hda b/houdini/otls/Vop::DW_MOONRAY::ImageDisplayFilter::1.hda
index a686416..21ed07e 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ImageDisplayFilter::1.hda and b/houdini/otls/Vop::DW_MOONRAY::ImageDisplayFilter::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ImageMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::ImageMap::1.hda
index f05d663..7ba8792 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ImageMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::ImageMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ImageNormalMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::ImageNormalMap::1.hda
index 16dfa48..b856dd9 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ImageNormalMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::ImageNormalMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::IntensityLightFilter::1.hda b/houdini/otls/Vop::DW_MOONRAY::IntensityLightFilter::1.hda
new file mode 100644
index 0000000..36aba49
Binary files /dev/null and b/houdini/otls/Vop::DW_MOONRAY::IntensityLightFilter::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::LODMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::LODMap::1.hda
index 2c6c686..e876656 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::LODMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::LODMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::LayerMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::LayerMap::1.hda
index ddaa65a..ff27f9e 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::LayerMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::LayerMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::LayerMap::2.hda b/houdini/otls/Vop::DW_MOONRAY::LayerMap::2.hda
index 96bcf30..360c1dc 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::LayerMap::2.hda and b/houdini/otls/Vop::DW_MOONRAY::LayerMap::2.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ListMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::ListMap::1.hda
index 7b163a1..4bb5181 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ListMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::ListMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::MacroFlakeMaterial::1.hda b/houdini/otls/Vop::DW_MOONRAY::MacroFlakeMaterial::1.hda
index 9f19a4a..f8fc94b 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::MacroFlakeMaterial::1.hda and b/houdini/otls/Vop::DW_MOONRAY::MacroFlakeMaterial::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::MultiChannelToFloatMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::MultiChannelToFloatMap::1.hda
index 6c0c25e..8cceac0 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::MultiChannelToFloatMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::MultiChannelToFloatMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::NoiseMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::NoiseMap::1.hda
index b06dc29..e12db16 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::NoiseMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::NoiseMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::NoiseMap::2.hda b/houdini/otls/Vop::DW_MOONRAY::NoiseMap::2.hda
index f1b76fa..9efef78 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::NoiseMap::2.hda and b/houdini/otls/Vop::DW_MOONRAY::NoiseMap::2.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::NoiseWorleyMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::NoiseWorleyMap::1.hda
index 92c2dbd..0179b85 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::NoiseWorleyMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::NoiseWorleyMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::NoiseWorleyMap::2.hda b/houdini/otls/Vop::DW_MOONRAY::NoiseWorleyMap::2.hda
index 33ee6d3..0054034 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::NoiseWorleyMap::2.hda and b/houdini/otls/Vop::DW_MOONRAY::NoiseWorleyMap::2.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::NoiseWorleyMap::3.hda b/houdini/otls/Vop::DW_MOONRAY::NoiseWorleyMap::3.hda
index 83795a0..c0f0591 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::NoiseWorleyMap::3.hda and b/houdini/otls/Vop::DW_MOONRAY::NoiseWorleyMap::3.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::NormalDisplacement::1.hda b/houdini/otls/Vop::DW_MOONRAY::NormalDisplacement::1.hda
index 1aa138f..19f80ce 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::NormalDisplacement::1.hda and b/houdini/otls/Vop::DW_MOONRAY::NormalDisplacement::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::NormalToRgbMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::NormalToRgbMap::1.hda
index f1881c6..2db5219 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::NormalToRgbMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::NormalToRgbMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::OpDisplayFilter::1.hda b/houdini/otls/Vop::DW_MOONRAY::OpDisplayFilter::1.hda
index 2adc046..3e1d60a 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::OpDisplayFilter::1.hda and b/houdini/otls/Vop::DW_MOONRAY::OpDisplayFilter::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::OpMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::OpMap::1.hda
index 020e194..5429e59 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::OpMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::OpMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::OpSqrtMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::OpSqrtMap::1.hda
index 3d698a2..a7694f5 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::OpSqrtMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::OpSqrtMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::OpenVdbMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::OpenVdbMap::1.hda
index 8e9acc4..43c0684 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::OpenVdbMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::OpenVdbMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::OpenVdbMap::2.hda b/houdini/otls/Vop::DW_MOONRAY::OpenVdbMap::2.hda
index 617fefc..9bddf8f 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::OpenVdbMap::2.hda and b/houdini/otls/Vop::DW_MOONRAY::OpenVdbMap::2.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::OverDisplayFilter::1.hda b/houdini/otls/Vop::DW_MOONRAY::OverDisplayFilter::1.hda
index 9712ce1..ea462e0 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::OverDisplayFilter::1.hda and b/houdini/otls/Vop::DW_MOONRAY::OverDisplayFilter::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ProjectCameraMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::ProjectCameraMap::1.hda
index aac960d..656d16b 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ProjectCameraMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::ProjectCameraMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ProjectCameraMap::2.hda b/houdini/otls/Vop::DW_MOONRAY::ProjectCameraMap::2.hda
index c8ce191..ff7f0ab 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ProjectCameraMap::2.hda and b/houdini/otls/Vop::DW_MOONRAY::ProjectCameraMap::2.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ProjectCameraNormalMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::ProjectCameraNormalMap::1.hda
index 6ce989f..3334fc7 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ProjectCameraNormalMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::ProjectCameraNormalMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ProjectCylindricalMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::ProjectCylindricalMap::1.hda
index e9de1bb..b2b714d 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ProjectCylindricalMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::ProjectCylindricalMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ProjectPlanarMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::ProjectPlanarMap::1.hda
index ac3721e..abeec38 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ProjectPlanarMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::ProjectPlanarMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ProjectPlanarNormalMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::ProjectPlanarNormalMap::1.hda
index 0cce378..48a7864 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ProjectPlanarNormalMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::ProjectPlanarNormalMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ProjectSphericalMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::ProjectSphericalMap::1.hda
index 4995b8d..d329922 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ProjectSphericalMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::ProjectSphericalMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ProjectTriplanarMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::ProjectTriplanarMap::1.hda
index 776bcf6..20711c3 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ProjectTriplanarMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::ProjectTriplanarMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ProjectTriplanarMap::2.hda b/houdini/otls/Vop::DW_MOONRAY::ProjectTriplanarMap::2.hda
index 5326b67..c5d5550 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ProjectTriplanarMap::2.hda and b/houdini/otls/Vop::DW_MOONRAY::ProjectTriplanarMap::2.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ProjectTriplanarNormalMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::ProjectTriplanarNormalMap::1.hda
index 332a4da..c230eae 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ProjectTriplanarNormalMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::ProjectTriplanarNormalMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ProjectTriplanarNormalMap::2.hda b/houdini/otls/Vop::DW_MOONRAY::ProjectTriplanarNormalMap::2.hda
index cd5ffe4..7f24fc3 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ProjectTriplanarNormalMap::2.hda and b/houdini/otls/Vop::DW_MOONRAY::ProjectTriplanarNormalMap::2.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ProjectTriplanarUdimMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::ProjectTriplanarUdimMap::1.hda
index 9f1eb70..88bd4dd 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ProjectTriplanarUdimMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::ProjectTriplanarUdimMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::RampDisplayFilter::1.hda b/houdini/otls/Vop::DW_MOONRAY::RampDisplayFilter::1.hda
index aef571f..e5a62e0 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::RampDisplayFilter::1.hda and b/houdini/otls/Vop::DW_MOONRAY::RampDisplayFilter::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::RampMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::RampMap::1.hda
index 946946a..d4c8730 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::RampMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::RampMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::RandomMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::RandomMap::1.hda
index 5ff678e..0ce395b 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::RandomMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::RandomMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::RandomNormalMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::RandomNormalMap::1.hda
index 39eb0d7..d73c80f 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::RandomNormalMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::RandomNormalMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::RaySwitchMaterial::1.hda b/houdini/otls/Vop::DW_MOONRAY::RaySwitchMaterial::1.hda
index 702fb5e..56f12f2 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::RaySwitchMaterial::1.hda and b/houdini/otls/Vop::DW_MOONRAY::RaySwitchMaterial::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::RemapDisplayFilter::1.hda b/houdini/otls/Vop::DW_MOONRAY::RemapDisplayFilter::1.hda
index 8641643..3a31753 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::RemapDisplayFilter::1.hda and b/houdini/otls/Vop::DW_MOONRAY::RemapDisplayFilter::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::RemapMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::RemapMap::1.hda
index 3747662..1d1d340 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::RemapMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::RemapMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::RgbToFloatDisplayFilter::1.hda b/houdini/otls/Vop::DW_MOONRAY::RgbToFloatDisplayFilter::1.hda
index dbb7266..3618d19 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::RgbToFloatDisplayFilter::1.hda and b/houdini/otls/Vop::DW_MOONRAY::RgbToFloatDisplayFilter::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::RgbToFloatMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::RgbToFloatMap::1.hda
index 4523109..54d2cd4 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::RgbToFloatMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::RgbToFloatMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::RgbToHsvDisplayFilter::1.hda b/houdini/otls/Vop::DW_MOONRAY::RgbToHsvDisplayFilter::1.hda
index e565777..00525c5 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::RgbToHsvDisplayFilter::1.hda and b/houdini/otls/Vop::DW_MOONRAY::RgbToHsvDisplayFilter::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::RgbToHsvMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::RgbToHsvMap::1.hda
index 9d9043e..cd71fd2 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::RgbToHsvMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::RgbToHsvMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::RgbToLabMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::RgbToLabMap::1.hda
index 618a8bf..146f8a7 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::RgbToLabMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::RgbToLabMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::RgbToNormalMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::RgbToNormalMap::1.hda
index b36e586..af13f24 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::RgbToNormalMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::RgbToNormalMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::RodLightFilter::1.hda b/houdini/otls/Vop::DW_MOONRAY::RodLightFilter::1.hda
new file mode 100644
index 0000000..d8d009a
Binary files /dev/null and b/houdini/otls/Vop::DW_MOONRAY::RodLightFilter::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ShadowDisplayFilter::1.hda b/houdini/otls/Vop::DW_MOONRAY::ShadowDisplayFilter::1.hda
index 26c6c92..9da625f 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ShadowDisplayFilter::1.hda and b/houdini/otls/Vop::DW_MOONRAY::ShadowDisplayFilter::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::SwitchColorMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::SwitchColorMap::1.hda
index 5dc098e..a4ac66a 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::SwitchColorMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::SwitchColorMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::SwitchDisplacement::1.hda b/houdini/otls/Vop::DW_MOONRAY::SwitchDisplacement::1.hda
index 842dbf8..eca3e83 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::SwitchDisplacement::1.hda and b/houdini/otls/Vop::DW_MOONRAY::SwitchDisplacement::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::SwitchFloatMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::SwitchFloatMap::1.hda
index 5b396e2..f6ed357 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::SwitchFloatMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::SwitchFloatMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::SwitchMaterial::1.hda b/houdini/otls/Vop::DW_MOONRAY::SwitchMaterial::1.hda
index c285cf1..b07b8d8 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::SwitchMaterial::1.hda and b/houdini/otls/Vop::DW_MOONRAY::SwitchMaterial::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::SwitchNormalMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::SwitchNormalMap::1.hda
index ddedab1..4ba050b 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::SwitchNormalMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::SwitchNormalMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::TangentSpaceDisplayFilter::1.hda b/houdini/otls/Vop::DW_MOONRAY::TangentSpaceDisplayFilter::1.hda
index 60a5026..514c04d 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::TangentSpaceDisplayFilter::1.hda and b/houdini/otls/Vop::DW_MOONRAY::TangentSpaceDisplayFilter::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ToonDisplayFilter::1.hda b/houdini/otls/Vop::DW_MOONRAY::ToonDisplayFilter::1.hda
index 3a45ea1..b3ab39f 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ToonDisplayFilter::1.hda and b/houdini/otls/Vop::DW_MOONRAY::ToonDisplayFilter::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::ToonMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::ToonMap::1.hda
index 7e77d60..bf6303c 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::ToonMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::ToonMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::TransformNormalMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::TransformNormalMap::1.hda
index c015823..5b1bdde 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::TransformNormalMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::TransformNormalMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::TransformSpaceMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::TransformSpaceMap::1.hda
index bf64566..6d97ce6 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::TransformSpaceMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::TransformSpaceMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::TwoSidedMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::TwoSidedMap::1.hda
index 489a9fe..a10ddd0 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::TwoSidedMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::TwoSidedMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::UVTransformMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::UVTransformMap::1.hda
index 11b487e..26cb604 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::UVTransformMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::UVTransformMap::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::VdbLightFilter::1.hda b/houdini/otls/Vop::DW_MOONRAY::VdbLightFilter::1.hda
new file mode 100644
index 0000000..ff5fc06
Binary files /dev/null and b/houdini/otls/Vop::DW_MOONRAY::VdbLightFilter::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::VectorDisplacement::1.hda b/houdini/otls/Vop::DW_MOONRAY::VectorDisplacement::1.hda
index ad715f0..1789b06 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::VectorDisplacement::1.hda and b/houdini/otls/Vop::DW_MOONRAY::VectorDisplacement::1.hda differ
diff --git a/houdini/otls/Vop::DW_MOONRAY::WireframeMap::1.hda b/houdini/otls/Vop::DW_MOONRAY::WireframeMap::1.hda
index 02b00f5..0cfde4b 100644
Binary files a/houdini/otls/Vop::DW_MOONRAY::WireframeMap::1.hda and b/houdini/otls/Vop::DW_MOONRAY::WireframeMap::1.hda differ
diff --git a/houdini/python3.11libs/__pycache__/moonray_lightfilter_nodes.cpython-314.pyc b/houdini/python3.11libs/__pycache__/moonray_lightfilter_nodes.cpython-314.pyc
new file mode 100644
index 0000000..69e9645
Binary files /dev/null and b/houdini/python3.11libs/__pycache__/moonray_lightfilter_nodes.cpython-314.pyc differ
diff --git a/houdini/python3.11libs/moonray_lightfilter_nodes.py b/houdini/python3.11libs/moonray_lightfilter_nodes.py
new file mode 100644
index 0000000..e1f428e
--- /dev/null
+++ b/houdini/python3.11libs/moonray_lightfilter_nodes.py
@@ -0,0 +1,1047 @@
+"""Generate MoonRay light-filter VOP HDAs for Solaris Light Filter Library.
+
+The standard Houdini Light Filter Library LOP consumes VOP nodes whose shader
+type is ``lightfilter`` and authors UsdLux PluginLightFilter prims. These
+generated nodes keep MoonRay on that native Solaris path while preserving the
+native MoonRay filter class and parameter names.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import hou
+
+
+TEMPLATE_NODE = "kma_lfilter_attenuation"
+USD_LIGHTFILTER_EXTRA_INFO = "shadertype=lightfilter visibleoutputs=0 vopnetmask='usdlightfilter' "
+
+
+def toggle(name, label, default="0", help_text=""):
+    return {
+        "name": name,
+        "label": label,
+        "vop_type": "int",
+        "parm_type": "toggle",
+        "default": default,
+        "script_ritype": "int",
+        "help": help_text,
+    }
+
+
+def int_parm(name, label, default="0", value_range=None, help_text="", menu=None):
+    item = {
+        "name": name,
+        "label": label,
+        "vop_type": "int",
+        "parm_type": "integer",
+        "default": default,
+        "script_ritype": "int",
+        "help": help_text,
+    }
+    if value_range is not None:
+        item["range"] = value_range
+    if menu is not None:
+        item["menu"] = menu
+    return item
+
+
+def float_parm(name, label, default="0", value_range=None, help_text=""):
+    item = {
+        "name": name,
+        "label": label,
+        "vop_type": "float",
+        "parm_type": "float",
+        "default": default,
+        "script_ritype": "float",
+        "help": help_text,
+    }
+    if value_range is not None:
+        item["range"] = value_range
+    return item
+
+
+def color_parm(name, label, default=("1", "1", "1"), help_text=""):
+    return {
+        "name": name,
+        "label": label,
+        "vop_type": "vector",
+        "parm_type": "color",
+        "default": default,
+        "range": (0, 1),
+        "script_ritype": "color",
+        "help": help_text,
+    }
+
+
+def string_parm(name, label, default="", help_text=""):
+    return {
+        "name": name,
+        "label": label,
+        "vop_type": "string",
+        "parm_type": "string",
+        "default": default,
+        "script_ritype": "string",
+        "help": help_text,
+    }
+
+
+def ramp_rgb_parm(
+    name,
+    label,
+    default_count="2",
+    value_type="color3f[]",
+    help_text="",
+    rampbasis_var=None,
+    rampkeys_var=None,
+    rampvalues_var=None,
+):
+    return {
+        "name": name,
+        "label": label,
+        "vop_type": None,
+        "parm_type": "ramp_rgb",
+        "default": default_count,
+        "script_ritype": "ramp_rgb",
+        "usdvaluetype": value_type,
+        "range": ("1!", "10"),
+        "help": help_text,
+        "ui_only": True,
+        "rampbasis_var": rampbasis_var,
+        "rampkeys_var": rampkeys_var,
+        "rampvalues_var": rampvalues_var,
+    }
+
+
+def ramp_float_parm(
+    name,
+    label,
+    default_count="2",
+    value_type="float[]",
+    help_text="",
+    rampbasis_var=None,
+    rampkeys_var=None,
+    rampvalues_var=None,
+):
+    return {
+        "name": name,
+        "label": label,
+        "vop_type": None,
+        "parm_type": "ramp_flt",
+        "default": default_count,
+        "script_ritype": "ramp_flt",
+        "usdvaluetype": value_type,
+        "range": ("1!", "10"),
+        "help": help_text,
+        "ui_only": True,
+        "rampbasis_var": rampbasis_var,
+        "rampkeys_var": rampkeys_var,
+        "rampvalues_var": rampvalues_var,
+    }
+
+
+LIGHT_FILTERS = {
+    "IntensityLightFilter": {
+        "label": "MoonRay Intensity Light Filter",
+        "folder": ("intensity_filter", "Intensity Filter"),
+        "inputs": [
+            toggle("on", "On", "1", "Turns the light filter on/off."),
+            float_parm(
+                "intensity",
+                "Intensity",
+                "1",
+                (0, 10),
+                "Multiply the light radiance by this intensity value",
+            ),
+            float_parm(
+                "exposure",
+                "Exposure",
+                "0",
+                (-10, 10),
+                "Multiply the light radiance by exposure = pow(2, exposure)",
+            ),
+            color_parm(
+                "color",
+                "Color",
+                ("1", "1", "1"),
+                "Multiply the light radiance by this RGB color value",
+            ),
+            toggle(
+                "invert",
+                "Invert",
+                "0",
+                "Invert the light radiance by 1/radiance",
+            ),
+            int_parm(
+                "light_path_selection",
+                "Light Path Selection",
+                "0",
+                menu=[
+                    ("0", "All Light Paths"),
+                    ("1", "All Indirect"),
+                    ("2", "All Indirect First Bounce"),
+                    ("3", "Indirect Diffuse"),
+                    ("4", "Indirect Diffuse First Bounce"),
+                    ("5", "Indirect Specular"),
+                    ("6", "Indirect Specular First Bounce"),
+                ],
+                help_text="Controls which light paths the filter is applied to.",
+            ),
+        ],
+    },
+
+    "DecayLightFilter": {
+        "label": "MoonRay Decay Light Filter",
+        "folder": ("decay_filter", "Decay Filter"),
+        "inputs": [
+            toggle("on", "On", "1", "Turns the light filter on or off."),
+            toggle("falloff_near", "Falloff Near", "0", "Does the light fade in?"),
+            float_parm(
+                "near_start",
+                "Near Start",
+                "0",
+                (0, 100),
+                "Distance from light to start of fade in",
+            ),
+            float_parm(
+                "near_end",
+                "Near End",
+                "0",
+                (0, 100),
+                "Distance from light to end of fade in",
+            ),
+            toggle("falloff_far", "Falloff Far", "0", "Does the light fade out?"),
+            float_parm(
+                "far_start",
+                "Far Start",
+                "0",
+                (0, 100),
+                "Distance from light to start of fade out",
+            ),
+            float_parm(
+                "far_end",
+                "Far End",
+                "0",
+                (0, 100),
+                "Distance from light to end of fade out",
+            ),
+        ],
+    },
+
+    "BarnDoorLightFilter": {
+        "label": "MoonRay Barn Door Light Filter",
+        "folder": ("barn_door_filter", "Barn Door Filter"),
+        "inputs": [
+            toggle("on", "On", "1", "Turns the light filter on or off."),
+            int_parm(
+                "projector_type",
+                "Projector Type",
+                "0",
+                menu=[
+                    ("0", "Perspective"),
+                    ("1", "Orthographic"),
+                ],
+                help_text="The projection type used to map points to the flap opening.",
+            ),
+            float_parm(
+                "projector_focal_distance",
+                "Projector Focal Distance",
+                "30",
+                (0, 100),
+                "Distance of the flap opening from the projector origin.",
+            ),
+            float_parm(
+                "projector_width",
+                "Projector Width",
+                "1",
+                (0, 100),
+                "Width of the flap opening.",
+            ),
+            float_parm(
+                "projector_height",
+                "Projector Height",
+                "1",
+                (0, 100),
+                "Height of the flap opening.",
+            ),
+            float_parm(
+                "edge_scale_top",
+                "Edge Scale Top",
+                "1",
+                (0, 10),
+                "Scale factor for the top edge.",
+            ),
+            float_parm(
+                "edge_scale_bottom",
+                "Edge Scale Bottom",
+                "1",
+                (0, 10),
+                "Scale factor for the bottom edge.",
+            ),
+            float_parm(
+                "edge_scale_left",
+                "Edge Scale Left",
+                "1",
+                (0, 10),
+                "Scale factor for the left edge.",
+            ),
+            float_parm(
+                "edge_scale_right",
+                "Edge Scale Right",
+                "1",
+                (0, 10),
+                "Scale factor for the right edge.",
+            ),
+            int_parm(
+                "pre_barn_mode",
+                "Pre Barn Mode",
+                "2",
+                menu=[
+                    ("0", "Black"),
+                    ("1", "White"),
+                    ("2", "Default"),
+                ],
+                help_text="Controls the region before the pre barn distance.",
+            ),
+            float_parm(
+                "pre_barn_distance",
+                "Pre Barn Distance",
+                "0.5",
+                (0, 100),
+                "Distance where the pre barn mode takes effect.",
+            ),
+            float_parm(
+                "density",
+                "Density",
+                "1",
+                (0, 1),
+                "Fades the filter effect.",
+            ),
+            toggle(
+                "invert",
+                "Invert",
+                "0",
+                "Swap application of the filter from inside to outside.",
+            ),
+            float_parm(
+                "radius",
+                "Radius",
+                "0",
+                (0, 1),
+                "Rounded box radius.",
+            ),
+            float_parm(
+                "edge",
+                "Edge",
+                "0",
+                (0, 1),
+                "Transition zone size.",
+            ),
+            int_parm(
+                "mode",
+                "Mode",
+                "0",
+                menu=[
+                    ("0", "Analytical"),
+                    ("1", "Physical"),
+                ],
+                help_text="Analytical or physical barn door mode.",
+            ),
+            float_parm(
+                "size_top",
+                "Size Top",
+                "0",
+                (-100, 100),
+                "Additional size on the top edge.",
+            ),
+            float_parm(
+                "size_bottom",
+                "Size Bottom",
+                "0",
+                (-100, 100),
+                "Additional size on the bottom edge.",
+            ),
+            float_parm(
+                "size_left",
+                "Size Left",
+                "0",
+                (-100, 100),
+                "Additional size on the left edge.",
+            ),
+            float_parm(
+                "size_right",
+                "Size Right",
+                "0",
+                (-100, 100),
+                "Additional size on the right edge.",
+            ),
+            toggle(
+                "use_light_xform",
+                "Use Light Xform",
+                "1",
+                "Attach the filter to the light and ignore node_xform.",
+            ),
+            float_parm(
+                "rotation",
+                "Rotation",
+                "0",
+                (-180, 180),
+                "Rotation around the focal direction, in degrees.",
+            ),
+            color_parm(
+                "color",
+                "Color",
+                ("1", "1", "1"),
+                "Color within the Barn Door lit region.",
+            ),
+        ],
+    },
+
+    "ColorRampLightFilter": {
+        "label": "MoonRay Color Ramp Light Filter",
+        "folder": ("color_ramp_filter", "Color Ramp Filter"),
+        "inputs": [
+            toggle("on", "On", "1", "Turns the light filter on or off."),
+            toggle("use_xform", "Use Xform", "0", "Use the filter's own transform."),
+            float_parm(
+                "begin_distance",
+                "Begin Distance",
+                "0",
+                (0, 100),
+                "Where the ramp starts.",
+            ),
+            float_parm(
+                "end_distance",
+                "End Distance",
+                "1",
+                (0, 100),
+                "Where the ramp ends.",
+            ),
+            ramp_rgb_parm(
+                "ramp",
+                "Ramp",
+                "2",
+                "color3f[]",
+                "Color ramp used by the light filter.",
+                rampbasis_var="interpolation_types",
+                rampkeys_var="distances",
+                rampvalues_var="colors",
+            ),
+            float_parm(
+                "intensity",
+                "Intensity",
+                "1",
+                (0, 1),
+                "The intensity of the filter.",
+            ),
+            float_parm(
+                "density",
+                "Density",
+                "1",
+                (0, 1),
+                "The density of the filter.",
+            ),
+            int_parm(
+                "mode",
+                "Mode",
+                "0",
+                menu=[
+                    ("0", "Radial"),
+                    ("1", "Directional"),
+                ],
+                help_text="Ramp mode.",
+            ),
+            int_parm(
+                "wrap_mode",
+                "Wrap Mode",
+                "0",
+                menu=[
+                    ("0", "Extend"),
+                    ("1", "Mirror"),
+                ],
+                help_text="Wrap mode for directional filtering.",
+            ),
+        ],
+    },
+
+    "CombineLightFilter": {
+        "label": "MoonRay Combine Light Filter",
+        "folder": ("combine_filter", "Combine Filter"),
+        "inputs": [
+            toggle("on", "On", "1", "Turns the light filter on or off."),
+            int_parm(
+                "mode",
+                "Mode",
+                "0",
+                menu=[
+                    ("0", "Multiply"),
+                    ("1", "Min"),
+                    ("2", "Max"),
+                    ("3", "Add"),
+                    ("4", "Subtract"),
+                ],
+                help_text="How the light filters are combined.",
+            ),
+        ],
+    },
+
+    "CookieLightFilter": {
+        "label": "MoonRay Cookie Light Filter",
+        "folder": ("cookie_filter", "Cookie Filter"),
+        "inputs": [
+            toggle("on", "On", "1", "Turns the light filter on or off."),
+            int_parm(
+                "projector_type",
+                "Projector Type",
+                "0",
+                menu=[
+                    ("0", "Perspective"),
+                    ("1", "Orthographic"),
+                ],
+                help_text="Perspective or orthographic projection.",
+            ),
+            float_parm(
+                "projector_focal",
+                "Projector Focal",
+                "30",
+                (0, 100),
+                "Projector focal length.",
+            ),
+            float_parm(
+                "projector_film_width_aperture",
+                "Projector Film Width Aperture",
+                "24",
+                (0, 100),
+                "Projector image plane width.",
+            ),
+            float_parm(
+                "projector_pixel_aspect_ratio",
+                "Projector Pixel Aspect Ratio",
+                "1",
+                (0.01, 10),
+                "Projector pixel aspect ratio.",
+            ),
+            float_parm(
+                "blur_near_distance",
+                "Blur Near Distance",
+                "0",
+                (0, 100),
+                "Near blur distance.",
+            ),
+            float_parm(
+                "blur_midpoint",
+                "Blur Midpoint",
+                "0.5",
+                (0, 100),
+                "Blur midpoint.",
+            ),
+            float_parm(
+                "blur_far_distance",
+                "Blur Far Distance",
+                "1",
+                (0, 100),
+                "Far blur distance.",
+            ),
+            float_parm(
+                "blur_near_value",
+                "Blur Near Value",
+                "0",
+                (0, 0.1),
+                "Near blur value.",
+            ),
+            float_parm(
+                "blur_mid_value",
+                "Blur Mid Value",
+                "0",
+                (0, 0.1),
+                "Mid blur value.",
+            ),
+            float_parm(
+                "blur_far_value",
+                "Blur Far Value",
+                "0",
+                (0, 0.1),
+                "Far blur value.",
+            ),
+            int_parm(
+                "blur_type",
+                "Blur Type",
+                "0",
+                menu=[
+                    ("0", "Gaussian"),
+                    ("1", "Circular"),
+                ],
+                help_text="Blur type.",
+            ),
+            int_parm(
+                "outside_projection",
+                "Outside Projection",
+                "0",
+                menu=[
+                    ("0", "Black"),
+                    ("1", "White"),
+                    ("2", "Default"),
+                ],
+                help_text="Behavior outside the projection frustum.",
+            ),
+            float_parm(
+                "density",
+                "Density",
+                "1",
+                (0, 1),
+                "Controls how much of the cookie is added to the light.",
+            ),
+            toggle("invert", "Invert", "0", "Invert the map."),
+        ],
+    },
+
+    "CookieLightFilter_v2": {
+        "label": "MoonRay Cookie Light Filter v2",
+        "folder": ("cookie_v2_filter", "Cookie v2 Filter"),
+        "inputs": [
+            toggle("on", "On", "1", "Turns the light filter on or off."),
+            int_parm(
+                "projector_type",
+                "Projector Type",
+                "0",
+                menu=[
+                    ("0", "Perspective"),
+                    ("1", "Orthographic"),
+                ],
+                help_text="Perspective or orthographic projection.",
+            ),
+            float_parm(
+                "projector_focal",
+                "Projector Focal",
+                "30",
+                (0, 100),
+                "Projector focal length.",
+            ),
+            float_parm(
+                "projector_film_width_aperture",
+                "Projector Film Width Aperture",
+                "24",
+                (0, 100),
+                "Projector image plane width.",
+            ),
+            float_parm(
+                "projector_pixel_aspect_ratio",
+                "Projector Pixel Aspect Ratio",
+                "1",
+                (0.01, 10),
+                "Projector pixel aspect ratio.",
+            ),
+            float_parm(
+                "blur_near_distance",
+                "Blur Near Distance",
+                "0",
+                (0, 100),
+                "Near blur distance.",
+            ),
+            float_parm(
+                "blur_midpoint",
+                "Blur Midpoint",
+                "0.5",
+                (0, 100),
+                "Blur midpoint.",
+            ),
+            float_parm(
+                "blur_far_distance",
+                "Blur Far Distance",
+                "1",
+                (0, 100),
+                "Far blur distance.",
+            ),
+            float_parm(
+                "blur_near_value",
+                "Blur Near Value",
+                "0",
+                (0, 0.1),
+                "Near blur value.",
+            ),
+            float_parm(
+                "blur_mid_value",
+                "Blur Mid Value",
+                "0",
+                (0, 0.1),
+                "Mid blur value.",
+            ),
+            float_parm(
+                "blur_far_value",
+                "Blur Far Value",
+                "0",
+                (0, 0.1),
+                "Far blur value.",
+            ),
+            int_parm(
+                "blur_type",
+                "Blur Type",
+                "0",
+                menu=[
+                    ("0", "Gaussian"),
+                    ("1", "Circular"),
+                ],
+                help_text="Blur type.",
+            ),
+            int_parm(
+                "outside_projection",
+                "Outside Projection",
+                "0",
+                menu=[
+                    ("0", "Black"),
+                    ("1", "White"),
+                    ("2", "Default"),
+                ],
+                help_text="Behavior outside the projection frustum.",
+            ),
+            float_parm(
+                "density",
+                "Density",
+                "1",
+                (0, 1),
+                "Controls how much of the cookie is added to the light.",
+            ),
+            toggle("invert", "Invert", "0", "Invert the texture."),
+            string_parm("texture", "Texture", "", "Texture file path."),
+            color_parm("gamma", "Gamma", ("1", "1", "1"), "Per-channel texture gamma."),
+        ],
+    },
+
+    "RodLightFilter": {
+        "label": "MoonRay Rod Light Filter",
+        "folder": ("rod_filter", "Rod Filter"),
+        "inputs": [
+            toggle("on", "On", "1", "Turns the light filter on or off."),
+            float_parm("width", "Width", "1", (0, 10), "Width of the base box."),
+            float_parm("depth", "Depth", "1", (0, 10), "Depth of the base box."),
+            float_parm("height", "Height", "1", (0, 10), "Height of the base box."),
+            float_parm("radius", "Radius", "0", (0, 10), "Rounded box radius."),
+            float_parm("edge", "Edge", "0", (0, 10), "Transition zone size."),
+            color_parm("color", "Color", ("0", "0", "0"), "Filter color."),
+            float_parm("intensity", "Intensity", "1", (0, 10), "Color intensity multiplier."),
+            float_parm("density", "Density", "1", (0, 10), "Fades the filter effect."),
+            toggle("invert", "Invert", "0", "Swap application from inside to outside."),
+            ramp_float_parm(
+                "ramp",
+                "Ramp",
+                "2",
+                "float[]",
+                "Distance remap ramp used by the rod filter.",
+                rampbasis_var="ramp_interpolation_types",
+                rampkeys_var="ramp_in_distances",
+                rampvalues_var="ramp_out_distances",
+            ),
+        ],
+    },
+
+    "VdbLightFilter": {
+        "label": "MoonRay VDB Light Filter",
+        "folder": ("vdb_filter", "VDB Filter"),
+        "inputs": [
+            toggle("on", "On", "1", "Turns the light filter on or off."),
+            string_parm("vdb_map", "VDB Map", "", "Path to the VDB file."),
+            string_parm(
+                "density_grid_name",
+                "Density Grid Name",
+                "density",
+                "Name of the density grid.",
+            ),
+            int_parm(
+                "vdb_interpolation_type",
+                "VDB Interpolation Type",
+                "0",
+                menu=[
+                    ("0", "Point"),
+                    ("1", "Box"),
+                    ("2", "Quadratic"),
+                ],
+                help_text="Interpolation type used when sampling the VDB.",
+            ),
+            float_parm(
+                "density_remap_input_min",
+                "Density Remap Input Min",
+                "0",
+                (-100, 100),
+                "Input remap minimum.",
+            ),
+            float_parm(
+                "density_remap_input_max",
+                "Density Remap Input Max",
+                "1",
+                (-100, 100),
+                "Input remap maximum.",
+            ),
+            float_parm(
+                "density_remap_output_min",
+                "Density Remap Output Min",
+                "0",
+                (-100, 100),
+                "Output remap minimum.",
+            ),
+            float_parm(
+                "density_remap_output_max",
+                "Density Remap Output Max",
+                "1",
+                (-100, 100),
+                "Output remap maximum.",
+            ),
+            toggle(
+                "density_rescale_enable",
+                "Density Rescale Enable",
+                "0",
+                "Enable density rescaling.",
+            ),
+            ramp_float_parm(
+                "ramp",
+                "Ramp",
+                "2",
+                "float[]",
+                "Density remap ramp used by the VDB filter.",
+                rampbasis_var="density_remap_interpolation_types",
+                rampkeys_var="density_remap_inputs",
+                rampvalues_var="density_remap_outputs",
+            ),
+            color_parm("color_tint", "Color Tint", ("0", "0", "0"), "Color tint."),
+            float_parm("blur_value", "Blur Value", "0", (0, 1000), "Blur radius."),
+            int_parm(
+                "blur_type",
+                "Blur Type",
+                "0",
+                menu=[
+                    ("0", "Gaussian"),
+                    ("1", "Circular"),
+                ],
+                help_text="Blur type.",
+            ),
+            toggle("invert_density", "Invert Density", "0", "Invert the density."),
+        ],
+    },
+}
+
+
+TYPE_OPTIONS = """SaveSpareParms := 0;
+CheckExternal := 1;
+SaveIcon := 1;
+GzipContents := 1;
+ContentsCompressionType := 1;
+UnlockOnCreate := 0;
+SaveCachedCode := 0;
+LockContents := 1;
+MakeDefault := 1;
+UseDSParms := 1;
+ForbidOutsideParms := 1;
+PrefixDroppedParmLabel := 0;
+PrefixDroppedParmName := 0;
+ParmsFromVfl := 0;
+"""
+
+
+TOOLS_SHELF = """<?xml version="1.0" encoding="UTF-8"?>
+<shelfDocument>
+  <tool name="$HDA_DEFAULT_TOOL" label="$HDA_LABEL" icon="$HDA_ICON">
+    <toolMenuContext name="viewer">
+      <contextNetType>VOP</contextNetType>
+    </toolMenuContext>
+    <toolMenuContext name="network">
+      <contextOpType>$HDA_TABLE_AND_NAME</contextOpType>
+    </toolMenuContext>
+    <toolSubmenu>MoonRay/Light Filters</toolSubmenu>
+    <toolSubmenu>DW Moonray</toolSubmenu>
+    <script scriptType="python"><![CDATA[import voptoolutils
+voptoolutils.genericTool(kwargs, '$HDA_NAME')
+]]></script>
+  </tool>
+</shelfDocument>
+"""
+
+
+def _quote(value: str) -> str:
+    return '"' + str(value).replace("\\", "\\\\").replace('"', '\\"') + '"'
+
+
+def _default_values(default):
+    if isinstance(default, (tuple, list)):
+        return " ".join(_quote(v) for v in default)
+    return _quote(default)
+
+
+def _parm_dialog(input_def: dict) -> str:
+    lines = [
+        "        parm {",
+        f"            name {_quote(input_def['name'])}",
+        f"            label {_quote(input_def['label'])}",
+        f"            type {input_def['parm_type']}",
+    ]
+
+    if input_def["parm_type"] == "color":
+        lines.append("            size 3")
+    elif input_def["parm_type"] not in ("ramp_rgb", "ramp_flt"):
+        lines.append("            size 1")
+
+    lines.extend(
+        [
+            "            export none",
+            f"            default {{ {_default_values(input_def['default'])} }}",
+        ]
+    )
+
+    if "range" in input_def:
+        lo, hi = input_def["range"]
+        lines.append(f"            range {{ {lo} {hi} }}")
+    if "menu" in input_def:
+        lines.append("            menu {")
+        for token, label in input_def["menu"]:
+            lines.append(f"                {_quote(token)} {_quote(label)}")
+        lines.append("            }")
+    if "help" in input_def:
+        lines.append(f"            help {_quote(input_def['help'])}")
+
+    if input_def.get("rampbasis_var"):
+        lines.append(
+            f"            parmtag {{ {_quote('rampbasis_var')} {_quote(input_def['rampbasis_var'])} }}"
+        )
+    if input_def.get("rampkeys_var"):
+        lines.append(
+            f"            parmtag {{ {_quote('rampkeys_var')} {_quote(input_def['rampkeys_var'])} }}"
+        )
+    if input_def.get("rampvalues_var"):
+        lines.append(
+            f"            parmtag {{ {_quote('rampvalues_var')} {_quote(input_def['rampvalues_var'])} }}"
+        )
+
+    if "usdvaluetype" in input_def:
+        lines.append(
+            f"            parmtag {{ {_quote('usdvaluetype')} {_quote(input_def['usdvaluetype'])} }}"
+        )
+    else:
+        lines.append(
+            f"            parmtag {{ {_quote('script_ritype')} {_quote(input_def['script_ritype'])} }}"
+        )
+
+    lines.append("        }")
+    return "\n".join(lines)
+
+
+def _dialog_script(class_name: str, spec: dict) -> str:
+    folder_name, folder_label = spec["folder"]
+    vop_inputs = [item for item in spec["inputs"] if not item.get("ui_only")]
+
+    input_lines = [
+        f"    input {item['vop_type']} {item['name']} {_quote(item['label'])}"
+        for item in vop_inputs
+    ]
+    input_flags = [f"    inputflags {item['name']} 0" for item in vop_inputs]
+    signature_types = " ".join(item["vop_type"] for item in vop_inputs)
+    parms = "\n".join(_parm_dialog(item) for item in spec["inputs"])
+
+    return f"""# Dialog script for Vop::DW_MOONRAY::{class_name}::1 automatically generated
+{{
+    name {_quote(f"Vop::DW_MOONRAY::{class_name}::1")}
+    script {_quote(class_name)}
+    label {_quote(spec['label'])}
+    rendermask moonray
+    shadertype lightfilter
+    externalshader 1
+
+{chr(10).join(input_lines)}
+    output lightfilter filter Filter
+{chr(10).join(input_flags)}
+    signature "Default Inputs" default {{ {signature_types} }}
+
+    help {{
+        {_quote(spec['label'])}
+    }}
+
+    group {{
+        name {_quote(folder_name)}
+        label {_quote(folder_label)}
+{parms}
+    }}
+}}
+"""
+
+
+def generate(output_dir: str | os.PathLike[str] | None = None) -> list[Path]:
+    if output_dir is None:
+        output_dir = Path(__file__).resolve().parents[1] / "otls"
+    output_dir = Path(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    template = hou.nodeType(hou.vopNodeTypeCategory(), TEMPLATE_NODE)
+    if template is None or template.definition() is None:
+        raise RuntimeError(f"Could not find template VOP node {TEMPLATE_NODE}")
+
+    written = []
+    for class_name, spec in LIGHT_FILTERS.items():
+        hda_name = f"Vop::DW_MOONRAY::{class_name}::1"
+        hda_path = output_dir / f"{hda_name}.hda"
+
+        if hda_path.exists():
+            hda_path.unlink()
+
+        template.definition().copyToHDAFile(
+            str(hda_path),
+            new_name=hda_name,
+            new_menu_name=spec["label"],
+        )
+
+        hou.hda.installFile(str(hda_path))
+        node_type = hou.nodeType(hou.vopNodeTypeCategory(), hda_name)
+
+        if node_type is None or node_type.definition() is None:
+            raise RuntimeError(f"Generated HDA did not register {hda_name}")
+
+        definition = node_type.definition()
+
+        definition.addSection("DialogScript", _dialog_script(class_name, spec))
+        definition.addSection("TypePropertiesOptions", TYPE_OPTIONS)
+        definition.addSection("Tools.shelf", TOOLS_SHELF)
+
+        # Critical for Solaris Light Filter Library visibility.
+        # The generated node must belong to the USD light-filter VOP context,
+        # not RIS / RenderMan.
+        definition.setExtraInfo(USD_LIGHTFILTER_EXTRA_INFO)
+
+        definition.setDescription(spec["label"])
+        definition.setIcon("NETWORKS/shop")
+
+        # Persist the edited definition into the HDA file.
+        definition.save(str(hda_path), create_backup=False)
+
+        # Reinstall/requery so validation checks the saved definition.
+        hou.hda.installFile(str(hda_path))
+        node_type = hou.nodeType(hou.vopNodeTypeCategory(), hda_name)
+
+        if node_type is None or node_type.definition() is None:
+            raise RuntimeError(f"Generated HDA disappeared after save: {hda_name}")
+
+        definition = node_type.definition()
+        mask = node_type.vopnetMask()
+        extra_info = definition.extraInfo()
+
+        if mask != "usdlightfilter":
+            raise RuntimeError(
+                f"{hda_name} has wrong vopnetMask {mask!r}; "
+                "expected 'usdlightfilter'"
+            )
+
+        if "risnet" in extra_info.lower():
+            raise RuntimeError(
+                f"{hda_name} still contains RIS extraInfo: {extra_info!r}"
+            )
+
+        if "shadertype=lightfilter" not in extra_info:
+            raise RuntimeError(
+                f"{hda_name} is missing shadertype=lightfilter extraInfo: "
+                f"{extra_info!r}"
+            )
+
+        written.append(hda_path)
+
+    return written
+
+
+if __name__ == "__main__":
+    for path in generate():
+        print(path)
\ No newline at end of file
diff --git a/houdini/python3.11libs/moonray_material_builder.py b/houdini/python3.11libs/moonray_material_builder.py
new file mode 100644
index 0000000..b2f7751
--- /dev/null
+++ b/houdini/python3.11libs/moonray_material_builder.py
@@ -0,0 +1,98 @@
+"""MoonRay Solaris material builder helpers."""
+
+import hou
+import voptoolutils
+
+
+MOONRAY_TAB_MASK = (
+    "moonray parameter constant rampparm collect null subnet "
+    "subnetconnector suboutput subinput genericshader"
+)
+
+
+def _set_if_present(node, parms):
+    existing = {parm.name() for parm in node.parms()}
+    node.setParms({name: value for name, value in parms.items() if name in existing})
+
+
+def _create_output_connector(subnet_node, name, label, parm_type, color, input_node):
+    connector = subnet_node.createNode("subnetconnector", "{}_output".format(name))
+    _set_if_present(
+        connector,
+        {
+            "parmname": name,
+            "parmlabel": label,
+            "parmtype": parm_type,
+            "connectorkind": 1,
+            "useasparmdefiner": 0,
+        },
+    )
+    connector.setColor(hou.Color(color))
+    connector.setInput(0, input_node, 0)
+    return connector
+
+
+def setup_moonray_material_builder(subnet_node):
+    """Configure a plain VOP subnet as a MoonRay-native material builder."""
+
+    subnet_node.setShaderLanguageName("VEX")
+
+    # Match Houdini's MaterialX/Karma builder pattern: a plain editable subnet
+    # carries a Tab Menu Mask and render context, rather than being a locked HDA.
+    voptoolutils._addMtlSubnetParms(  # pylint: disable=protected-access
+        subnet_node,
+        MOONRAY_TAB_MASK,
+        "moonray",
+        "MoonRay Material Builder",
+    )
+
+    suboutput = subnet_node.node("suboutput1")
+    if suboutput is not None:
+        suboutput.destroy()
+
+    subinput = subnet_node.node("subinput1")
+    if subinput is not None:
+        subinput.setName("inputs", unique_name=True)
+
+    surface = subnet_node.createNode(
+        "Vop::DW_MOONRAY::DwaBaseMaterial::1", "dwa_base"
+    )
+    displacement = subnet_node.createNode(
+        "Vop::DW_MOONRAY::NormalDisplacement::1", "normal_displacement"
+    )
+
+    # Keep the default displacement path valid but visually/editably present.
+    _set_if_present(displacement, {"height": 0.0, "height_multiplier": 0.0})
+
+    surface_output = _create_output_connector(
+        subnet_node, "surface", "Surface", 24, (0.89, 0.69, 0.6), surface
+    )
+    displacement_output = _create_output_connector(
+        subnet_node,
+        "displacement",
+        "Displacement",
+        25,
+        (0.6, 0.69, 0.89),
+        displacement,
+    )
+
+    if subinput is not None:
+        subinput.setPosition(hou.Vector2((-6.0, 2.2)))
+    surface.setPosition(hou.Vector2((-1.2, 1.3)))
+    surface_output.setPosition(hou.Vector2((3.8, 1.3)))
+    displacement.setPosition(hou.Vector2((1.7, -2.8)))
+    displacement_output.setPosition(hou.Vector2((3.8, -2.8)))
+
+    subnet_node.setMaterialFlag(True)
+    return subnet_node
+
+
+def create_moonray_material_builder(kwargs, name="moonraymaterial"):
+    """Create the artist-facing MoonRay Material Builder subnet."""
+
+    destination = kwargs.get("node")
+    if destination is not None and not hasattr(hou, "ui"):
+        subnet_node = destination.createNode("subnet", name)
+    else:
+        subnet_node = voptoolutils.genericTool(kwargs, "subnet", name)
+    return setup_moonray_material_builder(subnet_node)
diff --git a/houdini/python3.11libs/moonray_render_settings.py b/houdini/python3.11libs/moonray_render_settings.py
new file mode 100644
index 0000000..296b3ed
--- /dev/null
+++ b/houdini/python3.11libs/moonray_render_settings.py
@@ -0,0 +1,1177 @@
+"""MoonRay Solaris Render Settings authoring and HDA generation."""
+
+from pathlib import Path
+
+import hou
+
+from pxr import Gf, Sdf, UsdRender
+
+
+OPERATOR_TYPE = "Lop::DW_MOONRAY::moonrayrendersettings::1"
+OPERATOR_LABEL = "MoonRay Render Settings"
+RENDER_SETTINGS_PRIM = "/Render/rendersettings"
+RENDER_PRODUCTS_PARENT_PRIM = "/Render/Products"
+RENDER_VARS_PARENT_PRIM = "/Render/Products/Vars"
+RENDER_PRODUCT_NAME = "renderproduct"
+BEAUTY_RENDER_VAR_NAME = "beauty"
+PRODUCT_NAME = "$HIP/render/$HIPNAME.$OS.\\$F4.exr"
+DEFAULT_RESOLUTION = (1920, 1080)
+ROP_NODE_TYPE = "usdrender_rop"
+ROP_RENDERER_TOKEN = "HdMoonrayRendererPlugin"
+ROP_OWNER_LOP_KEY = "moonray_render_settings_lop"
+ROP_OWNER_OPERATOR_KEY = "moonray_render_settings_operator"
+ROP_OWNER_SESSION_KEY = "moonray_render_settings_lop_session_id"
+
+
+AOV_DEFINITIONS = (
+    {
+        "parm": "aov_alpha",
+        "label": "Alpha",
+        "render_var": "alpha",
+        "source_name": "alpha",
+        "data_type": "float",
+        "help": "MoonRay alpha RenderOutput. Production-tested as a native single-channel AOV.",
+    },
+    {
+        "parm": "aov_depth",
+        "label": "Depth",
+        "render_var": "depth",
+        "source_name": "depth",
+        "data_type": "float",
+        "help": "MoonRay depth RenderOutput. In hdMoonray this follows the existing depth mapping.",
+    },
+    {
+        "parm": "aov_z",
+        "label": "Z",
+        "render_var": "Z",
+        "source_name": "Z",
+        "data_type": "float",
+        "help": "MoonRay state-variable depth through the existing Z mapping.",
+    },
+    {
+        "parm": "aov_n",
+        "label": "N",
+        "render_var": "N",
+        "source_name": "N",
+        "data_type": "normal3f",
+        "help": "MoonRay shading normal state variable.",
+    },
+    {
+        "parm": "aov_ng",
+        "label": "Ng",
+        "render_var": "Ng",
+        "source_name": "Ng",
+        "data_type": "normal3f",
+        "help": "MoonRay geometric normal state variable.",
+    },
+    {
+        "parm": "aov_p",
+        "label": "P",
+        "render_var": "P",
+        "source_name": "P",
+        "data_type": "point3f",
+        "help": "MoonRay position state variable.",
+    },
+    {
+        "parm": "aov_wp",
+        "label": "Wp",
+        "render_var": "Wp",
+        "source_name": "Wp",
+        "data_type": "point3f",
+        "help": "MoonRay world-position state variable.",
+    },
+    {
+        "parm": "aov_st",
+        "label": "St",
+        "render_var": "St",
+        "source_name": "St",
+        "data_type": "float2",
+        "help": "MoonRay texture-coordinate state variable.",
+    },
+    {
+        "parm": "aov_weight",
+        "label": "Weight",
+        "render_var": "weight",
+        "source_name": "weight",
+        "data_type": "float",
+        "help": "MoonRay weight RenderOutput. Existing production proof showed a constant sample-count value in the simple fixture.",
+    },
+)
+
+MATERIAL_AOV_DEFINITIONS = (
+    {
+        "parm": "aov_denoise_albedo",
+        "label": "Denoise Albedo",
+        "render_var": "denoise_albedo",
+        "source_name": "D.albedo",
+        "source_type": "shader",
+        "data_type": "color3f",
+        "extra_attrs": {
+            "parameters:moonray:denoiser_input": (Sdf.ValueTypeNames.Token, "as albedo"),
+            "parameters:moonray:channel_suffix_mode": (Sdf.ValueTypeNames.Token, "rgb"),
+            "parameters:moonray:channel_format": (Sdf.ValueTypeNames.Token, "float"),
+        },
+        "help": "Official MoonRay OIDN albedo auxiliary output: material AOV D.albedo tagged as denoiser input.",
+    },
+    {
+        "parm": "aov_denoise_normal",
+        "label": "Denoise Normal",
+        "render_var": "denoise_normal",
+        "source_name": "N",
+        "source_type": "raw",
+        "data_type": "normal3f",
+        "extra_attrs": {
+            "parameters:moonray:denoiser_input": (Sdf.ValueTypeNames.Token, "as normal"),
+            "parameters:moonray:channel_suffix_mode": (Sdf.ValueTypeNames.Token, "rgb"),
+            "parameters:moonray:channel_format": (Sdf.ValueTypeNames.Token, "float"),
+        },
+        "help": "Official MoonRay OIDN normal auxiliary output: state variable N tagged as denoiser input.",
+    },
+    {
+        "parm": "aov_material_albedo",
+        "label": "Material Albedo",
+        "render_var": "material_albedo",
+        "source_name": "albedo",
+        "source_type": "shader",
+        "data_type": "color3f",
+        "help": "MoonRay material AOV albedo expression.",
+    },
+    {
+        "parm": "aov_material_emission",
+        "label": "Material Emission",
+        "render_var": "material_emission",
+        "source_name": "emission",
+        "source_type": "shader",
+        "data_type": "color3f",
+        "help": "MoonRay material AOV emission expression.",
+    },
+    {
+        "parm": "aov_material_normal",
+        "label": "Material Normal",
+        "render_var": "material_normal",
+        "source_name": "normal",
+        "source_type": "shader",
+        "data_type": "normal3f",
+        "extra_attrs": {
+            "parameters:moonray:channel_suffix_mode": (Sdf.ValueTypeNames.Token, "rgb"),
+        },
+        "help": "MoonRay material AOV normal expression.",
+    },
+    {
+        "parm": "aov_material_roughness",
+        "label": "Material Roughness",
+        "render_var": "material_roughness",
+        "source_name": "roughness",
+        "source_type": "shader",
+        "data_type": "float2",
+        "help": "MoonRay material AOV glossy roughness expression.",
+    },
+    {
+        "parm": "aov_material_pbr_validity",
+        "label": "Material PBR Validity",
+        "render_var": "material_pbr_validity",
+        "source_name": "pbr_validity",
+        "source_type": "shader",
+        "data_type": "color3f",
+        "help": "MoonRay material AOV PBR validity diagnostic expression.",
+    },
+)
+
+
+SCENE_VARIABLES = (
+    ("sampling_mode", Sdf.ValueTypeNames.Token),
+    ("light_sampling_mode", Sdf.ValueTypeNames.Token),
+    ("light_sampling_quality", Sdf.ValueTypeNames.Float),
+    ("pixel_samples", Sdf.ValueTypeNames.Int),
+    ("light_samples", Sdf.ValueTypeNames.Int),
+    ("bsdf_samples", Sdf.ValueTypeNames.Int),
+    ("bssrdf_samples", Sdf.ValueTypeNames.Int),
+    ("target_adaptive_error", Sdf.ValueTypeNames.Float),
+    ("min_adaptive_samples", Sdf.ValueTypeNames.Int),
+    ("max_adaptive_samples", Sdf.ValueTypeNames.Int),
+    ("batch_tile_order", Sdf.ValueTypeNames.Token),
+    ("progressive_tile_order", Sdf.ValueTypeNames.Token),
+    ("checkpoint_tile_order", Sdf.ValueTypeNames.Token),
+    ("sample_clamping_value", Sdf.ValueTypeNames.Float),
+    ("sample_clamping_depth", Sdf.ValueTypeNames.Int),
+    ("roughness_clamping_factor", Sdf.ValueTypeNames.Float),
+    ("max_depth", Sdf.ValueTypeNames.Int),
+    ("max_diffuse_depth", Sdf.ValueTypeNames.Int),
+    ("max_glossy_depth", Sdf.ValueTypeNames.Int),
+    ("max_mirror_depth", Sdf.ValueTypeNames.Int),
+    ("max_presence_depth", Sdf.ValueTypeNames.Int),
+    ("max_hair_depth", Sdf.ValueTypeNames.Int),
+    ("max_volume_depth", Sdf.ValueTypeNames.Int),
+    ("max_subsurface_per_path", Sdf.ValueTypeNames.Int),
+    ("russian_roulette_threshold", Sdf.ValueTypeNames.Float),
+    ("transparency_threshold", Sdf.ValueTypeNames.Float),
+    ("presence_threshold", Sdf.ValueTypeNames.Float),
+    ("presence_quality", Sdf.ValueTypeNames.Float),
+    ("lock_frame_noise", Sdf.ValueTypeNames.Bool),
+    ("disable_optimized_hair_sampling", Sdf.ValueTypeNames.Bool),
+    ("volume_quality", Sdf.ValueTypeNames.Float),
+    ("volume_shadow_quality", Sdf.ValueTypeNames.Float),
+    ("volume_illumination_samples", Sdf.ValueTypeNames.Int),
+    ("volume_opacity_threshold", Sdf.ValueTypeNames.Float),
+    ("volume_overlap_mode", Sdf.ValueTypeNames.Token),
+    ("volume_attenuation_factor", Sdf.ValueTypeNames.Float),
+    ("volume_contribution_factor", Sdf.ValueTypeNames.Float),
+    ("volume_phase_attenuation_factor", Sdf.ValueTypeNames.Float),
+    ("volume_indirect_samples", Sdf.ValueTypeNames.Int),
+    ("texture_blur", Sdf.ValueTypeNames.Float),
+    ("pixel_filter_width", Sdf.ValueTypeNames.Float),
+    ("pixel_filter", Sdf.ValueTypeNames.Token),
+    ("enable_dof", Sdf.ValueTypeNames.Bool),
+    ("enable_displacement", Sdf.ValueTypeNames.Bool),
+    ("enable_subsurface_scattering", Sdf.ValueTypeNames.Bool),
+    ("enable_shadowing", Sdf.ValueTypeNames.Bool),
+    ("enable_presence_shadows", Sdf.ValueTypeNames.Bool),
+    ("lights_visible_in_camera", Sdf.ValueTypeNames.Bool),
+    ("propagate_visibility_bounce_type", Sdf.ValueTypeNames.Bool),
+    ("shadow_terminator_fix", Sdf.ValueTypeNames.Token),
+)
+
+
+def _parm(node, name, default=None):
+    parm = node.parm(name)
+    if parm is None:
+        return default
+    return parm.eval()
+
+
+def _string_parm(node, name, default=""):
+    parm = node.parm(name)
+    if parm is None:
+        return default
+    try:
+        return parm.unexpandedString()
+    except hou.OperationFailed:
+        return str(parm.eval())
+
+
+def _path(node, name, default):
+    value = _string_parm(node, name, default).strip()
+    return value or default
+
+
+def _child_path(parent, child):
+    parent_path = Sdf.Path(parent)
+    return str(parent_path.AppendChild(child))
+
+
+def _set_rel_targets(schema_obj, create_rel, paths):
+    valid = [Sdf.Path(path) for path in paths if path]
+    rel = create_rel()
+    rel.SetTargets(valid)
+    return rel
+
+
+def _define_render_var(stage, path, data_type, source_name, source_type="raw", extra_attrs=None):
+    render_var = UsdRender.Var.Define(stage, path)
+    render_var.CreateDataTypeAttr().Set(data_type)
+    render_var.CreateSourceNameAttr().Set(source_name)
+    render_var.CreateSourceTypeAttr().Set(source_type)
+    prim = render_var.GetPrim()
+    prim.CreateAttribute(
+        "driver:parameters:aov:name",
+        Sdf.ValueTypeNames.String,
+        custom=True,
+    ).Set(source_name)
+    prim.CreateAttribute(
+        "driver:parameters:aov:format",
+        Sdf.ValueTypeNames.Token,
+        custom=True,
+    ).Set(data_type)
+    prim.CreateAttribute(
+        "driver:parameters:aov:multiSampled",
+        Sdf.ValueTypeNames.Bool,
+        custom=True,
+    ).Set(False)
+    prim.CreateAttribute(
+        "driver:parameters:aov:clearValue",
+        Sdf.ValueTypeNames.Int,
+        custom=True,
+    ).Set(0)
+    for attr_name, (value_type, value) in (extra_attrs or {}).items():
+        prim.CreateAttribute(attr_name, value_type, custom=True).Set(value)
+    return render_var
+
+
+def _bool_parm(node, name, default=False):
+    parm = node.parm(name)
+    if parm is None:
+        return default
+    return bool(parm.eval())
+
+
+def author_from_node(node=None):
+    """Author USD RenderSettings, RenderProduct, beauty RenderVar, and MoonRay settings."""
+
+    node = node or hou.pwd()
+    stage = node.editableStage()
+
+    settings_path = _path(node, "render_settings_prim", RENDER_SETTINGS_PRIM)
+    products_parent_path = _path(node, "render_products_parent_prim", RENDER_PRODUCTS_PARENT_PRIM)
+    vars_parent_path = _path(node, "render_vars_parent_prim", RENDER_VARS_PARENT_PRIM)
+    product_name = _string_parm(node, "render_product_name", RENDER_PRODUCT_NAME).strip() or RENDER_PRODUCT_NAME
+    beauty_var_name = _string_parm(node, "beauty_render_var_name", BEAUTY_RENDER_VAR_NAME).strip() or BEAUTY_RENDER_VAR_NAME
+    product_path = _child_path(products_parent_path, product_name)
+    beauty_var_path = _child_path(vars_parent_path, beauty_var_name)
+    camera_path = _path(node, "camera", "/cameras/camera1")
+
+    settings = UsdRender.Settings.Define(stage, settings_path)
+    product = UsdRender.Product.Define(stage, product_path)
+
+    _set_rel_targets(settings, settings.CreateProductsRel, [product_path])
+    if camera_path:
+        _set_rel_targets(settings, settings.CreateCameraRel, [camera_path])
+
+    width = int(_parm(node, "resolutionx", DEFAULT_RESOLUTION[0]))
+    height = int(_parm(node, "resolutiony", DEFAULT_RESOLUTION[1]))
+    settings.CreateResolutionAttr().Set(Gf.Vec2i(width, height))
+
+    product_name = _string_parm(node, "product_name", PRODUCT_NAME).strip() or PRODUCT_NAME
+    product.CreateProductNameAttr().Set(product_name)
+    product.CreateProductTypeAttr().Set("raster")
+
+    ordered_vars = []
+    if _bool_parm(node, "aov_beauty", True):
+        _define_render_var(stage, beauty_var_path, "color4f", "color")
+        ordered_vars.append(beauty_var_path)
+    for aov in AOV_DEFINITIONS:
+        if not _bool_parm(node, aov["parm"], False):
+            continue
+        aov_path = _child_path(vars_parent_path, aov["render_var"])
+        _define_render_var(stage, aov_path, aov["data_type"], aov["source_name"])
+        ordered_vars.append(aov_path)
+    for aov in MATERIAL_AOV_DEFINITIONS:
+        if not _bool_parm(node, aov["parm"], False):
+            continue
+        aov_path = _child_path(vars_parent_path, aov["render_var"])
+        _define_render_var(
+            stage,
+            aov_path,
+            aov["data_type"],
+            aov["source_name"],
+            aov.get("source_type", "raw"),
+            aov.get("extra_attrs"),
+        )
+        ordered_vars.append(aov_path)
+    _set_rel_targets(product, product.CreateOrderedVarsRel, ordered_vars)
+
+    settings_prim = settings.GetPrim()
+    for name, value_type in SCENE_VARIABLES:
+        parm = node.parm("sceneVariable_" + name)
+        if parm is None:
+            continue
+        if value_type == Sdf.ValueTypeNames.Token:
+            value = parm.evalAsString()
+        elif value_type == Sdf.ValueTypeNames.Int:
+            value = int(parm.eval())
+        elif value_type == Sdf.ValueTypeNames.Float:
+            value = float(parm.eval())
+        elif value_type == Sdf.ValueTypeNames.Bool:
+            value = bool(parm.eval())
+        settings_prim.CreateAttribute(
+            "moonray:sceneVariable:" + name,
+            value_type,
+            custom=True,
+        ).Set(value)
+
+    rdl_output = _string_parm(node, "rdlOutput", "").strip()
+    if rdl_output:
+        settings_prim.CreateAttribute(
+            "rdlOutput",
+            Sdf.ValueTypeNames.String,
+            custom=True,
+        ).Set(rdl_output)
+
+
+def _safe_node_name(name):
+    return "".join(ch if ch.isalnum() or ch == "_" else "_" for ch in name)
+
+
+def _rop_loppath_target(rop):
+    parm = rop.parm("loppath")
+    if parm is None:
+        return None
+    value = parm.eval()
+    if value.startswith("/"):
+        target = hou.node(value)
+    else:
+        target = rop.node(value)
+        if target is None and rop.parent() is not None:
+            target = rop.parent().node(value)
+    return target.path() if target is not None else value
+
+
+def _owned_rop_for_lop(lop_node):
+    parent = lop_node.parent()
+    if parent is None:
+        return None
+
+    lop_path = lop_node.path()
+    lop_session_id = str(lop_node.sessionId())
+    fallback_by_path = None
+    fallback_by_session = None
+    for rop in parent.children():
+        if rop.type().name() != ROP_NODE_TYPE:
+            continue
+        if rop.userData(ROP_OWNER_OPERATOR_KEY) != OPERATOR_TYPE:
+            continue
+        if rop.userData(ROP_OWNER_LOP_KEY) == lop_path:
+            return rop
+        if rop.userData(ROP_OWNER_SESSION_KEY) == lop_session_id:
+            fallback_by_session = rop
+        elif _rop_loppath_target(rop) == lop_path:
+            fallback_by_path = rop
+    return fallback_by_session or fallback_by_path
+
+
+def _create_owned_rop(lop_node):
+    parent = lop_node.parent()
+    if parent is None:
+        raise hou.OperationFailed("MoonRay Render Settings LOP has no parent network.")
+    base_name = _safe_node_name(lop_node.name() + "_usdrender")
+    existing = parent.node(base_name)
+    if existing is not None:
+        if (
+            existing.type().name() == ROP_NODE_TYPE
+            and existing.userData(ROP_OWNER_OPERATOR_KEY) == OPERATOR_TYPE
+            and existing.userData(ROP_OWNER_LOP_KEY) == lop_node.path()
+        ):
+            return existing
+        rop = parent.createNode(ROP_NODE_TYPE)
+        rop.setName(base_name, unique_name=True)
+        return rop
+    return parent.createNode(ROP_NODE_TYPE, base_name)
+
+
+def _set_hscript_string_expression(parm, expression):
+    value = "`%s`" % expression
+    try:
+        if parm.rawValue() == value:
+            return
+    except hou.OperationFailed:
+        pass
+    parm.set(value)
+
+
+def _chs_expression(node, parm_name):
+    return 'chs("%s/%s")' % (node.path(), parm_name)
+
+
+def create_or_update_usd_render_rop(lop_node=None):
+    """Create or update the USD Render ROP owned by this MoonRay Render Settings LOP."""
+
+    lop_node = lop_node or hou.pwd()
+    rop = _owned_rop_for_lop(lop_node) or _create_owned_rop(lop_node)
+
+    try:
+        rop.setInput(0, lop_node)
+    except hou.OperationFailed:
+        pass
+
+    renderer = rop.parm("renderer")
+    if renderer is not None:
+        renderer.set(ROP_RENDERER_TOKEN)
+
+    loppath = rop.parm("loppath")
+    if loppath is not None:
+        _set_hscript_string_expression(loppath, 'opinput(".", 0)')
+
+    render_settings = rop.parm("rendersettings")
+    if render_settings is not None:
+        _set_hscript_string_expression(render_settings, _chs_expression(lop_node, "render_settings_prim"))
+
+    output_image = rop.parm("outputimage")
+    if output_image is not None:
+        _set_hscript_string_expression(output_image, _chs_expression(lop_node, "product_name"))
+
+    try:
+        rop.setPosition(lop_node.position() + hou.Vector2(0, -1.0))
+    except hou.OperationFailed:
+        pass
+
+    rop.setUserData(ROP_OWNER_LOP_KEY, lop_node.path())
+    rop.setUserData(ROP_OWNER_OPERATOR_KEY, OPERATOR_TYPE)
+    rop.setUserData(ROP_OWNER_SESSION_KEY, str(lop_node.sessionId()))
+    rop.setComment("Owned by %s (%s)." % (lop_node.path(), OPERATOR_TYPE))
+    try:
+        rop.setGenericFlag(hou.nodeFlag.DisplayComment, True)
+    except hou.OperationFailed:
+        pass
+    return rop
+
+
+def _deferred_update_usd_render_rop(session_id):
+    node = hou.nodeBySessionId(session_id)
+    if node is not None and node.type().name() == OPERATOR_TYPE:
+        create_or_update_usd_render_rop(node)
+
+
+def on_created(kwargs):
+    node = kwargs.get("node")
+    if node is not None:
+        try:
+            import hdefereval
+
+            hdefereval.executeDeferred(_deferred_update_usd_render_rop, node.sessionId())
+        except Exception:
+            create_or_update_usd_render_rop(node)
+
+
+def _prim_path_tags(select_existing=False, input_index=None):
+    tags = {
+        "script_action": "import loputils\nloputils.selectPrimsInParm(kwargs, %s)" % (
+            "True" if select_existing else "False"
+        ),
+        "script_action_icon": "BUTTONS_reselect",
+        "sidefx::usdpathtype": "prim",
+    }
+    if input_index is not None:
+        tags["sidefx::usdpathinput"] = str(input_index)
+    return tags
+
+
+def _parm_tags(**tags):
+    return {key: value for key, value in tags.items() if value is not None}
+
+
+def _string_prim_path(name, label, default, help_text, select_existing=False, input_index=None):
+    parm = hou.StringParmTemplate(
+        name,
+        label,
+        1,
+        (default,),
+        string_type=hou.stringParmType.Regular,
+        help=help_text,
+    )
+    parm.setTags(_prim_path_tags(select_existing=select_existing, input_index=input_index))
+    return parm
+
+
+def _label(name, label, text):
+    return hou.LabelParmTemplate(name, label, (text,))
+
+
+def _scene_int(name, label, default, min_value=0, max_value=128, help_text=None):
+    return hou.IntParmTemplate(
+        "sceneVariable_" + name,
+        label,
+        1,
+        (default,),
+        min=min_value,
+        max=max_value,
+        help=help_text or ("MoonRay %s SceneVariable." % name),
+    )
+
+
+def _scene_float(name, label, default, min_value=0.0, max_value=10.0, help_text=None):
+    return hou.FloatParmTemplate(
+        "sceneVariable_" + name,
+        label,
+        1,
+        (default,),
+        min=min_value,
+        max=max_value,
+        help=help_text or ("MoonRay %s SceneVariable." % name),
+    )
+
+
+def _scene_toggle(name, label, default, help_text=None):
+    return hou.ToggleParmTemplate(
+        "sceneVariable_" + name,
+        label,
+        default_value=default,
+        help=help_text or ("MoonRay %s SceneVariable." % name),
+    )
+
+
+def _scene_menu(name, label, tokens, labels, default_token, help_text=None):
+    parm = hou.MenuParmTemplate(
+        "sceneVariable_" + name,
+        label,
+        tokens,
+        labels,
+        default_value=tokens.index(default_token),
+        help=help_text or ("MoonRay %s SceneVariable." % name),
+    )
+    parm.setMenuType(hou.menuType.Normal)
+    return parm
+
+
+TILE_ORDER_TOKENS = (
+    "top",
+    "bottom",
+    "left",
+    "right",
+    "morton",
+    "random",
+    "spiral square",
+    "spiral rect",
+    "morton shiftflip",
+)
+TILE_ORDER_LABELS = (
+    "Top",
+    "Bottom",
+    "Left",
+    "Right",
+    "Morton",
+    "Random",
+    "Spiral Square",
+    "Spiral Rect",
+    "Morton Shift Flip",
+)
+
+
+def _build_parm_template_group():
+    ptg = hou.ParmTemplateGroup()
+
+    render_settings_prim = (
+        _label(
+            "render_prim_note",
+            "",
+            "The primitives MUST be located under the /Render/ primitive to match the USD spec.",
+        ),
+        _string_prim_path(
+            "render_settings_prim",
+            "RenderSettings Primitive Path",
+            RENDER_SETTINGS_PRIM,
+            "USD RenderSettings prim authored by this node. Point USD Render ROP or a future MoonRay ROP at this prim.",
+            input_index=0,
+        ),
+        _string_prim_path(
+            "render_products_parent_prim",
+            "RenderProducts Parent Primitive Path",
+            RENDER_PRODUCTS_PARENT_PRIM,
+            "Parent prim under which the beauty RenderProduct is authored.",
+            select_existing=True,
+            input_index=0,
+        ),
+        _string_prim_path(
+            "render_vars_parent_prim",
+            "RenderVars Parent Primitive Path",
+            RENDER_VARS_PARENT_PRIM,
+            "Parent prim under which the first-pass beauty RenderVar is authored.",
+            select_existing=True,
+            input_index=0,
+        ),
+    )
+    ptg.append(
+        hou.FolderParmTemplate(
+            "render_settings_prim_folder",
+            "Render Settings Prim",
+            render_settings_prim,
+            folder_type=hou.folderType.Collapsible,
+        )
+    )
+
+    output_picture = hou.StringParmTemplate(
+        "product_name",
+        "Output Picture",
+        1,
+        (PRODUCT_NAME,),
+        string_type=hou.stringParmType.FileReference,
+        help="Final raster output path authored as RenderProduct.productName. This is separate from debug RDL/RDLA scene export.",
+    )
+    output_picture.setTags({"filechooser_mode": "write"})
+    ptg.append(output_picture)
+    ptg.append(
+        _string_prim_path(
+            "camera",
+            "Camera",
+            "/cameras/camera1",
+            "Render camera prim targeted by the RenderSettings camera relationship.",
+            input_index=0,
+        )
+    )
+    ptg.append(
+        _label(
+            "resolution_mode_note",
+            "Resolution Mode",
+            "Manual Resolution",
+        )
+    )
+    resolution = hou.IntParmTemplate(
+        "resolution",
+        "Resolution",
+        2,
+        DEFAULT_RESOLUTION,
+        naming_scheme=hou.parmNamingScheme.XYZW,
+        min=1,
+        max=8192,
+        min_is_strict=True,
+        help="Offline husk/USD renders use this resolution through RenderSettings. Viewport/IPR resolution is driven by the viewport.",
+    )
+    ptg.append(resolution)
+    resolution_menu = hou.MenuParmTemplate(
+        "resolutionMenu",
+        "Choose Resolution",
+        (),
+        (),
+        help="Choose a common image resolution.",
+    )
+    resolution_menu.setItemGeneratorScript(
+        'echo `pythonexprs("__import__(\'toolutils\').parseDialogScriptMenu(\'FBres\')")`'
+    )
+    resolution_menu.setItemGeneratorScriptLanguage(hou.scriptLanguage.Hscript)
+    resolution_menu.setMenuType(hou.menuType.Mini)
+    resolution_menu.hideLabel(True)
+    resolution_menu.setTags(
+        {
+            "script_callback": 'opparm . resolution ( `arg("$script_value", 0)` `arg("$script_value", 1)` pixelAspectRatio ( `arg("$script_value", 2)` )'
+        }
+    )
+    ptg.append(resolution_menu)
+    pixel_aspect = hou.FloatParmTemplate(
+        "pixelAspectRatio",
+        "Pixel Aspect Ratio",
+        1,
+        (1.0,),
+        help="Companion value used by Houdini's native resolution preset menu. Pixel aspect authoring is deferred.",
+    )
+    pixel_aspect.hide(True)
+    ptg.append(pixel_aspect)
+    ptg.append(
+        _label(
+            "resolution_note",
+            "Resolution Note",
+            "Offline husk/USD renders use this RenderSettings resolution. Viewport/IPR resolution is driven by the viewport.",
+        )
+    )
+    update_rop = hou.ButtonParmTemplate(
+        "create_update_usd_render_rop",
+        "Create / Update USD Render ROP",
+        help="Create or repair the USD Render ROP owned by this MoonRay Render Settings LOP.",
+    )
+    update_rop.setTags(
+        {
+            "script_callback": "import moonray_render_settings\nmoonray_render_settings.create_or_update_usd_render_rop(hou.pwd())",
+            "script_callback_language": "python",
+        }
+    )
+    ptg.append(update_rop)
+
+    beauty_output = (
+        hou.ToggleParmTemplate(
+            "aov_beauty",
+            "Beauty RenderVar / Disk Output Path",
+            default_value=True,
+            help="Author the Beauty RenderVar required by H20.5 USD Render ROP/husk disk output. Disable only for viewport/default-framebuffer diagnostics.",
+        ),
+        _label(
+            "experimental_aov_note",
+            "AOV Status",
+            "The AOV tab exposes only native RenderBuffer mappings with production filled-pixel proof. Broader material, LPE, visibility, Cryptomatte, primitive-attribute, and motion-vector AOVs remain deferred.",
+        ),
+    )
+
+    render_product = (
+        hou.StringParmTemplate(
+            "render_product_name",
+            "RenderProduct Name",
+            1,
+            (RENDER_PRODUCT_NAME,),
+            help="Advanced name for the default beauty RenderProduct authored under the RenderProducts parent prim.",
+        ),
+        hou.StringParmTemplate(
+            "beauty_render_var_name",
+            "Beauty RenderVar Name",
+            1,
+            (BEAUTY_RENDER_VAR_NAME,),
+            help="Advanced name for the default beauty RenderVar authored under the RenderVars parent prim.",
+        ),
+        _label(
+            "beauty_note",
+            "Beauty Output",
+            "Default disk rendering authors a Beauty RenderVar because H20.5 husk rejects raster RenderProducts with no orderedVars. The internal parameter name remains aov_beauty for compatibility.",
+        ),
+    )
+
+    aov_controls = [
+        _label(
+            "native_aov_note",
+            "Native AOV Scope",
+            "These toggles author fixed USD RenderVars for existing hdMoonray native RenderBuffer mappings. They default off and do not imply material/LPE/Cryptomatte or arbitrary AOV support.",
+        )
+    ]
+    for aov in AOV_DEFINITIONS:
+        aov_controls.append(
+            hou.ToggleParmTemplate(
+                aov["parm"],
+                aov["label"],
+                default_value=False,
+                help=aov["help"],
+            )
+        )
+
+    material_aov_controls = [
+        _label(
+            "material_aov_note",
+            "Material / Denoise AOV Scope",
+            "These toggles author documented MoonRay material AOV and denoiser auxiliary RenderVars. They default off and stay limited to production-proven MoonRay material/state-variable contracts.",
+        )
+    ]
+    for aov in MATERIAL_AOV_DEFINITIONS:
+        material_aov_controls.append(
+            hou.ToggleParmTemplate(
+                aov["parm"],
+                aov["label"],
+                default_value=False,
+                help=aov["help"],
+            )
+        )
+
+    pixel_samples = _scene_int(
+        "pixel_samples",
+        "Pixel Samples",
+        8,
+        max_value=4096,
+        help_text="The square root of the number of primary samples taken for each pixel in uniform sampling mode.",
+    )
+    sampling = [
+        _scene_menu(
+            "sampling_mode",
+            "Sampling Mode",
+            ("uniform", "adaptive"),
+            ("Uniform", "Adaptive"),
+            "uniform",
+            "Controls which sampling scheme to use: uniform or adaptive.",
+        ),
+        _scene_menu(
+            "light_sampling_mode",
+            "Light Sampling Mode",
+            ("uniform", "adaptive"),
+            ("Uniform", "Adaptive"),
+            "uniform",
+            "Controls which light sampling scheme to use: uniform or adaptive.",
+        ),
+        pixel_samples,
+        _scene_int(
+            "light_samples",
+            "Light Samples",
+            2,
+            max_value=4096,
+            help_text="The square root of the number of samples taken for each light on the primary intersection.",
+        ),
+        _scene_int(
+            "bsdf_samples",
+            "BSDF Samples",
+            2,
+            max_value=4096,
+            help_text="The square root of the number of samples taken for BSDF lobe evaluations on the primary intersection.",
+        ),
+        _scene_int(
+            "bssrdf_samples",
+            "BSSRDF Samples",
+            2,
+            max_value=4096,
+            help_text="The square root of the number of samples taken to evaluate BSSRDF contributions on the primary intersection.",
+        ),
+    ]
+    light_sampling_quality = _scene_float(
+        "light_sampling_quality",
+        "Light Sampling Quality",
+        0.5,
+        max_value=1,
+        help_text="When the light sampling mode is adaptive, this controls how many lights are sampled per light sample, where 0.0 is low quality and 1.0 is high quality.",
+    )
+    light_sampling_quality.setConditional(
+        hou.parmCondType.DisableWhen,
+        '{ sceneVariable_light_sampling_mode != "adaptive" }',
+    )
+    sampling.insert(2, light_sampling_quality)
+    pixel_samples.setConditional(hou.parmCondType.DisableWhen, '{ sceneVariable_sampling_mode != "uniform" }')
+    adaptive_cond = '{ sceneVariable_sampling_mode != "adaptive" }'
+    for name, label, default, help_text in (
+        (
+            "sceneVariable_min_adaptive_samples",
+            "Min Adaptive Samples",
+            16,
+            "MoonRay min_adaptive_samples SceneVariable. Used by adaptive sampling.",
+        ),
+        (
+            "sceneVariable_max_adaptive_samples",
+            "Max Adaptive Samples",
+            4096,
+            "MoonRay max_adaptive_samples SceneVariable. Used by adaptive sampling.",
+        ),
+    ):
+        parm = _scene_int(name.replace("sceneVariable_", ""), label, default, max_value=8192, help_text=help_text)
+        parm.setConditional(hou.parmCondType.DisableWhen, adaptive_cond)
+        sampling.append(parm)
+    target_error = _scene_float(
+        "target_adaptive_error",
+        "Target Adaptive Error",
+        10.0,
+        max_value=100.0,
+        help_text="When adaptive sampling is turned on, this represents the desired quality of the output images.",
+    )
+    target_error.setConditional(hou.parmCondType.DisableWhen, adaptive_cond)
+    sampling.append(target_error)
+    sampling.append(
+        _scene_toggle(
+            "lock_frame_noise",
+            "Lock Frame Noise",
+            False,
+            help_text="Use the same random seed from frame to frame instead of considering the frame number.",
+        )
+    )
+
+    tile_order = (
+        _scene_menu(
+            "batch_tile_order",
+            "Batch Tile Order",
+            TILE_ORDER_TOKENS,
+            TILE_ORDER_LABELS,
+            "morton",
+            "Specifies the order in which tiles are prioritized for batch rendering.",
+        ),
+        _scene_menu(
+            "progressive_tile_order",
+            "Progressive Tile Order",
+            TILE_ORDER_TOKENS,
+            TILE_ORDER_LABELS,
+            "morton",
+            "Specifies the order in which tiles are prioritized for progressive rendering.",
+        ),
+        _scene_menu(
+            "checkpoint_tile_order",
+            "Checkpoint Tile Order",
+            TILE_ORDER_TOKENS,
+            TILE_ORDER_LABELS,
+            "morton",
+            "Specifies the order in which tiles are prioritized for checkpoint rendering.",
+        ),
+    )
+
+    ray_depth = []
+    for name, label, default in (
+        ("sceneVariable_max_depth", "Max Ray Depth", 5),
+        ("sceneVariable_max_diffuse_depth", "Max Diffuse Depth", 2),
+        ("sceneVariable_max_glossy_depth", "Max Glossy Depth", 2),
+        ("sceneVariable_max_mirror_depth", "Max Mirror Depth", 3),
+        ("sceneVariable_max_presence_depth", "Max Presence Depth", 16),
+        ("sceneVariable_max_hair_depth", "Max Hair Depth", 5),
+        ("sceneVariable_max_volume_depth", "Max Volume Depth", 1),
+    ):
+        ray_depth.append(
+            _scene_int(
+                name.replace("sceneVariable_", ""),
+                label,
+                default,
+                max_value=128,
+                help_text="MoonRay %s SceneVariable." % name.replace("sceneVariable_", ""),
+            )
+        )
+    ray_depth.extend(
+        (
+            _scene_int(
+                "max_subsurface_per_path",
+                "Max Subsurface Per Path",
+                1,
+                max_value=32,
+                help_text='The maximum ray depth to allow subsurface scattering. For ray depths beyond this limit Lambertian diffuse is used to approximate subsurface scattering.',
+            ),
+            _scene_float(
+                "russian_roulette_threshold",
+                "Russian Roulette Threshold",
+                0.0375,
+                max_value=10,
+                help_text="The Russian roulette threshold specifies the luminance point at which Russian roulette is evaluated for direct light sampling and BSDF continuation.",
+            ),
+            _scene_float(
+                "transparency_threshold",
+                "Transparency Threshold",
+                1.0,
+                max_value=10,
+                help_text="The transparency threshold defines the point at which accumulated opacity can be considered opaque.",
+            ),
+            _scene_float(
+                "presence_threshold",
+                "Presence Threshold",
+                0.999,
+                max_value=10,
+                help_text="The presence threshold defines the point at which accumulated presence can be considered opaque.",
+            ),
+            _scene_float(
+                "presence_quality",
+                "Presence Quality",
+                0.75,
+                max_value=10,
+                help_text="Controls the threshold for stochastic presence sampling along paths.",
+            ),
+        )
+    )
+
+    clamping = (
+        _scene_float(
+            "sample_clamping_value",
+            "Sample Clamping Value",
+            10.0,
+            max_value=100,
+            help_text="Clamp sample radiance values to this maximum value. A value of 0 disables the effect.",
+        ),
+        _scene_int(
+            "sample_clamping_depth",
+            "Sample Clamping Depth",
+            1,
+            max_value=32,
+            help_text="Clamp sample values only after the given non-specular ray depth.",
+        ),
+        _scene_float(
+            "roughness_clamping_factor",
+            "Roughness Clamping Factor",
+            0.0,
+            max_value=10,
+            help_text="Clamp material roughness along paths. A value of 1 clamps values to the maximum roughness encountered, while lower values temper the clamping value. 0 disables the effect. Using this technique reduces fireflies from indirect caustics but is biased.",
+        ),
+    )
+
+    volumes = (
+        _scene_float("volume_quality", "Volume Quality", 0.5, max_value=10, help_text="Controls the overall quality of volume rendering."),
+        _scene_float("volume_shadow_quality", "Volume Shadow Quality", 1.0, max_value=10, help_text="Controls the quality of volume shadow transmittance."),
+        _scene_int("volume_illumination_samples", "Volume Illumination Samples", 4, max_value=128, help_text="Sample number along the ray when computing volume scattering radiance towards the eye. Set to 0 to turn off volume lighting completely."),
+        _scene_float("volume_opacity_threshold", "Volume Opacity Threshold", 0.995, max_value=10, help_text="Stop further volume integration when accumulated opacity exceeds this threshold."),
+        _scene_menu(
+            "volume_overlap_mode",
+            "Volume Overlap Mode",
+            ("sum", "max", "rnd"),
+            ("Sum", "Max", "Random"),
+            "sum",
+            "Selects how to handle contributions from overlapping volumes.",
+        ),
+        _scene_float("volume_attenuation_factor", "Volume Attenuation Factor", 0.65, max_value=10, help_text="Controls how volume attenuation gets exponentially scaled down when rendering multiple scattering volumes."),
+        _scene_float("volume_contribution_factor", "Volume Contribution Factor", 0.65, max_value=10, help_text="Controls how scattering contribution gets exponentially scaled down when rendering multiple scattering volumes."),
+        _scene_float("volume_phase_attenuation_factor", "Volume Phase Attenuation Factor", 0.5, max_value=10, help_text="Controls how phase function anisotropy gets exponentially scaled down when rendering multiple scattering volumes."),
+        _scene_int("volume_indirect_samples", "Volume Indirect Samples", 0, max_value=128, help_text="Number of indirect illumination samples on volumes per primary ray."),
+    )
+
+    filtering = (
+        _scene_float("texture_blur", "Texture Blur", 0.0, max_value=10, help_text="Adjusts the amount of texture filtering."),
+        _scene_float("pixel_filter_width", "Pixel Filter Width", 3.0, max_value=10, help_text="The overall extents, in pixels, of the pixel filter."),
+        _scene_menu(
+            "pixel_filter",
+            "Pixel Filter Type",
+            ("box", "cubic b-spline", "quadratic b-spline"),
+            ("Box", "Cubic B-Spline", "Quadratic B-Spline"),
+            "cubic b-spline",
+            "The type of filter used for filter importance sampling.",
+        ),
+    )
+
+    global_toggles = (
+        _scene_toggle("enable_dof", "Enable DOF", True, help_text="Enables or disables camera depth-of-field."),
+        _scene_toggle("enable_displacement", "Enable Displacement", True, help_text="Enables or disables geometry displacement."),
+        _scene_toggle("enable_subsurface_scattering", "Enable Subsurface Scattering", True, help_text="Enables or disables subsurface scattering."),
+        _scene_toggle("enable_shadowing", "Enable Shadowing", True, help_text="Enables or disables shadowing through occlusion rays."),
+        _scene_toggle("enable_presence_shadows", "Enable Presence Shadows", False, help_text='Whether or not to respect a material\'s "presence" value for shadow rays.'),
+        _scene_toggle("lights_visible_in_camera", "Lights Visible in Camera", False, help_text="Globally enables or disables lights being visible in camera."),
+        _scene_toggle("propagate_visibility_bounce_type", "Propagate Visibility Bounce Type", False, help_text="Turns on/off propagation for ray visibility masks."),
+        _scene_menu(
+            "shadow_terminator_fix",
+            "Shadow Terminator Fix",
+            (
+                "Off",
+                "On",
+                "On (Sine Compensation Alternative)",
+                "On (GGX Compensation Alternative)",
+                "On (Cosine Compensation Alternative)",
+            ),
+            (
+                "Off",
+                "On",
+                "On (Sine Compensation Alternative)",
+                "On (GGX Compensation Alternative)",
+                "On (Cosine Compensation Alternative)",
+            ),
+            "Off",
+            "Attempt to soften hard shadow terminator boundaries due to shading/geometric normal deviations.",
+        ),
+    )
+
+    debug = (
+        _scene_toggle(
+            "disable_optimized_hair_sampling",
+            "Disable Optimized Hair Sampling",
+            False,
+            help_text="Forces all hair materials to sample each hair BSDF lobe independently. This is mainly useful for troubleshooting hair LPE label behavior.",
+        ),
+        hou.StringParmTemplate(
+            "rdlOutput",
+            "Debug RDL/RDLA Output",
+            1,
+            ("",),
+            string_type=hou.stringParmType.FileReference,
+            help="Optional debug scene export path consumed by hdMoonRay rdlOutput. This writes RDL/RDLA scene data, not the final raster image.",
+        ),
+    )
+    debug[0].setTags({"filechooser_mode": "write"})
+
+    ptg.append(
+        hou.FolderParmTemplate(
+            "moonray_settings",
+            "MoonRay Render Settings",
+            (
+                hou.FolderParmTemplate("render_product", "Render Product", tuple(render_product) + beauty_output),
+                hou.FolderParmTemplate("aovs", "AOVs", tuple(aov_controls)),
+                hou.FolderParmTemplate("material_denoise_aovs", "Material / Denoise AOVs", tuple(material_aov_controls)),
+                hou.FolderParmTemplate("sampling", "Sampling", sampling),
+                hou.FolderParmTemplate("tile_order", "Tile Order", tile_order),
+                hou.FolderParmTemplate("ray_depth", "Ray Depth / Path", ray_depth),
+                hou.FolderParmTemplate("clamping", "Clamping / Fireflies", clamping),
+                hou.FolderParmTemplate("volumes", "Volumes", volumes),
+                hou.FolderParmTemplate("filtering", "Filtering / Textures", filtering),
+                hou.FolderParmTemplate("global_toggles", "Global Toggles", global_toggles),
+                hou.FolderParmTemplate("advanced_debug", "Advanced / Debug", tuple(debug)),
+            ),
+            folder_type=hou.folderType.Tabs,
+        )
+    )
+
+    return ptg
+
+
+def regenerate_hda(hda_path):
+    """Regenerate the MoonRay Render Settings HDA from this source module."""
+
+    hda_path = Path(hda_path)
+    hda_path.parent.mkdir(parents=True, exist_ok=True)
+    if hda_path.exists():
+        hda_path.unlink()
+
+    stage = hou.node("/stage") or hou.node("/").createNode("lopnet", "stage")
+    source = stage.createNode("pythonscript", "moonrayrendersettings_src")
+    source.parm("python").set(
+        "import hou\n"
+        "import moonray_render_settings\n\n"
+        "moonray_render_settings.author_from_node(hou.pwd())\n"
+    )
+
+    hda_node = source.createDigitalAsset(
+        name=OPERATOR_TYPE,
+        hda_file_name=str(hda_path),
+        description=OPERATOR_LABEL,
+        min_num_inputs=0,
+        max_num_inputs=1,
+        ignore_external_references=True,
+    )
+    definition = hda_node.type().definition()
+    definition.setComment(
+        "Authors an artist-friendly USD RenderSettings/RenderProduct setup and curated hdMoonRay moonray:sceneVariable settings."
+    )
+    definition.setParmTemplateGroup(_build_parm_template_group())
+    definition.addSection(
+        "OnCreated",
+        "import moonray_render_settings\n"
+        "moonray_render_settings.on_created(kwargs)\n",
+    )
+    definition.setExtraFileOption("OnCreated/IsPython", True)
+    try:
+        definition.setIcon("ROP_usdrender")
+    except hou.OperationFailed:
+        pass
+    definition.updateFromNode(hda_node)
+    hda_node.destroy()
+    return str(hda_path)
diff --git a/houdini/python3.11libs/moonray_vopmask_check.py b/houdini/python3.11libs/moonray_vopmask_check.py
new file mode 100644
index 0000000..1ba90ef
--- /dev/null
+++ b/houdini/python3.11libs/moonray_vopmask_check.py
@@ -0,0 +1,58 @@
+"""Validate MoonRay VOP network masks in Houdini.
+
+Run with Houdini's hython after sourcing the OpenMoonRay Houdini setup:
+
+    hython moonray_vopmask_check.py
+
+The script is intentionally read-only. It verifies that DW_MOONRAY VOP
+definitions include the MaterialX token in their vopnetMask/extraInfo so the
+installed definitions are usable inside MaterialX VOP contexts without a
+post-install HOM patch.
+"""
+
+from __future__ import print_function
+
+import sys
+
+import hou
+
+
+TOKEN = "MaterialX"
+TYPE_MARKER = "DW_MOONRAY"
+
+
+def main():
+    category = hou.vopNodeTypeCategory()
+    missing = []
+    checked = 0
+
+    for type_name, node_type in sorted(category.nodeTypes().items()):
+        if TYPE_MARKER not in type_name:
+            continue
+
+        checked += 1
+        definition = node_type.definition()
+        extra_info = definition.extraInfo() if definition else ""
+        mask = node_type.vopnetMask()
+
+        if TOKEN not in mask and TOKEN not in extra_info:
+            missing.append((type_name, mask, extra_info,
+                            definition.libraryFilePath() if definition else ""))
+
+    print("DW_MOONRAY VOP definitions checked:", checked)
+    print("Definitions missing MaterialX:", len(missing))
+
+    for type_name, mask, extra_info, path in missing[:80]:
+        print("MISSING:", type_name,
+              "mask={!r}".format(mask),
+              "extraInfo={!r}".format(extra_info),
+              "path={}".format(path))
+
+    if len(missing) > 80:
+        print("... and {} more".format(len(missing) - 80))
+
+    return 1 if missing else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/houdini/python3.11libs/moonray_vopmask_materialx_patch.py b/houdini/python3.11libs/moonray_vopmask_materialx_patch.py
new file mode 100644
index 0000000..292f06e
--- /dev/null
+++ b/houdini/python3.11libs/moonray_vopmask_materialx_patch.py
@@ -0,0 +1,90 @@
+"""Add MaterialX to source DW_MOONRAY VOP HDA masks.
+
+This is a source-definition maintenance helper. Run it with Houdini's hython
+against the source otls directory before install-time packaging if regenerated
+HDAs lose the MaterialX VOP context token:
+
+    hython moonray_vopmask_materialx_patch.py /path/to/houdini/otls
+
+It updates the HDA files in-place so installed definitions do not need a manual
+post-install HOM patch.
+"""
+
+from __future__ import print_function
+
+import os
+import sys
+
+import hou
+
+
+TOKEN = "MaterialX"
+TYPE_MARKER = "DW_MOONRAY"
+
+
+def _with_materialx(extra_info):
+    parts = extra_info.split()
+    if TOKEN in parts:
+        return extra_info
+    if not parts:
+        return extra_info
+    if parts[0] == "*":
+        parts.insert(1, TOKEN)
+    elif "moonray" in parts:
+        parts.insert(parts.index("moonray"), TOKEN)
+    else:
+        parts.append(TOKEN)
+    return " ".join(parts)
+
+
+def main(argv):
+    if len(argv) != 2:
+        print("Usage: hython {} /path/to/houdini/otls".format(argv[0]))
+        return 2
+
+    otls_dir = argv[1]
+    if not os.path.isdir(otls_dir):
+        print("Not a directory:", otls_dir)
+        return 2
+
+    changed = []
+    skipped = []
+
+    for filename in sorted(os.listdir(otls_dir)):
+        if TYPE_MARKER not in filename or not filename.endswith((".hda", ".otl")):
+            continue
+
+        hda_path = os.path.join(otls_dir, filename)
+        hou.hda.installFile(hda_path)
+        definitions = hou.hda.definitionsInFile(hda_path)
+
+        for definition in definitions:
+            node_type = definition.nodeType()
+            type_name = node_type.nameWithCategory()
+            if TYPE_MARKER not in type_name:
+                continue
+
+            old_info = definition.extraInfo()
+            new_info = _with_materialx(old_info)
+            if new_info == old_info:
+                skipped.append(type_name)
+                continue
+
+            definition.setExtraInfo(new_info)
+            definition.save(hda_path, create_backup=False)
+            changed.append((type_name, old_info, new_info, hda_path))
+
+    print("Changed:", len(changed))
+    print("Skipped:", len(skipped))
+    for type_name, old_info, new_info, hda_path in changed[:80]:
+        print("CHANGED:", type_name,
+              repr(old_info), "->", repr(new_info),
+              hda_path)
+    if len(changed) > 80:
+        print("... and {} more".format(len(changed) - 80))
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))
diff --git a/houdini/python3.11libs/pythonrc.py b/houdini/python3.11libs/pythonrc.py
new file mode 100644
index 0000000..cd296d9
--- /dev/null
+++ b/houdini/python3.11libs/pythonrc.py
@@ -0,0 +1,30 @@
+# Copyright 2023-2024 DreamWorks Animation LLC
+# SPDX-License-Identifier: Apache-2.0
+
+# Temporary solution to force houdini to load moonrayLight.ds.
+# Remove this file once moonray hydra render delegate is available
+import hou
+
+import loputils
+
+
+def addRendererParmFolders(node, parmgroup):
+    if not loputils:
+        return
+    names = hou.lop.availableRendererNames()
+    labels = hou.lop.availableRendererLabels()
+    new_names = ["moonray"] + list(names)
+    new_labels = ["Moonray"] + list(labels)
+
+    for name, label in zip(new_names, new_labels):
+        try:
+            dspath = hou.findFile('soho/parameters/%s_%s.ds'
+                                        % (name, parmgroup))
+        except hou.OperationFailed:
+            continue
+
+        loputils.addDialogScriptFolder(dspath, node, label)
+
+
+if loputils:
+    loputils.addRendererParmFolders = addRendererParmFolders
diff --git a/houdini/soho/parameters/HdMoonrayRendererPlugin_Geometry.ds b/houdini/soho/parameters/HdMoonrayRendererPlugin_Geometry.ds
index dbb1c41..005578f 100644
--- a/houdini/soho/parameters/HdMoonrayRendererPlugin_Geometry.ds
+++ b/houdini/soho/parameters/HdMoonrayRendererPlugin_Geometry.ds
@@ -515,4 +515,237 @@
         }
     }
 
+    group {
+        name    "folder_mesh"
+        label   "Mesh Tessellation"
+
+        parm {
+            name    "xn__primvarsmoonrayis_subd_control_zpbh"
+            label   "primvars:moonray:is_subd"
+            type    string
+            default { "none" }
+            menujoin {
+                "set"           "![BUTTONS_set_or_create]Set or Create"
+                "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
+                "block"         "![BUTTONS_set_block]Block"
+                "none"          "![BUTTONS_set_nothing]Do Nothing"
+            }
+            parmtag { "sidefx::look" "icon" }
+        }
+        parm {
+            name    "xn__primvarsmoonrayis_subd_ycbh"
+            label   "Is Subd"
+            type    toggle
+            default { "1" }
+            help    "If true, a SubdivisionMesh primitive will be created; otherwise a PolygonMesh primitive will be created."
+            disablewhen "{ xn__primvarsmoonrayis_subd_control_zpbh == block } { xn__primvarsmoonrayis_subd_control_zpbh == none }"
+            parmtag { "usdvaluetype" "bool" }
+        }
+
+        parm {
+            name    "xn__primvarsmoonraysubd_scheme_control_iwbh"
+            label   "primvars:moonray:subd_scheme"
+            type    string
+            default { "none" }
+            menujoin {
+                "set"           "![BUTTONS_set_or_create]Set or Create"
+                "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
+                "add"           "![BUTTONS_set_add]Add if Exists"
+                "multiply"      "![BUTTONS_set_multiply]Multiply if Exists"
+                "block"         "![BUTTONS_set_block]Block"
+                "none"          "![BUTTONS_set_nothing]Do Nothing"
+            }
+            parmtag { "sidefx::look" "icon" }
+        }
+        parm {
+            name    "xn__primvarsmoonraysubd_scheme_hjbh"
+            label   "Subd Scheme"
+            type    string
+            default { "catclark" }
+            help    "MoonRay subdivision scheme. USD Loop subdivision is not supported by hdMoonray and is treated as Catmull-Clark."
+            disablewhen "{ xn__primvarsmoonraysubd_scheme_control_iwbh == block } { xn__primvarsmoonraysubd_scheme_control_iwbh == none }"
+            menu {
+                "bilinear"  "Bilinear"
+                "catclark"  "Catmull-Clark"
+            }
+            parmtag { "usdvaluetype" "token" }
+        }
+
+        parm {
+            name    "xn__primvarsmoonraysubd_boundary_control_rzbh"
+            label   "primvars:moonray:subd_boundary"
+            type    string
+            default { "none" }
+            menujoin {
+                "set"           "![BUTTONS_set_or_create]Set or Create"
+                "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
+                "add"           "![BUTTONS_set_add]Add if Exists"
+                "multiply"      "![BUTTONS_set_multiply]Multiply if Exists"
+                "block"         "![BUTTONS_set_block]Block"
+                "none"          "![BUTTONS_set_nothing]Do Nothing"
+            }
+            parmtag { "sidefx::look" "icon" }
+        }
+        parm {
+            name    "xn__primvarsmoonraysubd_boundary_qmbh"
+            label   "Subd Boundary"
+            type    string
+            default { "edge and corner" }
+            help    "Boundary interpolation for subdivision meshes."
+            disablewhen "{ xn__primvarsmoonraysubd_boundary_control_rzbh == block } { xn__primvarsmoonraysubd_boundary_control_rzbh == none }"
+            menu {
+                "none"              "None"
+                "edge only"         "Edge Only"
+                "edge and corner"   "Edge And Corner"
+            }
+            parmtag { "usdvaluetype" "token" }
+        }
+
+        parm {
+            name    "xn__primvarsmoonraysubd_fvar_linear_control_n4bh"
+            label   "primvars:moonray:subd_fvar_linear"
+            type    string
+            default { "none" }
+            menujoin {
+                "set"           "![BUTTONS_set_or_create]Set or Create"
+                "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
+                "add"           "![BUTTONS_set_add]Add if Exists"
+                "multiply"      "![BUTTONS_set_multiply]Multiply if Exists"
+                "block"         "![BUTTONS_set_block]Block"
+                "none"          "![BUTTONS_set_nothing]Do Nothing"
+            }
+            parmtag { "sidefx::look" "icon" }
+        }
+        parm {
+            name    "xn__primvarsmoonraysubd_fvar_linear_mrbh"
+            label   "Subd Fvar Linear"
+            type    string
+            default { "corners only" }
+            help    "Face-varying linear interpolation for subdivision meshes."
+            disablewhen "{ xn__primvarsmoonraysubd_fvar_linear_control_n4bh == block } { xn__primvarsmoonraysubd_fvar_linear_control_n4bh == none }"
+            menu {
+                "none"          "None"
+                "corners only"  "Corners Only"
+                "corners plus1" "Corners Plus1"
+                "corners plus2" "Corners Plus2"
+                "boundaries"    "Boundaries"
+                "all"           "All"
+            }
+            parmtag { "usdvaluetype" "token" }
+        }
+
+        parm {
+            name    "xn__primvarsmoonraymesh_resolution_control_02bh"
+            label   "primvars:moonray:mesh_resolution"
+            type    string
+            default { "none" }
+            menujoin {
+                "set"           "![BUTTONS_set_or_create]Set or Create"
+                "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
+                "add"           "![BUTTONS_set_add]Add if Exists"
+                "multiply"      "![BUTTONS_set_multiply]Multiply if Exists"
+                "block"         "![BUTTONS_set_block]Block"
+                "none"          "![BUTTONS_set_nothing]Do Nothing"
+            }
+            parmtag { "sidefx::look" "icon" }
+        }
+        parm {
+            name    "xn__primvarsmoonraymesh_resolution_zpbh"
+            label   "Mesh Resolution"
+            type    float
+            default { "2.0" }
+            help    "Maximum resolution for mesh tessellation. With adaptive tessellation this caps the tessellation level."
+            disablewhen "{ xn__primvarsmoonraymesh_resolution_control_02bh == block } { xn__primvarsmoonraymesh_resolution_control_02bh == none }"
+            range   { 0 10 }
+            parmtag { "usdvaluetype" "float" }
+        }
+
+        parm {
+            name    "xn__primvarsmoonrayadaptive_error_control_e1bh"
+            label   "primvars:moonray:adaptive_error"
+            type    string
+            default { "none" }
+            menujoin {
+                "set"           "![BUTTONS_set_or_create]Set or Create"
+                "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
+                "add"           "![BUTTONS_set_add]Add if Exists"
+                "multiply"      "![BUTTONS_set_multiply]Multiply if Exists"
+                "block"         "![BUTTONS_set_block]Block"
+                "none"          "![BUTTONS_set_nothing]Do Nothing"
+            }
+            parmtag { "sidefx::look" "icon" }
+        }
+        parm {
+            name    "xn__primvarsmoonrayadaptive_error_dobh"
+            label   "Adaptive Error"
+            type    float
+            default { "0.0" }
+            help    "Maximum allowable pixel error for adaptive subdivision tessellation. A value of 0 disables adaptive tessellation."
+            disablewhen "{ xn__primvarsmoonrayadaptive_error_control_e1bh == block } { xn__primvarsmoonrayadaptive_error_control_e1bh == none }"
+            range   { 0 10 }
+            parmtag { "usdvaluetype" "float" }
+        }
+
+        parm {
+            name    "xn__primvarsmoonraysmooth_normal_control_rzbh"
+            label   "primvars:moonray:smooth_normal"
+            type    string
+            default { "none" }
+            menujoin {
+                "set"           "![BUTTONS_set_or_create]Set or Create"
+                "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
+                "block"         "![BUTTONS_set_block]Block"
+                "none"          "![BUTTONS_set_nothing]Do Nothing"
+            }
+            parmtag { "sidefx::look" "icon" }
+        }
+        parm {
+            name    "xn__primvarsmoonraysmooth_normal_qmbh"
+            label   "Smooth Normal"
+            type    toggle
+            default { "1" }
+            help    "Generate smooth shading normals on polygon meshes when the mesh does not provide shading normals."
+            disablewhen "{ xn__primvarsmoonraysmooth_normal_control_rzbh == block } { xn__primvarsmoonraysmooth_normal_control_rzbh == none }"
+            parmtag { "usdvaluetype" "bool" }
+        }
+    }
+
+    group {
+        name    "folder_motion"
+        label   "Motion Blur"
+
+        parm {
+            name    "xn__primvarsmoonraymotion_blur_type_control_n4bh"
+            label   "primvars:moonray:motion_blur_type"
+            type    string
+            default { "none" }
+            menujoin {
+                "set"           "![BUTTONS_set_or_create]Set or Create"
+                "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
+                "add"           "![BUTTONS_set_add]Add if Exists"
+                "multiply"      "![BUTTONS_set_multiply]Multiply if Exists"
+                "block"         "![BUTTONS_set_block]Block"
+                "none"          "![BUTTONS_set_nothing]Do Nothing"
+            }
+            parmtag { "sidefx::look" "icon" }
+        }
+        parm {
+            name    "xn__primvarsmoonraymotion_blur_type_mrbh"
+            label   "Motion Blur Type"
+            type    string
+            default { "best" }
+            help    "Motion blur method for MoonRay mesh, curve, and point geometry when motion samples or velocity data are present."
+            disablewhen "{ xn__primvarsmoonraymotion_blur_type_control_n4bh == block } { xn__primvarsmoonraymotion_blur_type_control_n4bh == none }"
+            menu {
+                "best"          "Best"
+                "static"        "Static"
+                "velocity"      "Velocity"
+                "frame delta"   "Frame Delta"
+                "acceleration"  "Acceleration"
+                "hermite"       "Hermite"
+            }
+            parmtag { "usdvaluetype" "token" }
+        }
+    }
+
 }
diff --git a/houdini/soho/parameters/HdMoonrayRendererPlugin_Global.ds b/houdini/soho/parameters/HdMoonrayRendererPlugin_Global.ds
index 3133669..6a03317 100644
--- a/houdini/soho/parameters/HdMoonrayRendererPlugin_Global.ds
+++ b/houdini/soho/parameters/HdMoonrayRendererPlugin_Global.ds
@@ -1161,7 +1161,7 @@
             name    "xn__moonraysceneVariablesample_clamping_value_v7bn"
             label   "Sample Clamping Value"
             type    float
-            default { "10" }
+            default { "10.0" }
             help    "Clamp sample radiance values to this maximum value (the feature is disabled if the value is 0.0). Using this technique reduces fireflies, but is biased."
             disablewhen "{ xn__moonraysceneVariablesample_clamping_value_control_wlcn == block } { xn__moonraysceneVariablesample_clamping_value_control_wlcn == none }"
             range   { 0 10 }
@@ -2693,7 +2693,7 @@
         name    "xn__moonraysceneVariabletarget_adaptive_error_v7bn"
         label   "Target Adaptive Error"
         type    float
-        default { "10" }
+        default { "10.0" }
         help    "When adaptive sampling is turned on, this represents the desired quality of the output images. Lower values will give higher quality but take longer to render. Higher values will give lower quality but render quicker."
         disablewhen "{ xn__moonraysceneVariabletarget_adaptive_error_control_wlcn == block } { xn__moonraysceneVariabletarget_adaptive_error_control_wlcn == none }"
         range   { 0 10 }
diff --git a/houdini/soho/parameters/HdMoonrayRendererPlugin_Light.ds b/houdini/soho/parameters/HdMoonrayRendererPlugin_Light.ds
index f1582e1..5bfd515 100644
--- a/houdini/soho/parameters/HdMoonrayRendererPlugin_Light.ds
+++ b/houdini/soho/parameters/HdMoonrayRendererPlugin_Light.ds
@@ -7,7 +7,7 @@
         label   "moonray:class"
         type    string
         invisible
-        default { "set" }
+        default { "none" }
         menujoin {
             "set"           "![BUTTONS_set_or_create]Set or Create"
             "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
@@ -21,21 +21,21 @@
         label   "class"
         type    string
         invisible
-        default { [ "\n        parm = hou.parm(\"lighttype\")\n        if parm:\n            value = parm.eval()\n            label = parm.menuLabels()[value]\n            if label == \"Geometry\":\n                label = \"Mesh\"\n            elif label == \"Rectangle\":\n                label = \"Rect\"\n            return label + \"Light\"\n        else:\n            parm = hou.parm(\"primtype\")\n            value = parm.eval()\n            if value == \"UsdLuxDomeLight\":\n                return \"EnvLight\"\n        " python ] }
+        default { [ "\n        parm = hou.parm(\"lighttype\")\n        if parm:\n            value = parm.eval()\n            label = parm.menuLabels()[value]\n            if label == \"Geometry\":\n                label = \"Mesh\"\n            elif label == \"Point\":\n                label = \"Sphere\"\n            elif label == \"Rectangle\":\n                label = \"Rect\"\n            return label + \"Light\"\n        else:\n            parm = hou.parm(\"primtype\")\n            value = parm.eval()\n            if value in (\"UsdLuxDomeLight\", \"UsdLuxDomeLight_1\", \"DomeLight_1\"):\n                return \"EnvLight\"\n        " python ] }
         disablewhen "{ xn__moonrayclass_control_o8a == block } { xn__moonrayclass_control_o8a == none }"
         parmtag { "usdvaluetype" "token" }
     }
     group {
         name    "folder"
         label   "Properties"
-        hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+        hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
 
         parm {
             name    "xn__moonrayon_control_s3a"
             label   "moonray:on"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "![BUTTONS_set_or_create]Set or Create"
                 "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
@@ -51,7 +51,7 @@
             default { "1" }
             help    "Whether the light is switched on."
             disablewhen "{ xn__moonrayon_control_s3a == block } { xn__moonrayon_control_s3a == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             parmtag { "usdvaluetype" "bool" }
         }
         parm {
@@ -59,7 +59,7 @@
             label   "moonray:mb"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "![BUTTONS_set_or_create]Set or Create"
                 "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
@@ -75,7 +75,7 @@
             default { "0" }
             help    "Whether motion-blur is active for this light. When set to true, the scene's illumination will correctly account for any blur() applied to the light's transformation matrix."
             disablewhen "{ xn__moonraymb_control_s3a == block } { xn__moonraymb_control_s3a == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             parmtag { "usdvaluetype" "bool" }
         }
         parm {
@@ -83,7 +83,7 @@
             label   "moonray:visible_in_camera"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "![BUTTONS_set_or_create]Set or Create"
                 "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
@@ -101,7 +101,7 @@
             default { "use default" }
             help    "Whether the light is directly visible in the scene's active camera. When set to \"use default\" it reads from the value of SceneVariable lights_visible_in_camera."
             disablewhen "{ xn__moonrayvisible_in_camera_control_7sb == block } { xn__moonrayvisible_in_camera_control_7sb == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menu {
                 "force off"     "Force Off"
                 "force on"      "Force On"
@@ -114,7 +114,7 @@
             label   "moonray:max_shadow_distance"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "![BUTTONS_set_or_create]Set or Create"
                 "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
@@ -132,7 +132,7 @@
             default { "0" }
             help    "The distance from the light beyond which a light-receiving surface will no longer receive shadows cast from that light.\nNote that the distance is thresholded for each occlusion ray cast for this light, it is possible for a receiving point to lie at an intermediate distance such that some parts of the light are closer than the threshold distance and other parts beyond it, in which case the point will appearto be in partial shadow."
             disablewhen "{ xn__moonraymax_shadow_distance_control_hwb == block } { xn__moonraymax_shadow_distance_control_hwb == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             range   { 0 10 }
             parmtag { "usdvaluetype" "float" }
         }
@@ -141,7 +141,7 @@
             label   "moonray:min_shadow_distance"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "![BUTTONS_set_or_create]Set or Create"
                 "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
@@ -159,7 +159,7 @@
             default { "0" }
             help    "The distance from the light before which a light-receiving surface will no longer receive shadows cast from that light.\nNote that the distance is thresholded for each occlusion ray cast for this light, it is possible for a receiving point to lie at an intermediate distance such that some parts of the light are closer than the threshold distance and other parts beyond it, in which case the point will appearto be in partial shadow."
             disablewhen "{ xn__moonraymin_shadow_distance_control_hwb == block } { xn__moonraymin_shadow_distance_control_hwb == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             range   { 0 10 }
             parmtag { "usdvaluetype" "float" }
         }
@@ -168,7 +168,7 @@
             label   "moonray:presence_shadows"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "![BUTTONS_set_or_create]Set or Create"
                 "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
@@ -186,7 +186,7 @@
             default { "use default" }
             help    "Switch this attribute on for shadows cast from this light to correctly respect presence values. When off, surfaces with a material with presence less than 1.0 will cast opaque shadows from this light. This is an optimization - when the attribute is off, occlusion rays (fast) are used for testing for shadows. When it is on, regular rays (slower) are used, and the material's presence is evaluated to determine how much shadowing should occur. When set to \"use default\" it reads from the value of SceneVariable enable_presence_shadows."
             disablewhen "{ xn__moonraypresence_shadows_control_lrb == block } { xn__moonraypresence_shadows_control_lrb == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menu {
                 "force off"     "Force Off"
                 "force on"      "Force On"
@@ -199,7 +199,7 @@
             label   "moonray:ray_termination"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "![BUTTONS_set_or_create]Set or Create"
                 "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
@@ -215,7 +215,7 @@
             default { "0" }
             help    "Whether the light is used for ray termination color. Ray termination color is used for filling in falsely dark areas where ray paths have been terminated too early by the depth controls. Such a ray path immediately exits to any ray termination light(s) present in the light set being applied to the lobe, ignoring occlusion by scene geometry. Any light can either be a regular light or a ray termination light (but not both). Thus they can be freely assigned to light sets, which provides a mechanism for applying specific ray termination lights to specific materials, parts or objects. Ray termination color is only applied to non-hair transmission lobes."
             disablewhen "{ xn__moonrayray_termination_control_ypb == block } { xn__moonrayray_termination_control_ypb == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             parmtag { "usdvaluetype" "bool" }
         }
         parm {
@@ -223,7 +223,7 @@
             label   "moonray:texture_filter"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "![BUTTONS_set_or_create]Set or Create"
                 "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
@@ -241,7 +241,7 @@
             default { "nearest neighbor" }
             help    "The filtering mode to apply to the texture. Nearest neighbor is the cheapest filtering mode but produces a blocky result. Switch linear filtering on for a smoother result. Additionally, mip-mapping can be switched on with either nearest neighbor or linear filtering."
             disablewhen "{ xn__moonraytexture_filter_control_cob == block } { xn__moonraytexture_filter_control_cob == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menu {
                 "nearest neighbor"                  "Nearest Neighbor"
                 "bilinear"                          "Bilinear"
@@ -255,7 +255,7 @@
             label   "moonray:label"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "![BUTTONS_set_or_create]Set or Create"
                 "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
@@ -271,7 +271,7 @@
             default { "" }
             help    "Label used in light aov expressions."
             disablewhen "{ xn__moonraylabel_control_o8a == block } { xn__moonraylabel_control_o8a == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             parmtag { "usdvaluetype" "string" }
         }
         parm {
@@ -519,7 +519,7 @@
             label   "moonray:color"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "![BUTTONS_set_or_create]Set or Create"
                 "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
@@ -538,7 +538,7 @@
             default { "1" "1" "1" }
             help    "The light's RGB values.\nThese are combined multiplicatively with the intensity and other attributes in determining the light's 3-channel radiance."
             disablewhen "{ xn__moonraycolor_control_o8a == block } { xn__moonraycolor_control_o8a == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             range   { 0 10 }
             parmtag { "usdvaluetype" "color3f" }
         }
@@ -547,7 +547,7 @@
             label   "moonray:intensity"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "![BUTTONS_set_or_create]Set or Create"
                 "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
@@ -565,7 +565,7 @@
             default { "1" }
             help    "The light's intensity.\nThis is combined multiplicatively with the color and other attributes in determining the light's 3-channel radiance."
             disablewhen "{ xn__moonrayintensity_control_6fb == block } { xn__moonrayintensity_control_6fb == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             range   { 0 10 }
             parmtag { "usdvaluetype" "float" }
         }
@@ -574,7 +574,7 @@
             label   "moonray:exposure"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "![BUTTONS_set_or_create]Set or Create"
                 "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
@@ -592,7 +592,7 @@
             default { "0" }
             help    "The light's exposure value.\nThis value provides an alternative to the intensity value as a mechanism for controlling the light's overall brightness, and is inspired by the corresponding photographic term but is generalised to apply independently to each light. To calculate its effect, pow(2, exposure) is combined multiplicatively with the color and other attributes in determining the light's 3-channel radiance."
             disablewhen "{ xn__moonrayexposure_control_keb == block } { xn__moonrayexposure_control_keb == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             range   { 0 10 }
             parmtag { "usdvaluetype" "float" }
         }
@@ -680,14 +680,14 @@
     group {
         name    "folder2"
         label   "Map"
-        hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+        hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
 
         parm {
             name    "xn__moonraytexture_control_xcb"
             label   "moonray:texture"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "![BUTTONS_set_or_create]Set or Create"
                 "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
@@ -703,7 +703,7 @@
             default { "" }
             help    "File name of the texture applied to the light. If set to the empty string, no texture is applied. Any file format supported by OpenImageIO can be used. The texture is used in 2 ways - for looking up the texture value at the intersection point when a ray hits the light, and for building a lookup-table-based auxilliary data structure used for distributing light samples over the texture."
             disablewhen "{ xn__moonraytexture_control_xcb == block } { xn__moonraytexture_control_xcb == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             parmtag { "usdvaluetype" "asset" }
         }
         parm {
@@ -711,7 +711,7 @@
             label   "moonray:saturation"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "![BUTTONS_set_or_create]Set or Create"
                 "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
@@ -730,7 +730,7 @@
             default { "1" "1" "1" }
             help    "Per-channel saturation used in color-correcting the light's texture, if one is present. This is achieved by applying the following formula for each channel:\n  output = lerp(luminance(inputRGB), input, saturation)."
             disablewhen "{ xn__moonraysaturation_control_thb == block } { xn__moonraysaturation_control_thb == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             range   { 0 10 }
             parmtag { "usdvaluetype" "color3f" }
         }
@@ -739,7 +739,7 @@
             label   "moonray:contrast"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "![BUTTONS_set_or_create]Set or Create"
                 "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
@@ -758,7 +758,7 @@
             default { "1" "1" "1" }
             help    "Per-channel contrast used in color-correcting the light's texture, if one is present. The operation mimics Nuke's ColorCorrect node's contrast function:\n  For input >  0, output = 0.18 * pow(inputCompnent/0.18, contrast).\n  For input <= 0, output = 0.18 * input * pow(1/0.18, contrast)."
             disablewhen "{ xn__moonraycontrast_control_keb == block } { xn__moonraycontrast_control_keb == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             range   { 0 10 }
             parmtag { "usdvaluetype" "color3f" }
         }
@@ -767,7 +767,7 @@
             label   "moonray:gamma"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "![BUTTONS_set_or_create]Set or Create"
                 "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
@@ -786,7 +786,7 @@
             default { "1" "1" "1" }
             help    "Per-channel gamma used in color-correcting the light's texture, if one is present. This is achieved by applying the following formula for each channel:\n  For input >  0, output = pow(input, gamma)\n  For input <= 0, output = input"
             disablewhen "{ xn__moonraygamma_control_o8a == block } { xn__moonraygamma_control_o8a == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             range   { 0 10 }
             parmtag { "usdvaluetype" "color3f" }
         }
@@ -795,7 +795,7 @@
             label   "moonray:gain"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "![BUTTONS_set_or_create]Set or Create"
                 "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
@@ -814,7 +814,7 @@
             default { "1" "1" "1" }
             help    "Per-channel gain used in tandem with a per-channel offset for color-correcting the light's texture, if one is present. This is achieved by applying the following formula for each channel:\n  output = input * gain + offset"
             disablewhen "{ xn__moonraygain_control_16a == block } { xn__moonraygain_control_16a == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             range   { 0 10 }
             parmtag { "usdvaluetype" "color3f" }
         }
@@ -823,7 +823,7 @@
             label   "moonray:offset"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "![BUTTONS_set_or_create]Set or Create"
                 "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
@@ -842,7 +842,7 @@
             default { "0" "0" "0" }
             help    "Per-channel offset used in tandem with a per-channel gain for color-correcting the light's texture, if one is present. This is achieved by applying the following formula for each channel:\n  output = input * gain + offset"
             disablewhen "{ xn__moonrayoffset_control_bbb == block } { xn__moonrayoffset_control_bbb == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             range   { 0 10 }
             parmtag { "usdvaluetype" "color3f" }
         }
@@ -851,7 +851,7 @@
             label   "moonray:temperature"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "![BUTTONS_set_or_create]Set or Create"
                 "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
@@ -870,7 +870,7 @@
             default { "0" "0" "0" }
             help    "Color temperature using Nuke-style T/M/I settings (T = temperature, M = magenta/green, I = intensity). This is achieved as follows:\nThe 3-channel temperature is interpreted as the vector (T,M,I). The followiong scale values are then applied to the RGB components:\n  outputR = inputR * (pow(2,I) + M/3 - T/2)\n  outputG = inputG * (pow(2,I) - 2*M/3\n  outputB = inputB * (pow(2,I) + M/3 + T/2)"
             disablewhen "{ xn__moonraytemperature_control_gjb == block } { xn__moonraytemperature_control_gjb == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             range   { 0 10 }
             parmtag { "usdvaluetype" "vector3f" }
         }
@@ -879,7 +879,7 @@
             label   "moonray:texture_rotation"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "![BUTTONS_set_or_create]Set or Create"
                 "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
@@ -897,7 +897,7 @@
             default { "0" }
             help    "Clockwise rotation angle in degrees."
             disablewhen "{ xn__moonraytexture_rotation_control_lrb == block } { xn__moonraytexture_rotation_control_lrb == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             range   { 0 10 }
             parmtag { "usdvaluetype" "float" }
         }
@@ -906,7 +906,7 @@
             label   "moonray:texture_translation"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "![BUTTONS_set_or_create]Set or Create"
                 "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
@@ -925,7 +925,7 @@
             default { "0" "0" }
             help    "Translation of the texture in (u,v)-space, in units of the texture size. For example, a translation of (0.25, 0.5) will translate the texture one-quarter of its width in the u-direction and one-half of its height in the v-direction."
             disablewhen "{ xn__moonraytexture_translation_control_hwb == block } { xn__moonraytexture_translation_control_hwb == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             range   { 0 10 }
             parmtag { "usdvaluetype" "float2" }
         }
@@ -934,7 +934,7 @@
             label   "moonray:texture_coverage"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "![BUTTONS_set_or_create]Set or Create"
                 "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
@@ -953,7 +953,7 @@
             default { "1" "1" }
             help    "Texture scales in the u and v-directions."
             disablewhen "{ xn__moonraytexture_coverage_control_lrb == block } { xn__moonraytexture_coverage_control_lrb == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             range   { 0 10 }
             parmtag { "usdvaluetype" "float2" }
         }
@@ -962,7 +962,7 @@
             label   "moonray:texture_reps_u"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "![BUTTONS_set_or_create]Set or Create"
                 "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
@@ -980,7 +980,7 @@
             default { "1" }
             help    "Number of times texture repeats in u over the scaled texture space."
             disablewhen "{ xn__moonraytexture_reps_u_control_cob == block } { xn__moonraytexture_reps_u_control_cob == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             range   { 0 10 }
             parmtag { "usdvaluetype" "float" }
         }
@@ -989,7 +989,7 @@
             label   "moonray:texture_reps_v"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "![BUTTONS_set_or_create]Set or Create"
                 "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
@@ -1007,7 +1007,7 @@
             default { "1" }
             help    "Number of times texture repeats in v over the scaled texture space."
             disablewhen "{ xn__moonraytexture_reps_v_control_cob == block } { xn__moonraytexture_reps_v_control_cob == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             range   { 0 10 }
             parmtag { "usdvaluetype" "float" }
         }
@@ -1016,7 +1016,7 @@
             label   "moonray:texture_mirror_u"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "![BUTTONS_set_or_create]Set or Create"
                 "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
@@ -1032,7 +1032,7 @@
             default { "0" }
             help    "Whether to mirror the texture in the u-direction. If set to false, the texture is repeated in the u-direction."
             disablewhen "{ xn__moonraytexture_mirror_u_control_lrb == block } { xn__moonraytexture_mirror_u_control_lrb == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             parmtag { "usdvaluetype" "bool" }
         }
         parm {
@@ -1040,7 +1040,7 @@
             label   "moonray:texture_mirror_v"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "![BUTTONS_set_or_create]Set or Create"
                 "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
@@ -1056,7 +1056,7 @@
             default { "0" }
             help    "Whether to mirror the texture in the v-direction. If set to false, the texture is repeated in the v-direction."
             disablewhen "{ xn__moonraytexture_mirror_v_control_lrb == block } { xn__moonraytexture_mirror_v_control_lrb == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             parmtag { "usdvaluetype" "bool" }
         }
         parm {
@@ -1064,7 +1064,7 @@
             label   "moonray:texture_border_color"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "![BUTTONS_set_or_create]Set or Create"
                 "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
@@ -1083,7 +1083,7 @@
             default { "1" "1" "1" }
             help    "RGB value used when a texture lookup occurs outside the texture."
             disablewhen "{ xn__moonraytexture_border_color_control_3xb == block } { xn__moonraytexture_border_color_control_3xb == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             range   { 0 10 }
             parmtag { "usdvaluetype" "color3f" }
         }
@@ -1092,7 +1092,7 @@
             label   "moonray:sample_upper_hemisphere_only"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxDomeLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 createprims == on }"
             menujoin {
                 "set"           "![BUTTONS_set_or_create]Set or Create"
                 "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
@@ -1108,22 +1108,240 @@
             default { "0" }
             help    "Set this to true if you want the EnvLight to illuminate from only the \"upper\" hemisphere, defined as the hemisphere centered around the light's positive local z-axis direction."
             disablewhen "{ xn__moonraysample_upper_hemisphere_only_control_4bc == block } { xn__moonraysample_upper_hemisphere_only_control_4bc == none }"
-            hidewhen "{ primtype != UsdLuxDomeLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 createprims == on }"
             parmtag { "usdvaluetype" "bool" }
         }
     }
+    group {
+        name    "folder4"
+        label   "SpotLight"
+        hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+
+        parm {
+            name    "xn__moonraynative_spotlight_rqa"
+            label   "Enable Native MoonRay SpotLight"
+            type    toggle
+            default { "0" }
+            help    "Forces this Solaris light to render as MoonRay's native SpotLight. Use this when you specifically want MoonRay projector-style controls such as inner/outer cone angles, lens radius, focal plane distance, aspect ratio, angle falloff, and black level. The standard Solaris Shaping tab remains the renderer-neutral USD ShapingAPI path."
+            parmtag { "script_callback_language" "python" }
+            parmtag { "script_callback" "node = kwargs['node']; enabled = bool(kwargs['parm'].eval()); control = node.parm('xn__moonrayclass_control_o8a'); klass = node.parm('xn__moonrayclass_nva');\nif enabled:\n    if control is not None and klass is not None:\n        control.set('set')\n        klass.deleteAllKeyframes()\n        klass.set('SpotLight')\nelse:\n    if control is not None and klass is not None and control.evalAsString() == 'set' and klass.evalAsString() == 'SpotLight':\n        control.set('none')\n        klass.deleteAllKeyframes()" }
+        }
+
+        parm {
+            name    "xn__moonraylens_radius_control_gjb"
+            label   "moonray:lens_radius"
+            type    string
+            default { "none" }
+            disablewhen "{ xn__moonraynative_spotlight_rqa == 0 }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            menujoin {
+                "set"           "![BUTTONS_set_or_create]Set or Create"
+                "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
+                "add"           "![BUTTONS_set_add]Add if Exists"
+                "multiply"      "![BUTTONS_set_multiply]Multiply if Exists"
+                "block"         "![BUTTONS_set_block]Block"
+                "none"          "![BUTTONS_set_nothing]Do Nothing"
+            }
+            parmtag { "sidefx::look" "icon" }
+        }
+        parm {
+            name    "xn__moonraylens_radius_f5a"
+            label   "Lens Radius"
+            type    float
+            default { "1" }
+            help    "The radius of the SpotLight's lens (when the aspect ratio is 1.0, so that the lens is circular)."
+            disablewhen "{ xn__moonraynative_spotlight_rqa == 0 } { xn__moonraylens_radius_control_gjb == block } { xn__moonraylens_radius_control_gjb == none }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            range   { 0 10 }
+            parmtag { "usdvaluetype" "float" }
+        }
+        parm {
+            name    "xn__moonrayaspect_ratio_control_2kb"
+            label   "moonray:aspect_ratio"
+            type    string
+            default { "none" }
+            disablewhen "{ xn__moonraynative_spotlight_rqa == 0 }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            menujoin {
+                "set"           "![BUTTONS_set_or_create]Set or Create"
+                "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
+                "add"           "![BUTTONS_set_add]Add if Exists"
+                "multiply"      "![BUTTONS_set_multiply]Multiply if Exists"
+                "block"         "![BUTTONS_set_block]Block"
+                "none"          "![BUTTONS_set_nothing]Do Nothing"
+            }
+            parmtag { "sidefx::look" "icon" }
+        }
+        parm {
+            name    "xn__moonrayaspect_ratio_16a"
+            label   "Aspect Ratio"
+            type    float
+            default { "1" }
+            help    "The aspect ratio of the lens - its local y dimension divided by its local x dimension. Values other than 1.0 will give the lens a non-circular elliptical shape."
+            disablewhen "{ xn__moonraynative_spotlight_rqa == 0 } { xn__moonrayaspect_ratio_control_2kb == block } { xn__moonrayaspect_ratio_control_2kb == none }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            range   { 0 10 }
+            parmtag { "usdvaluetype" "float" }
+        }
+        parm {
+            name    "xn__moonrayfocal_plane_distance_control_3xb"
+            label   "moonray:focal_plane_distance"
+            type    string
+            default { "none" }
+            disablewhen "{ xn__moonraynative_spotlight_rqa == 0 }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            menujoin {
+                "set"           "![BUTTONS_set_or_create]Set or Create"
+                "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
+                "add"           "![BUTTONS_set_add]Add if Exists"
+                "multiply"      "![BUTTONS_set_multiply]Multiply if Exists"
+                "block"         "![BUTTONS_set_block]Block"
+                "none"          "![BUTTONS_set_nothing]Do Nothing"
+            }
+            parmtag { "sidefx::look" "icon" }
+        }
+        parm {
+            name    "xn__moonrayfocal_plane_distance_2kb"
+            label   "Focal Plane Distance"
+            type    float
+            default { "1e+10" }
+            help    "The distance from the SpotLight's position, measured in the direction the light is pointing, at which the projected image will be in focus."
+            disablewhen "{ xn__moonraynative_spotlight_rqa == 0 } { xn__moonrayfocal_plane_distance_control_3xb == block } { xn__moonrayfocal_plane_distance_control_3xb == none }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            range   { 0 10 }
+            parmtag { "usdvaluetype" "float" }
+        }
+        parm {
+            name    "xn__moonrayouter_cone_angle_control_lrb"
+            label   "moonray:outer_cone_angle"
+            type    string
+            default { "none" }
+            disablewhen "{ xn__moonraynative_spotlight_rqa == 0 }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            menujoin {
+                "set"           "![BUTTONS_set_or_create]Set or Create"
+                "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
+                "add"           "![BUTTONS_set_add]Add if Exists"
+                "multiply"      "![BUTTONS_set_multiply]Multiply if Exists"
+                "block"         "![BUTTONS_set_block]Block"
+                "none"          "![BUTTONS_set_nothing]Do Nothing"
+            }
+            parmtag { "sidefx::look" "icon" }
+        }
+        parm {
+            name    "xn__moonrayouter_cone_angle_keb"
+            label   "Outer Cone Angle"
+            type    float
+            default { "60" }
+            help    "The apex angle of the bounding cone of the light emitted by the SpotLight. No illumination takes placeoutside this angle. This is a full angle, measured from one side to the other. There is a falloff function applied between the outer and inner cones - see the angle_falloff_type attribute."
+            disablewhen "{ xn__moonraynative_spotlight_rqa == 0 } { xn__moonrayouter_cone_angle_control_lrb == block } { xn__moonrayouter_cone_angle_control_lrb == none }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            range   { 0 180 }
+            parmtag { "usdvaluetype" "float" }
+        }
+        parm {
+            name    "xn__moonrayinner_cone_angle_control_lrb"
+            label   "moonray:inner_cone_angle"
+            type    string
+            default { "none" }
+            disablewhen "{ xn__moonraynative_spotlight_rqa == 0 }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            menujoin {
+                "set"           "![BUTTONS_set_or_create]Set or Create"
+                "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
+                "add"           "![BUTTONS_set_add]Add if Exists"
+                "multiply"      "![BUTTONS_set_multiply]Multiply if Exists"
+                "block"         "![BUTTONS_set_block]Block"
+                "none"          "![BUTTONS_set_nothing]Do Nothing"
+            }
+            parmtag { "sidefx::look" "icon" }
+        }
+        parm {
+            name    "xn__moonrayinner_cone_angle_keb"
+            label   "Inner Cone Angle"
+            type    float
+            default { "30" }
+            help    "The apex angle of the bright inner cone of the light emitted by the SpotLight. Full illumination takes place inside this region. This is a full angle, measured from one side to the other. There is a falloff function applied between the outer and inner cones - see the angle_falloff_type attribute."
+            disablewhen "{ xn__moonraynative_spotlight_rqa == 0 } { xn__moonrayinner_cone_angle_control_lrb == block } { xn__moonrayinner_cone_angle_control_lrb == none }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            range   { 0 180 }
+            parmtag { "usdvaluetype" "float" }
+        }
+        parm {
+            name    "xn__moonrayangle_falloff_type_control_uub"
+            label   "moonray:angle_falloff_type"
+            type    string
+            default { "none" }
+            disablewhen "{ xn__moonraynative_spotlight_rqa == 0 }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            menujoin {
+                "set"           "![BUTTONS_set_or_create]Set or Create"
+                "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
+                "add"           "![BUTTONS_set_add]Add if Exists"
+                "multiply"      "![BUTTONS_set_multiply]Multiply if Exists"
+                "block"         "![BUTTONS_set_block]Block"
+                "none"          "![BUTTONS_set_nothing]Do Nothing"
+            }
+            parmtag { "sidefx::look" "icon" }
+        }
+        parm {
+            name    "xn__moonrayangle_falloff_type_thb"
+            label   "Angle Falloff Type"
+            type    string
+            default { "ease in/out" }
+            help    "The falloff function applied between the outer and inner cones. To calculate this, the angle from the cone's axis to the the point being illuminated is measured as seen from the SpotLight's position. This angle is converted into a fractional value representing the fraction from the outer cone angle to the inner cone angle, clamped to the range [0,1]. The resulting value is then fed into one of the following user-selectable functions to determine the final 0-1 scaling value to be applied to thelight's radiance: \n  0 (off)         - no fallof, a step function at the outer cone boundary is applied\n  1 (linear)      - a linear ramp, i.e. the fractional parameter is applied as-is\n  2 (ease in)     - a quadratic ramp with zero gradient at the start point (outer cone)\n  3 (ease out)    - a quadratic ramp with zero gradient at the end point (inner cone)\n  4 (ease in/out) - a cubic ramp with zero gradient at both ends (outer and inner cone)\n"
+            disablewhen "{ xn__moonraynative_spotlight_rqa == 0 } { xn__moonrayangle_falloff_type_control_uub == block } { xn__moonrayangle_falloff_type_control_uub == none }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            menu {
+                "off"           "Off"
+                "linear"        "Linear"
+                "ease in"       "Ease In"
+                "ease out"      "Ease Out"
+                "ease in/out"   "Ease In/Out"
+            }
+            parmtag { "usdvaluetype" "token" }
+        }
+        parm {
+            name    "xn__moonrayblack_level_control_gjb"
+            label   "moonray:black_level"
+            type    string
+            default { "none" }
+            disablewhen "{ xn__moonraynative_spotlight_rqa == 0 }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            menujoin {
+                "set"           "![BUTTONS_set_or_create]Set or Create"
+                "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
+                "add"           "![BUTTONS_set_add]Add if Exists"
+                "multiply"      "![BUTTONS_set_multiply]Multiply if Exists"
+                "block"         "![BUTTONS_set_block]Block"
+                "none"          "![BUTTONS_set_nothing]Do Nothing"
+            }
+            parmtag { "sidefx::look" "icon" }
+        }
+        parm {
+            name    "xn__moonrayblack_level_f5a"
+            label   "Black Level"
+            type    float
+            default { "0.001" }
+            help    "The radiance used for rendering the SpotLight lens as seen through the camera via a primary ray, when the true computed radiance would otherwise be black. This is simply a convenience feature to make the SpotLight lens visible in the camera view."
+            disablewhen "{ xn__moonraynative_spotlight_rqa == 0 } { xn__moonrayblack_level_control_gjb == block } { xn__moonrayblack_level_control_gjb == none }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            range   { 0 10 }
+            parmtag { "usdvaluetype" "float" }
+        }
+    }
 
     group {
         name    "folder3"
         label   "Visibility Flags"
-        hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+        hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
 
         parm {
             name    "xn__moonrayvisible_diffuse_reflection_control_v7b"
             label   "moonray:visible_diffuse_reflection"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "![BUTTONS_set_or_create]Set or Create"
                 "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
@@ -1139,7 +1357,7 @@
             default { "1" }
             help    "Whether the light is visible in diffuse reflection."
             disablewhen "{ xn__moonrayvisible_diffuse_reflection_control_v7b == block } { xn__moonrayvisible_diffuse_reflection_control_v7b == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             parmtag { "usdvaluetype" "bool" }
         }
         parm {
@@ -1147,7 +1365,7 @@
             label   "moonray:visible_diffuse_transmission"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "![BUTTONS_set_or_create]Set or Create"
                 "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
@@ -1163,7 +1381,7 @@
             default { "1" }
             help    "Whether the light is visible in diffuse transmission."
             disablewhen "{ xn__moonrayvisible_diffuse_transmission_control_4bc == block } { xn__moonrayvisible_diffuse_transmission_control_4bc == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             parmtag { "usdvaluetype" "bool" }
         }
         parm {
@@ -1171,7 +1389,7 @@
             label   "moonray:visible_glossy_reflection"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "![BUTTONS_set_or_create]Set or Create"
                 "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
@@ -1187,7 +1405,7 @@
             default { "1" }
             help    "Whether the light is visible in glossy reflection."
             disablewhen "{ xn__moonrayvisible_glossy_reflection_control_85b == block } { xn__moonrayvisible_glossy_reflection_control_85b == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             parmtag { "usdvaluetype" "bool" }
         }
         parm {
@@ -1195,7 +1413,7 @@
             label   "moonray:visible_glossy_transmission"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "![BUTTONS_set_or_create]Set or Create"
                 "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
@@ -1211,7 +1429,7 @@
             default { "1" }
             help    "Whether the light is visible in glossy transmission (refraction)."
             disablewhen "{ xn__moonrayvisible_glossy_transmission_control_i9b == block } { xn__moonrayvisible_glossy_transmission_control_i9b == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             parmtag { "usdvaluetype" "bool" }
         }
         parm {
@@ -1219,7 +1437,7 @@
             label   "moonray:visible_mirror_reflection"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "![BUTTONS_set_or_create]Set or Create"
                 "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
@@ -1235,7 +1453,7 @@
             default { "1" }
             help    "Whether the light is visible in miror reflection."
             disablewhen "{ xn__moonrayvisible_mirror_reflection_control_85b == block } { xn__moonrayvisible_mirror_reflection_control_85b == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             parmtag { "usdvaluetype" "bool" }
         }
         parm {
@@ -1243,7 +1461,7 @@
             label   "moonray:visible_mirror_transmission"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "![BUTTONS_set_or_create]Set or Create"
                 "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
@@ -1259,7 +1477,7 @@
             default { "1" }
             help    "Whether the light is visible in miror transmission (refraction)."
             disablewhen "{ xn__moonrayvisible_mirror_transmission_control_i9b == block } { xn__moonrayvisible_mirror_transmission_control_i9b == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             parmtag { "usdvaluetype" "bool" }
         }
     }
@@ -1269,7 +1487,7 @@
         label   "moonray:light_filters"
         type    string
         default { "none" }
-        hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+        hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
         menujoin {
             "set"           "![BUTTONS_set_or_create]Set or Create"
             "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
@@ -1283,7 +1501,7 @@
         label    "Light Filters"
         default 0
         disablewhen "{ xn__moonraylight_filters_control_pmb == block } { xn__moonraylight_filters_control_pmb == none }"
-        hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+        hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxPortalLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
         parmtag { "usdvaluetype" "<class 'pxr.Usd.Relationship'>" }
 
         parm {
@@ -1297,159 +1515,4 @@
         }
     }
 
-    group {
-        name    "folder4"
-        label   "Cone"
-        hidewhen "{ primtype != UsdLuxDiskLight createprims == on }"
-
-        parm {
-            name    "xn__moonrayaspect_ratio_control_2kb"
-            label   "moonray:aspect_ratio"
-            type    string
-            default { "none" }
-            hidewhen "{ primtype != UsdLuxDiskLight createprims == on }"
-            menujoin {
-                "set"           "![BUTTONS_set_or_create]Set or Create"
-                "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
-                "add"           "![BUTTONS_set_add]Add if Exists"
-                "multiply"      "![BUTTONS_set_multiply]Multiply if Exists"
-                "block"         "![BUTTONS_set_block]Block"
-                "none"          "![BUTTONS_set_nothing]Do Nothing"
-            }
-            parmtag { "sidefx::look" "icon" }
-        }
-        parm {
-            name    "xn__moonrayaspect_ratio_16a"
-            label   "Aspect Ratio"
-            type    float
-            default { "1" }
-            help    "The aspect ratio of the lens - its local y dimension divided by its local x dimension. Values other than 1.0 will give the lens a non-circular elliptical shape."
-            disablewhen "{ xn__moonrayaspect_ratio_control_2kb == block } { xn__moonrayaspect_ratio_control_2kb == none }"
-            hidewhen "{ primtype != UsdLuxDiskLight createprims == on }"
-            range   { 0 10 }
-            parmtag { "usdvaluetype" "float" }
-        }
-        parm {
-            name    "xn__moonrayfocal_plane_distance_control_3xb"
-            label   "moonray:focal_plane_distance"
-            type    string
-            default { "none" }
-            hidewhen "{ primtype != UsdLuxDiskLight createprims == on }"
-            menujoin {
-                "set"           "![BUTTONS_set_or_create]Set or Create"
-                "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
-                "add"           "![BUTTONS_set_add]Add if Exists"
-                "multiply"      "![BUTTONS_set_multiply]Multiply if Exists"
-                "block"         "![BUTTONS_set_block]Block"
-                "none"          "![BUTTONS_set_nothing]Do Nothing"
-            }
-            parmtag { "sidefx::look" "icon" }
-        }
-        parm {
-            name    "xn__moonrayfocal_plane_distance_2kb"
-            label   "Focal Plane Distance"
-            type    float
-            default { "1e+10" }
-            help    "The distance from the SpotLight's position, measured in the direction the light is pointing, at which the projected image will be in focus."
-            disablewhen "{ xn__moonrayfocal_plane_distance_control_3xb == block } { xn__moonrayfocal_plane_distance_control_3xb == none }"
-            hidewhen "{ primtype != UsdLuxDiskLight createprims == on }"
-            range   { 0 10 }
-            parmtag { "usdvaluetype" "float" }
-        }
-        parm {
-            name    "xn__moonrayinner_cone_angle_control_lrb"
-            label   "moonray:inner_cone_angle"
-            type    string
-            default { "none" }
-            hidewhen "{ primtype != UsdLuxDiskLight createprims == on }"
-            menujoin {
-                "set"           "![BUTTONS_set_or_create]Set or Create"
-                "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
-                "add"           "![BUTTONS_set_add]Add if Exists"
-                "multiply"      "![BUTTONS_set_multiply]Multiply if Exists"
-                "block"         "![BUTTONS_set_block]Block"
-                "none"          "![BUTTONS_set_nothing]Do Nothing"
-            }
-            parmtag { "sidefx::look" "icon" }
-        }
-        parm {
-            name    "xn__moonrayinner_cone_angle_keb"
-            label   "Inner Cone Angle"
-            type    float
-            default { "30" }
-            help    "The apex angle of the bright inner cone of the light emitted by the SpotLight. Full illumination takes place inside this region. This is a full angle, measured from one side to the other. There is a falloff function applied between the outer and inner cones - see the angle_falloff_type attribute."
-            disablewhen "{ xn__moonrayinner_cone_angle_control_lrb == block } { xn__moonrayinner_cone_angle_control_lrb == none }"
-            hidewhen "{ primtype != UsdLuxDiskLight createprims == on }"
-            range   { 0 10 }
-            parmtag { "usdvaluetype" "float" }
-        }
-    }
-
-    group {
-        name    "folder5"
-        label   "Falloff"
-        hidewhen "{ primtype != UsdLuxDiskLight createprims == on }"
-
-        parm {
-            name    "xn__moonrayangle_falloff_type_control_uub"
-            label   "moonray:angle_falloff_type"
-            type    string
-            default { "none" }
-            hidewhen "{ primtype != UsdLuxDiskLight createprims == on }"
-            menujoin {
-                "set"           "![BUTTONS_set_or_create]Set or Create"
-                "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
-                "add"           "![BUTTONS_set_add]Add if Exists"
-                "multiply"      "![BUTTONS_set_multiply]Multiply if Exists"
-                "block"         "![BUTTONS_set_block]Block"
-                "none"          "![BUTTONS_set_nothing]Do Nothing"
-            }
-            parmtag { "sidefx::look" "icon" }
-        }
-        parm {
-            name    "xn__moonrayangle_falloff_type_thb"
-            label   "Angle Falloff Type"
-            type    string
-            default { "ease in/out" }
-            help    "The falloff function applied between the outer and inner cones. To calculate this, the angle from the cone's axis to the the point being illuminated is measured as seen from the SpotLight's position. This angle is converted into a fractional value representing the fraction from the outer cone angle to the inner cone angle, clamped to the range [0,1]. The resulting value is then fed into one of the following user-selectable functions to determine the final 0-1 scaling value to be applied to thelight's radiance: \n  0 (off)         - no fallof, a step function at the outer cone boundary is applied\n  1 (linear)      - a linear ramp, i.e. the fractional parameter is applied as-is\n  2 (ease in)     - a quadratic ramp with zero gradient at the start point (outer cone)\n  3 (ease out)    - a quadratic ramp with zero gradient at the end point (inner cone)\n  4 (ease in/out) - a cubic ramp with zero gradient at both ends (outer and inner cone)\n"
-            disablewhen "{ xn__moonrayangle_falloff_type_control_uub == block } { xn__moonrayangle_falloff_type_control_uub == none }"
-            hidewhen "{ primtype != UsdLuxDiskLight createprims == on }"
-            menu {
-                "off"           "Off"
-                "linear"        "Linear"
-                "ease in"       "Ease In"
-                "ease out"      "Ease Out"
-                "ease in/out"   "Ease In/Out"
-            }
-            parmtag { "usdvaluetype" "token" }
-        }
-        parm {
-            name    "xn__moonrayblack_level_control_gjb"
-            label   "moonray:black_level"
-            type    string
-            default { "none" }
-            hidewhen "{ primtype != UsdLuxDiskLight createprims == on }"
-            menujoin {
-                "set"           "![BUTTONS_set_or_create]Set or Create"
-                "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
-                "add"           "![BUTTONS_set_add]Add if Exists"
-                "multiply"      "![BUTTONS_set_multiply]Multiply if Exists"
-                "block"         "![BUTTONS_set_block]Block"
-                "none"          "![BUTTONS_set_nothing]Do Nothing"
-            }
-            parmtag { "sidefx::look" "icon" }
-        }
-        parm {
-            name    "xn__moonrayblack_level_f5a"
-            label   "Black Level"
-            type    float
-            default { "0.001" }
-            help    "The radiance used for rendering the SpotLight lens as seen through the camera via a primary ray, when the true computed radiance would otherwise be black. This is simply a convenience feature to make the SpotLight lens visible in the camera view."
-            disablewhen "{ xn__moonrayblack_level_control_gjb == block } { xn__moonrayblack_level_control_gjb == none }"
-            hidewhen "{ primtype != UsdLuxDiskLight createprims == on }"
-            range   { 0 10 }
-            parmtag { "usdvaluetype" "float" }
-        }
-    }
-
 }
diff --git a/houdini/soho/parameters/moonray_Camera.ds b/houdini/soho/parameters/moonray_Camera.ds
new file mode 100644
index 0000000..04fb102
--- /dev/null
+++ b/houdini/soho/parameters/moonray_Camera.ds
@@ -0,0 +1,186 @@
+#include "$HFS/houdini/soho/parameters/CommonMacros.ds"
+{
+    name    parameters
+    label   "Moonray"
+
+    group {
+        name    "folder"
+        label   "Motion Blur"
+
+        parm {
+            name    "xn__moonraymb_shutter_bias_control_ypb"
+            label   "moonray:mb_shutter_bias"
+            type    string
+            default { "none" }
+            menujoin {
+                "set"           "![BUTTONS_set_or_create]Set or Create"
+                "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
+                "add"           "![BUTTONS_set_add]Add if Exists"
+                "multiply"      "![BUTTONS_set_multiply]Multiply if Exists"
+                "block"         "![BUTTONS_set_block]Block"
+                "none"          "![BUTTONS_set_nothing]Do Nothing"
+            }
+            parmtag { "sidefx::look" "icon" }
+        }
+        parm {
+            name    "xn__moonraymb_shutter_bias_xcb"
+            label   "Mb Shutter Bias"
+            type    float
+            default { "0" }
+            help    "Biases the motion blur samples toward one end of the shutter interval."
+            disablewhen "{ xn__moonraymb_shutter_bias_control_ypb == block } { xn__moonraymb_shutter_bias_control_ypb == none }"
+            range   { 0 10 }
+            parmtag { "usdvaluetype" "float" }
+        }
+    }
+
+    group {
+        name    "folder2"
+        label   "Bokeh"
+
+        parm {
+            name    "xn__moonraybokeh_control_o8a"
+            label   "moonray:bokeh"
+            type    string
+            default { "none" }
+            menujoin {
+                "set"           "![BUTTONS_set_or_create]Set or Create"
+                "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
+                "block"         "![BUTTONS_set_block]Block"
+                "none"          "![BUTTONS_set_nothing]Do Nothing"
+            }
+            parmtag { "sidefx::look" "icon" }
+        }
+        parm {
+            name    "xn__moonraybokeh_nva"
+            label   "Bokeh"
+            type    toggle
+            default { "0" }
+            help    "Enable Bokeh. Requires DOF to be enabled."
+            disablewhen "{ xn__moonraybokeh_control_o8a == block } { xn__moonraybokeh_control_o8a == none }"
+            parmtag { "usdvaluetype" "bool" }
+        }
+        parm {
+            name    "xn__moonraybokeh_sides_control_gjb"
+            label   "moonray:bokeh_sides"
+            type    string
+            default { "none" }
+            menujoin {
+                "set"           "![BUTTONS_set_or_create]Set or Create"
+                "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
+                "add"           "![BUTTONS_set_add]Add if Exists"
+                "multiply"      "![BUTTONS_set_multiply]Multiply if Exists"
+                "block"         "![BUTTONS_set_block]Block"
+                "none"          "![BUTTONS_set_nothing]Do Nothing"
+            }
+            parmtag { "sidefx::look" "icon" }
+        }
+        parm {
+            name    "xn__moonraybokeh_sides_f5a"
+            label   "Bokeh Sides"
+            type    integer
+            default { "0" }
+            help    "Number of sides of the iris. Specifying less than 3 sides will default to a disk."
+            disablewhen "{ xn__moonraybokeh_sides_control_gjb == block } { xn__moonraybokeh_sides_control_gjb == none }"
+            range   { 0 10 }
+            parmtag { "usdvaluetype" "int" }
+        }
+        parm {
+            name    "xn__moonraybokeh_image_control_gjb"
+            label   "moonray:bokeh_image"
+            type    string
+            default { "none" }
+            menujoin {
+                "set"           "![BUTTONS_set_or_create]Set or Create"
+                "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
+                "block"         "![BUTTONS_set_block]Block"
+                "none"          "![BUTTONS_set_nothing]Do Nothing"
+            }
+            parmtag { "sidefx::look" "icon" }
+        }
+        parm {
+            name    "xn__moonraybokeh_image_f5a"
+            label   "Bokeh Image"
+            type    string
+            default { "" }
+            help    "Path to image file to be used for the iris"
+            disablewhen "{ xn__moonraybokeh_image_control_gjb == block } { xn__moonraybokeh_image_control_gjb == none }"
+            parmtag { "usdvaluetype" "string" }
+        }
+        parm {
+            name    "xn__moonraybokeh_angle_control_gjb"
+            label   "moonray:bokeh_angle"
+            type    string
+            default { "none" }
+            menujoin {
+                "set"           "![BUTTONS_set_or_create]Set or Create"
+                "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
+                "add"           "![BUTTONS_set_add]Add if Exists"
+                "multiply"      "![BUTTONS_set_multiply]Multiply if Exists"
+                "block"         "![BUTTONS_set_block]Block"
+                "none"          "![BUTTONS_set_nothing]Do Nothing"
+            }
+            parmtag { "sidefx::look" "icon" }
+        }
+        parm {
+            name    "xn__moonraybokeh_angle_f5a"
+            label   "Bokeh Angle"
+            type    float
+            default { "0" }
+            help    "Angle of iris rotation"
+            disablewhen "{ xn__moonraybokeh_angle_control_gjb == block } { xn__moonraybokeh_angle_control_gjb == none }"
+            range   { 0 10 }
+            parmtag { "usdvaluetype" "float" }
+        }
+        parm {
+            name    "xn__moonraybokeh_weight_location_control_qzb"
+            label   "moonray:bokeh_weight_location"
+            type    string
+            default { "none" }
+            menujoin {
+                "set"           "![BUTTONS_set_or_create]Set or Create"
+                "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
+                "add"           "![BUTTONS_set_add]Add if Exists"
+                "multiply"      "![BUTTONS_set_multiply]Multiply if Exists"
+                "block"         "![BUTTONS_set_block]Block"
+                "none"          "![BUTTONS_set_nothing]Do Nothing"
+            }
+            parmtag { "sidefx::look" "icon" }
+        }
+        parm {
+            name    "xn__moonraybokeh_weight_location_pmb"
+            label   "Bokeh Weight Location"
+            type    float
+            default { "0" }
+            help    "Distance from the origin of Bokeh shape"
+            disablewhen "{ xn__moonraybokeh_weight_location_control_qzb == block } { xn__moonraybokeh_weight_location_control_qzb == none }"
+            range   { 0 10 }
+            parmtag { "usdvaluetype" "float" }
+        }
+        parm {
+            name    "xn__moonraybokeh_weight_strength_control_qzb"
+            label   "moonray:bokeh_weight_strength"
+            type    string
+            default { "none" }
+            menujoin {
+                "set"           "![BUTTONS_set_or_create]Set or Create"
+                "setexisting"   "![BUTTONS_set_if_exists]Set if Exists"
+                "add"           "![BUTTONS_set_add]Add if Exists"
+                "multiply"      "![BUTTONS_set_multiply]Multiply if Exists"
+                "block"         "![BUTTONS_set_block]Block"
+                "none"          "![BUTTONS_set_nothing]Do Nothing"
+            }
+            parmtag { "sidefx::look" "icon" }
+        }
+        parm {
+            name    "xn__moonraybokeh_weight_strength_pmb"
+            label   "Bokeh Weight Strength"
+            type    float
+            default { "0" }
+            help    "Controls the strength of weights as samples approach the weight location"
+            disablewhen "{ xn__moonraybokeh_weight_strength_control_qzb == block } { xn__moonraybokeh_weight_strength_control_qzb == none }"
+            range   { 0 10 }
+            parmtag { "usdvaluetype" "float" }
+        }
+    }
+}
diff --git a/houdini/soho/parameters/moonray_Global.ds b/houdini/soho/parameters/moonray_Global.ds
index d8f8a22..c3e8d6b 100644
--- a/houdini/soho/parameters/moonray_Global.ds
+++ b/houdini/soho/parameters/moonray_Global.ds
@@ -1009,7 +1009,7 @@
             name    "xn__sceneVariablesample_clamping_value_nwb"
             label   "Sample Clamping Value"
             type    float
-            default { "10" }
+            default { "10.0" }
             help    "Clamp sample radiance values to this maximum value (the feature is disabled if the value is 0.0). Using this technique reduces fireflies, but is biased."
             disablewhen "{ xn__sceneVariablesample_clamping_value_control_o9b == block } { xn__sceneVariablesample_clamping_value_control_o9b == none }"
             range   { 0 10 }
@@ -2599,7 +2599,7 @@
         name    "xn__sceneVariabletarget_adaptive_error_nwb"
         label   "Target Adaptive Error"
         type    float
-        default { "10" }
+        default { "10.0" }
         help    "When adaptive sampling is turned on, this represents the desired quality of the output images. Lower values will give higher quality but take longer to render. Higher values will give lower quality but render quicker."
         disablewhen "{ xn__sceneVariabletarget_adaptive_error_control_o9b == block } { xn__sceneVariabletarget_adaptive_error_control_o9b == none }"
         range   { 0 10 }
diff --git a/houdini/soho/parameters/moonray_Light.ds b/houdini/soho/parameters/moonray_Light.ds
index 88fc327..30abadb 100644
--- a/houdini/soho/parameters/moonray_Light.ds
+++ b/houdini/soho/parameters/moonray_Light.ds
@@ -7,7 +7,7 @@
         label   "moonray:class"
         type    string
         invisible
-        default { "set" }
+        default { "none" }
         menujoin {
             "set"           "Set Or Create"
             "setexisting"   "Set if Exists"
@@ -20,21 +20,21 @@
         label   "class"
         type    string
         invisible
-        default { [ "\n        parm = hou.parm(\"lighttype\")\n        if parm:\n            value = parm.eval()\n            label = parm.menuLabels()[value]\n            if label == \"Geometry\":\n                label = \"Mesh\"\n            elif label == \"Rectangle\":\n                label = \"Rect\"\n            return label + \"Light\"\n        else:\n            parm = hou.parm(\"primtype\")\n            value = parm.eval()\n            if value == \"UsdLuxDomeLight\":\n                return \"EnvLight\"\n        " python ] }
+        default { [ "\n        parm = hou.parm(\"lighttype\")\n        if parm:\n            value = parm.eval()\n            label = parm.menuLabels()[value]\n            if label == \"Geometry\":\n                label = \"Mesh\"\n            elif label == \"Point\":\n                label = \"Sphere\"\n            elif label == \"Rectangle\":\n                label = \"Rect\"\n            return label + \"Light\"\n        else:\n            parm = hou.parm(\"primtype\")\n            value = parm.eval()\n            if value in (\"UsdLuxDomeLight\", \"UsdLuxDomeLight_1\", \"DomeLight_1\"):\n                return \"EnvLight\"\n        " python ] }
         disablewhen "{ xn__moonrayclass_control_o8a == block } { xn__moonrayclass_control_o8a == none }"
         parmtag { "usdvaluetype" "token" }
     }
     group {
         name    "folder"
         label   "Properties"
-        hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+        hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
 
         parm {
             name    "xn__moonrayon_control_s3a"
             label   "moonray:on"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -49,7 +49,7 @@
             default { "1" }
             help    "Whether the light is switched on."
             disablewhen "{ xn__moonrayon_control_s3a == block } { xn__moonrayon_control_s3a == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             parmtag { "usdvaluetype" "bool" }
         }
         parm {
@@ -57,7 +57,7 @@
             label   "moonray:mb"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -72,7 +72,7 @@
             default { "0" }
             help    "Whether motion-blur is active for this light. When set to true, the scene's illumination will correctly account for any blur() applied to the light's transformation matrix."
             disablewhen "{ xn__moonraymb_control_s3a == block } { xn__moonraymb_control_s3a == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             parmtag { "usdvaluetype" "bool" }
         }
         parm {
@@ -80,7 +80,7 @@
             label   "moonray:visible_in_camera"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -95,7 +95,7 @@
             default { "use default" }
             help    "Whether the light is directly visible in the scene's active camera. When set to \"use default\" it reads from the value of SceneVariable lights_visible_in_camera."
             disablewhen "{ xn__moonrayvisible_in_camera_control_7sb == block } { xn__moonrayvisible_in_camera_control_7sb == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menu {
                 "force off"     "Force Off"
                 "force on"      "Force On"
@@ -108,7 +108,7 @@
             label   "moonray:color"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -124,7 +124,7 @@
             default { "1" "1" "1" }
             help    "The light's RGB values.\nThese are combined multiplicatively with the intensity and other attributes in determining the light's 3-channel radiance."
             disablewhen "{ xn__moonraycolor_control_o8a == block } { xn__moonraycolor_control_o8a == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             range   { 0 10 }
             parmtag { "usdvaluetype" "color3f" }
         }
@@ -133,7 +133,7 @@
             label   "moonray:intensity"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -148,7 +148,7 @@
             default { "1" }
             help    "The light's intensity.\nThis is combined multiplicatively with the color and other attributes in determining the light's 3-channel radiance."
             disablewhen "{ xn__moonrayintensity_control_6fb == block } { xn__moonrayintensity_control_6fb == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             range   { 0 10 }
             parmtag { "usdvaluetype" "float" }
         }
@@ -157,7 +157,7 @@
             label   "moonray:exposure"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -172,7 +172,7 @@
             default { "0" }
             help    "The light's exposure value.\nThis value provides an alternative to the intensity value as a mechanism for controlling the light's overall brightness, and is inspired by the corresponding photographic term but is generalised to apply independently to each light. To calculate its effect, pow(2, exposure) is combined multiplicatively with the color and other attributes in determining the light's 3-channel radiance."
             disablewhen "{ xn__moonrayexposure_control_keb == block } { xn__moonrayexposure_control_keb == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             range   { 0 10 }
             parmtag { "usdvaluetype" "float" }
         }
@@ -181,7 +181,7 @@
             label   "moonray:max_shadow_distance"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -196,7 +196,7 @@
             default { "0" }
             help    "The distance from the light beyond which a light-receiving surface will no longer receive shadows cast from that light.\nNote that the distance is thresholded for each occlusion ray cast for this light, it is possible for a receiving point to lie at an intermediate distance such that some parts of the light are closer than the threshold distance and other parts beyond it, in which case the point will appearto be in partial shadow."
             disablewhen "{ xn__moonraymax_shadow_distance_control_hwb == block } { xn__moonraymax_shadow_distance_control_hwb == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             range   { 0 10 }
             parmtag { "usdvaluetype" "float" }
         }
@@ -205,7 +205,7 @@
             label   "moonray:presence_shadows"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -220,7 +220,7 @@
             default { "use default" }
             help    "Switch this attribute on for shadows cast from this light to correctly respect presence values. When off, surfaces with a material with presence less than 1.0 will cast opaque shadows from this light. This is an optimization - when the attribute is off, occlusion rays (fast) are used for testing for shadows. When it is on, regular rays (slower) are used, and the material's presence is evaluated to determine how much shadowing should occur. When set to \"use default\" it reads from the value of SceneVariable enable_presence_shadows."
             disablewhen "{ xn__moonraypresence_shadows_control_lrb == block } { xn__moonraypresence_shadows_control_lrb == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menu {
                 "force off"     "Force Off"
                 "force on"      "Force On"
@@ -233,7 +233,7 @@
             label   "moonray:ray_termination"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -248,7 +248,7 @@
             default { "0" }
             help    "Whether the light is used for ray termination color. Ray termination color is used for filling in falsely dark areas where ray paths have been terminated too early by the depth controls. Such a ray path immediately exits to any ray termination light(s) present in the light set being applied to the lobe, ignoring occlusion by scene geometry. Any light can either be a regular light or a ray termination light (but not both). Thus they can be freely assigned to light sets, which provides a mechanism for applying specific ray termination lights to specific materials, parts or objects. Ray termination color is only applied to non-hair transmission lobes."
             disablewhen "{ xn__moonrayray_termination_control_ypb == block } { xn__moonrayray_termination_control_ypb == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             parmtag { "usdvaluetype" "bool" }
         }
         parm {
@@ -256,7 +256,7 @@
             label   "moonray:texture_filter"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -271,7 +271,7 @@
             default { "nearest neighbor" }
             help    "The filtering mode to apply to the texture. Nearest neighbor is the cheapest filtering mode but produces a blocky result. Switch linear filtering on for a smoother result. Additionally, mip-mapping can be switched on with either nearest neighbor or linear filtering."
             disablewhen "{ xn__moonraytexture_filter_control_cob == block } { xn__moonraytexture_filter_control_cob == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menu {
                 "nearest neighbor"                  "Nearest Neighbor"
                 "bilinear"                          "Bilinear"
@@ -285,7 +285,7 @@
             label   "moonray:label"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -300,7 +300,7 @@
             default { "" }
             help    "Label used in light aov expressions."
             disablewhen "{ xn__moonraylabel_control_o8a == block } { xn__moonraylabel_control_o8a == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             parmtag { "usdvaluetype" "string" }
         }
         parm {
@@ -657,14 +657,14 @@
     group {
         name    "folder2"
         label   "Map"
-        hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+        hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
 
         parm {
             name    "xn__moonraytexture_control_xcb"
             label   "moonray:texture"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -679,7 +679,7 @@
             default { "" }
             help    "File name of the texture applied to the light. If set to the empty string, no texture is applied. Any file format supported by OpenImageIO can be used. The texture is used in 2 ways - for looking up the texture value at the intersection point when a ray hits the light, and for building a lookup-table-based auxilliary data structure used for distributing light samples over the texture."
             disablewhen "{ xn__moonraytexture_control_xcb == block } { xn__moonraytexture_control_xcb == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             parmtag { "usdvaluetype" "asset" }
         }
         parm {
@@ -687,7 +687,7 @@
             label   "moonray:saturation"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -703,7 +703,7 @@
             default { "1" "1" "1" }
             help    "Per-channel saturation used in color-correcting the light's texture, if one is present. This is achieved by applying the following formula for each channel:\n  output = lerp(luminance(inputRGB), input, saturation)."
             disablewhen "{ xn__moonraysaturation_control_thb == block } { xn__moonraysaturation_control_thb == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             range   { 0 10 }
             parmtag { "usdvaluetype" "color3f" }
         }
@@ -712,7 +712,7 @@
             label   "moonray:contrast"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -728,7 +728,7 @@
             default { "1" "1" "1" }
             help    "Per-channel contrast used in color-correcting the light's texture, if one is present. The operation mimics Nuke's ColorCorrect node's contrast function:\n  For input >  0, output = 0.18 * pow(inputCompnent/0.18, contrast).\n  For input <= 0, output = 0.18 * input * pow(1/0.18, contrast)."
             disablewhen "{ xn__moonraycontrast_control_keb == block } { xn__moonraycontrast_control_keb == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             range   { 0 10 }
             parmtag { "usdvaluetype" "color3f" }
         }
@@ -737,7 +737,7 @@
             label   "moonray:gamma"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -753,7 +753,7 @@
             default { "1" "1" "1" }
             help    "Per-channel gamma used in color-correcting the light's texture, if one is present. This is achieved by applying the following formula for each channel:\n  For input >  0, output = pow(input, gamma)\n  For input <= 0, output = input"
             disablewhen "{ xn__moonraygamma_control_o8a == block } { xn__moonraygamma_control_o8a == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             range   { 0 10 }
             parmtag { "usdvaluetype" "color3f" }
         }
@@ -762,7 +762,7 @@
             label   "moonray:gain"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -778,7 +778,7 @@
             default { "1" "1" "1" }
             help    "Per-channel gain used in tandem with a per-channel offset for color-correcting the light's texture, if one is present. This is achieved by applying the following formula for each channel:\n  output = input * gain + offset"
             disablewhen "{ xn__moonraygain_control_16a == block } { xn__moonraygain_control_16a == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             range   { 0 10 }
             parmtag { "usdvaluetype" "color3f" }
         }
@@ -787,7 +787,7 @@
             label   "moonray:offset"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -803,7 +803,7 @@
             default { "0" "0" "0" }
             help    "Per-channel offset used in tandem with a per-channel gain for color-correcting the light's texture, if one is present. This is achieved by applying the following formula for each channel:\n  output = input * gain + offset"
             disablewhen "{ xn__moonrayoffset_control_bbb == block } { xn__moonrayoffset_control_bbb == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             range   { 0 10 }
             parmtag { "usdvaluetype" "color3f" }
         }
@@ -812,7 +812,7 @@
             label   "moonray:temperature"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -828,7 +828,7 @@
             default { "0" "0" "0" }
             help    "Color temperature using Nuke-style T/M/I settings (T = temperature, M = magenta/green, I = intensity). This is achieved as follows:\nThe 3-channel temperature is interpreted as the vector (T,M,I). The followiong scale values are then applied to the RGB components:\n  outputR = inputR * (pow(2,I) + M/3 - T/2)\n  outputG = inputG * (pow(2,I) - 2*M/3\n  outputB = inputB * (pow(2,I) + M/3 + T/2)"
             disablewhen "{ xn__moonraytemperature_control_gjb == block } { xn__moonraytemperature_control_gjb == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             range   { 0 10 }
             parmtag { "usdvaluetype" "vector3f" }
         }
@@ -837,7 +837,7 @@
             label   "moonray:texture_rotation"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -852,7 +852,7 @@
             default { "0" }
             help    "Clockwise rotation angle in degrees."
             disablewhen "{ xn__moonraytexture_rotation_control_lrb == block } { xn__moonraytexture_rotation_control_lrb == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             range   { 0 10 }
             parmtag { "usdvaluetype" "float" }
         }
@@ -861,7 +861,7 @@
             label   "moonray:texture_translation"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -877,7 +877,7 @@
             default { "0" "0" }
             help    "Translation of the texture in (u,v)-space, in units of the texture size. For example, a translation of (0.25, 0.5) will translate the texture one-quarter of its width in the u-direction and one-half of its height in the v-direction."
             disablewhen "{ xn__moonraytexture_translation_control_hwb == block } { xn__moonraytexture_translation_control_hwb == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             range   { 0 10 }
             parmtag { "usdvaluetype" "float2" }
         }
@@ -886,7 +886,7 @@
             label   "moonray:texture_coverage"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -902,7 +902,7 @@
             default { "1" "1" }
             help    "Texture scales in the u and v-directions."
             disablewhen "{ xn__moonraytexture_coverage_control_lrb == block } { xn__moonraytexture_coverage_control_lrb == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             range   { 0 10 }
             parmtag { "usdvaluetype" "float2" }
         }
@@ -911,7 +911,7 @@
             label   "moonray:texture_reps_u"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -926,7 +926,7 @@
             default { "1" }
             help    "Number of times texture repeats in u over the scaled texture space."
             disablewhen "{ xn__moonraytexture_reps_u_control_cob == block } { xn__moonraytexture_reps_u_control_cob == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             range   { 0 10 }
             parmtag { "usdvaluetype" "float" }
         }
@@ -935,7 +935,7 @@
             label   "moonray:texture_reps_v"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -950,7 +950,7 @@
             default { "1" }
             help    "Number of times texture repeats in v over the scaled texture space."
             disablewhen "{ xn__moonraytexture_reps_v_control_cob == block } { xn__moonraytexture_reps_v_control_cob == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             range   { 0 10 }
             parmtag { "usdvaluetype" "float" }
         }
@@ -959,7 +959,7 @@
             label   "moonray:texture_mirror_u"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -974,7 +974,7 @@
             default { "0" }
             help    "Whether to mirror the texture in the u-direction. If set to false, the texture is repeated in the u-direction."
             disablewhen "{ xn__moonraytexture_mirror_u_control_lrb == block } { xn__moonraytexture_mirror_u_control_lrb == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             parmtag { "usdvaluetype" "bool" }
         }
         parm {
@@ -982,7 +982,7 @@
             label   "moonray:texture_mirror_v"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -997,7 +997,7 @@
             default { "0" }
             help    "Whether to mirror the texture in the v-direction. If set to false, the texture is repeated in the v-direction."
             disablewhen "{ xn__moonraytexture_mirror_v_control_lrb == block } { xn__moonraytexture_mirror_v_control_lrb == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             parmtag { "usdvaluetype" "bool" }
         }
         parm {
@@ -1005,7 +1005,7 @@
             label   "moonray:texture_border_color"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -1021,7 +1021,7 @@
             default { "1" "1" "1" }
             help    "RGB value used when a texture lookup occurs outside the texture."
             disablewhen "{ xn__moonraytexture_border_color_control_3xb == block } { xn__moonraytexture_border_color_control_3xb == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             range   { 0 10 }
             parmtag { "usdvaluetype" "color3f" }
         }
@@ -1030,7 +1030,7 @@
             label   "moonray:sample_upper_hemisphere_only"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxDomeLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -1045,22 +1045,32 @@
             default { "0" }
             help    "Set this to true if you want the EnvLight to illuminate from only the \"upper\" hemisphere, defined as the hemisphere centered around the light's positive local z-axis direction."
             disablewhen "{ xn__moonraysample_upper_hemisphere_only_control_4bc == block } { xn__moonraysample_upper_hemisphere_only_control_4bc == none }"
-            hidewhen "{ primtype != UsdLuxDomeLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 createprims == on }"
             parmtag { "usdvaluetype" "bool" }
         }
     }
-
     group {
-        name    "folder3"
-        label   "Visibility Flags"
-        hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+        name    "folder4"
+        label   "SpotLight"
+        hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
 
         parm {
-            name    "xn__moonrayvisible_diffuse_reflection_control_v7b"
-            label   "moonray:visible_diffuse_reflection"
+            name    "xn__moonraynative_spotlight_rqa"
+            label   "Enable Native MoonRay SpotLight"
+            type    toggle
+            default { "0" }
+            help    "Forces this Solaris light to render as MoonRay's native SpotLight. Use this when you specifically want MoonRay projector-style controls such as inner/outer cone angles, lens radius, focal plane distance, aspect ratio, angle falloff, and black level. The standard Solaris Shaping tab remains the renderer-neutral USD ShapingAPI path."
+            parmtag { "script_callback_language" "python" }
+            parmtag { "script_callback" "node = kwargs['node']; enabled = bool(kwargs['parm'].eval()); control = node.parm('xn__moonrayclass_control_o8a'); klass = node.parm('xn__moonrayclass_nva');\nif enabled:\n    if control is not None and klass is not None:\n        control.set('set')\n        klass.deleteAllKeyframes()\n        klass.set('SpotLight')\nelse:\n    if control is not None and klass is not None and control.evalAsString() == 'set' and klass.evalAsString() == 'SpotLight':\n        control.set('none')\n        klass.deleteAllKeyframes()" }
+        }
+
+        parm {
+            name    "xn__moonraylens_radius_control_gjb"
+            label   "moonray:lens_radius"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            disablewhen "{ xn__moonraynative_spotlight_rqa == 0 }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -1069,21 +1079,23 @@
             }
         }
         parm {
-            name    "xn__moonrayvisible_diffuse_reflection_uub"
-            label   "Visible Diffuse Reflection"
-            type    toggle
+            name    "xn__moonraylens_radius_f5a"
+            label   "Lens Radius"
+            type    float
             default { "1" }
-            help    "Whether the light is visible in diffuse reflection."
-            disablewhen "{ xn__moonrayvisible_diffuse_reflection_control_v7b == block } { xn__moonrayvisible_diffuse_reflection_control_v7b == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
-            parmtag { "usdvaluetype" "bool" }
+            help    "The radius of the SpotLight's lens (when the aspect ratio is 1.0, so that the lens is circular)."
+            disablewhen "{ xn__moonraynative_spotlight_rqa == 0 } { xn__moonraylens_radius_control_gjb == block } { xn__moonraylens_radius_control_gjb == none }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            range   { 0 10 }
+            parmtag { "usdvaluetype" "float" }
         }
         parm {
-            name    "xn__moonrayvisible_diffuse_transmission_control_4bc"
-            label   "moonray:visible_diffuse_transmission"
+            name    "xn__moonrayaspect_ratio_control_2kb"
+            label   "moonray:aspect_ratio"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            disablewhen "{ xn__moonraynative_spotlight_rqa == 0 }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -1092,21 +1104,23 @@
             }
         }
         parm {
-            name    "xn__moonrayvisible_diffuse_transmission_3xb"
-            label   "Visible Diffuse Transmission"
-            type    toggle
+            name    "xn__moonrayaspect_ratio_16a"
+            label   "Aspect Ratio"
+            type    float
             default { "1" }
-            help    "Whether the light is visible in diffuse transmission."
-            disablewhen "{ xn__moonrayvisible_diffuse_transmission_control_4bc == block } { xn__moonrayvisible_diffuse_transmission_control_4bc == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
-            parmtag { "usdvaluetype" "bool" }
+            help    "The aspect ratio of the lens - its local y dimension divided by its local x dimension. Values other than 1.0 will give the lens a non-circular elliptical shape."
+            disablewhen "{ xn__moonraynative_spotlight_rqa == 0 } { xn__moonrayaspect_ratio_control_2kb == block } { xn__moonrayaspect_ratio_control_2kb == none }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            range   { 0 10 }
+            parmtag { "usdvaluetype" "float" }
         }
         parm {
-            name    "xn__moonrayvisible_glossy_reflection_control_85b"
-            label   "moonray:visible_glossy_reflection"
+            name    "xn__moonrayfocal_plane_distance_control_3xb"
+            label   "moonray:focal_plane_distance"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            disablewhen "{ xn__moonraynative_spotlight_rqa == 0 }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -1115,21 +1129,23 @@
             }
         }
         parm {
-            name    "xn__moonrayvisible_glossy_reflection_7sb"
-            label   "Visible Glossy Reflection"
-            type    toggle
-            default { "1" }
-            help    "Whether the light is visible in glossy reflection."
-            disablewhen "{ xn__moonrayvisible_glossy_reflection_control_85b == block } { xn__moonrayvisible_glossy_reflection_control_85b == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
-            parmtag { "usdvaluetype" "bool" }
+            name    "xn__moonrayfocal_plane_distance_2kb"
+            label   "Focal Plane Distance"
+            type    float
+            default { "1e+10" }
+            help    "The distance from the SpotLight's position, measured in the direction the light is pointing, at which the projected image will be in focus."
+            disablewhen "{ xn__moonraynative_spotlight_rqa == 0 } { xn__moonrayfocal_plane_distance_control_3xb == block } { xn__moonrayfocal_plane_distance_control_3xb == none }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            range   { 0 10 }
+            parmtag { "usdvaluetype" "float" }
         }
         parm {
-            name    "xn__moonrayvisible_glossy_transmission_control_i9b"
-            label   "moonray:visible_glossy_transmission"
+            name    "xn__moonrayouter_cone_angle_control_lrb"
+            label   "moonray:outer_cone_angle"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            disablewhen "{ xn__moonraynative_spotlight_rqa == 0 }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -1138,21 +1154,23 @@
             }
         }
         parm {
-            name    "xn__moonrayvisible_glossy_transmission_hwb"
-            label   "Visible Glossy Transmission"
-            type    toggle
-            default { "1" }
-            help    "Whether the light is visible in glossy transmission (refraction)."
-            disablewhen "{ xn__moonrayvisible_glossy_transmission_control_i9b == block } { xn__moonrayvisible_glossy_transmission_control_i9b == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
-            parmtag { "usdvaluetype" "bool" }
+            name    "xn__moonrayouter_cone_angle_keb"
+            label   "Outer Cone Angle"
+            type    float
+            default { "60" }
+            help    "The apex angle of the bounding cone of the light emitted by the SpotLight. No illumination takes placeoutside this angle. This is a full angle, measured from one side to the other. There is a falloff function applied between the outer and inner cones - see the angle_falloff_type attribute."
+            disablewhen "{ xn__moonraynative_spotlight_rqa == 0 } { xn__moonrayouter_cone_angle_control_lrb == block } { xn__moonrayouter_cone_angle_control_lrb == none }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            range   { 0 180 }
+            parmtag { "usdvaluetype" "float" }
         }
         parm {
-            name    "xn__moonrayvisible_mirror_reflection_control_85b"
-            label   "moonray:visible_mirror_reflection"
+            name    "xn__moonrayinner_cone_angle_control_lrb"
+            label   "moonray:inner_cone_angle"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            disablewhen "{ xn__moonraynative_spotlight_rqa == 0 }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -1161,21 +1179,23 @@
             }
         }
         parm {
-            name    "xn__moonrayvisible_mirror_reflection_7sb"
-            label   "Visible Mirror Reflection"
-            type    toggle
-            default { "1" }
-            help    "Whether the light is visible in miror reflection."
-            disablewhen "{ xn__moonrayvisible_mirror_reflection_control_85b == block } { xn__moonrayvisible_mirror_reflection_control_85b == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
-            parmtag { "usdvaluetype" "bool" }
+            name    "xn__moonrayinner_cone_angle_keb"
+            label   "Inner Cone Angle"
+            type    float
+            default { "30" }
+            help    "The apex angle of the bright inner cone of the light emitted by the SpotLight. Full illumination takes place inside this region. This is a full angle, measured from one side to the other. There is a falloff function applied between the outer and inner cones - see the angle_falloff_type attribute."
+            disablewhen "{ xn__moonraynative_spotlight_rqa == 0 } { xn__moonrayinner_cone_angle_control_lrb == block } { xn__moonrayinner_cone_angle_control_lrb == none }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            range   { 0 180 }
+            parmtag { "usdvaluetype" "float" }
         }
         parm {
-            name    "xn__moonrayvisible_mirror_transmission_control_i9b"
-            label   "moonray:visible_mirror_transmission"
+            name    "xn__moonrayangle_falloff_type_control_uub"
+            label   "moonray:angle_falloff_type"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            disablewhen "{ xn__moonraynative_spotlight_rqa == 0 }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -1184,60 +1204,29 @@
             }
         }
         parm {
-            name    "xn__moonrayvisible_mirror_transmission_hwb"
-            label   "Visible Mirror Transmission"
-            type    toggle
-            default { "1" }
-            help    "Whether the light is visible in miror transmission (refraction)."
-            disablewhen "{ xn__moonrayvisible_mirror_transmission_control_i9b == block } { xn__moonrayvisible_mirror_transmission_control_i9b == none }"
-            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
-            parmtag { "usdvaluetype" "bool" }
-        }
-    }
-
-    parm {
-        name    "xn__moonraylight_filters_control_pmb"
-        label   "moonray:light_filters"
-        type    string
-        default { "none" }
-        hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
-        menujoin {
-            "set"           "Set Or Create"
-            "setexisting"   "Set if Exists"
-            "block"         "Block"
-            "none"          "Do Nothing"
-        }
-    }
-    multiparm {
-        name    "light_filters"
-        label    "Light Filters"
-        default 0
-        disablewhen "{ xn__moonraylight_filters_control_pmb == block } { xn__moonraylight_filters_control_pmb == none }"
-        hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
-        parmtag { "usdvaluetype" "<class 'pxr.Usd.Relationship'>" }
-
-        parm {
-            name    "xn__moonraylight_filters_o8a#"
-            label   "Light Filters"
-            type    oppath
-            default { "" }
-            help    "Vector of LightFilters associated with the light."
-            parmtag { "moonray::is_parm" "1" }
-            parmtag { "oprelative" "." }
+            name    "xn__moonrayangle_falloff_type_thb"
+            label   "Angle Falloff Type"
+            type    string
+            default { "ease in/out" }
+            help    "The falloff function applied between the outer and inner cones. To calculate this, the angle from the cone's axis to the the point being illuminated is measured as seen from the SpotLight's position. This angle is converted into a fractional value representing the fraction from the outer cone angle to the inner cone angle, clamped to the range [0,1]. The resulting value is then fed into one of the following user-selectable functions to determine the final 0-1 scaling value to be applied to thelight's radiance: \n  0 (off)         - no fallof, a step function at the outer cone boundary is applied\n  1 (linear)      - a linear ramp, i.e. the fractional parameter is applied as-is\n  2 (ease in)     - a quadratic ramp with zero gradient at the start point (outer cone)\n  3 (ease out)    - a quadratic ramp with zero gradient at the end point (inner cone)\n  4 (ease in/out) - a cubic ramp with zero gradient at both ends (outer and inner cone)\n"
+            disablewhen "{ xn__moonraynative_spotlight_rqa == 0 } { xn__moonrayangle_falloff_type_control_uub == block } { xn__moonrayangle_falloff_type_control_uub == none }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            menu {
+                "off"           "Off"
+                "linear"        "Linear"
+                "ease in"       "Ease In"
+                "ease out"      "Ease Out"
+                "ease in/out"   "Ease In/Out"
+            }
+            parmtag { "usdvaluetype" "token" }
         }
-    }
-
-    group {
-        name    "folder4"
-        label   "Cone"
-        hidewhen "{ primtype != UsdLuxDiskLight createprims == on }"
-
         parm {
-            name    "xn__moonraylens_radius_control_gjb"
-            label   "moonray:lens_radius"
+            name    "xn__moonrayblack_level_control_gjb"
+            label   "moonray:black_level"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxDiskLight createprims == on }"
+            disablewhen "{ xn__moonraynative_spotlight_rqa == 0 }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -1246,22 +1235,29 @@
             }
         }
         parm {
-            name    "xn__moonraylens_radius_f5a"
-            label   "Lens Radius"
+            name    "xn__moonrayblack_level_f5a"
+            label   "Black Level"
             type    float
-            default { "1" }
-            help    "The radius of the SpotLight's lens (when the aspect ratio is 1.0, so that the lens is circular)."
-            disablewhen "{ xn__moonraylens_radius_control_gjb == block } { xn__moonraylens_radius_control_gjb == none }"
-            hidewhen "{ primtype != UsdLuxDiskLight createprims == on }"
+            default { "0.001" }
+            help    "The radiance used for rendering the SpotLight lens as seen through the camera via a primary ray, when the true computed radiance would otherwise be black. This is simply a convenience feature to make the SpotLight lens visible in the camera view."
+            disablewhen "{ xn__moonraynative_spotlight_rqa == 0 } { xn__moonrayblack_level_control_gjb == block } { xn__moonrayblack_level_control_gjb == none }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             range   { 0 10 }
             parmtag { "usdvaluetype" "float" }
         }
+    }
+
+    group {
+        name    "folder3"
+        label   "Visibility Flags"
+        hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+
         parm {
-            name    "xn__moonrayaspect_ratio_control_2kb"
-            label   "moonray:aspect_ratio"
+            name    "xn__moonrayvisible_diffuse_reflection_control_v7b"
+            label   "moonray:visible_diffuse_reflection"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -1270,22 +1266,21 @@
             }
         }
         parm {
-            name    "xn__moonrayaspect_ratio_16a"
-            label   "Aspect Ratio"
-            type    float
+            name    "xn__moonrayvisible_diffuse_reflection_uub"
+            label   "Visible Diffuse Reflection"
+            type    toggle
             default { "1" }
-            help    "The aspect ratio of the lens - its local y dimension divided by its local x dimension. Values other than 1.0 will give the lens a non-circular elliptical shape."
-            disablewhen "{ xn__moonrayaspect_ratio_control_2kb == block } { xn__moonrayaspect_ratio_control_2kb == none }"
-            hidewhen "{ primtype != UsdLuxDiskLight createprims == on }"
-            range   { 0 10 }
-            parmtag { "usdvaluetype" "float" }
+            help    "Whether the light is visible in diffuse reflection."
+            disablewhen "{ xn__moonrayvisible_diffuse_reflection_control_v7b == block } { xn__moonrayvisible_diffuse_reflection_control_v7b == none }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            parmtag { "usdvaluetype" "bool" }
         }
         parm {
-            name    "xn__moonrayfocal_plane_distance_control_3xb"
-            label   "moonray:focal_plane_distance"
+            name    "xn__moonrayvisible_diffuse_transmission_control_4bc"
+            label   "moonray:visible_diffuse_transmission"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -1294,22 +1289,21 @@
             }
         }
         parm {
-            name    "xn__moonrayfocal_plane_distance_2kb"
-            label   "Focal Plane Distance"
-            type    float
-            default { "1e+10" }
-            help    "The distance from the SpotLight's position, measured in the direction the light is pointing, at which the projected image will be in focus."
-            disablewhen "{ xn__moonrayfocal_plane_distance_control_3xb == block } { xn__moonrayfocal_plane_distance_control_3xb == none }"
-            hidewhen "{ primtype != UsdLuxDiskLight createprims == on }"
-            range   { 0 10 }
-            parmtag { "usdvaluetype" "float" }
+            name    "xn__moonrayvisible_diffuse_transmission_3xb"
+            label   "Visible Diffuse Transmission"
+            type    toggle
+            default { "1" }
+            help    "Whether the light is visible in diffuse transmission."
+            disablewhen "{ xn__moonrayvisible_diffuse_transmission_control_4bc == block } { xn__moonrayvisible_diffuse_transmission_control_4bc == none }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            parmtag { "usdvaluetype" "bool" }
         }
         parm {
-            name    "xn__moonrayouter_cone_angle_control_lrb"
-            label   "moonray:outer_cone_angle"
+            name    "xn__moonrayvisible_glossy_reflection_control_85b"
+            label   "moonray:visible_glossy_reflection"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -1318,22 +1312,21 @@
             }
         }
         parm {
-            name    "xn__moonrayouter_cone_angle_keb"
-            label   "Outer Cone Angle"
-            type    float
-            default { "60" }
-            help    "The apex angle of the bounding cone of the light emitted by the SpotLight. No illumination takes placeoutside this angle. This is a full angle, measured from one side to the other. There is a falloff function applied between the outer and inner cones - see the angle_falloff_type attribute."
-            disablewhen "{ xn__moonrayouter_cone_angle_control_lrb == block } { xn__moonrayouter_cone_angle_control_lrb == none }"
-            hidewhen "{ primtype != UsdLuxDiskLight createprims == on }"
-            range   { 0 10 }
-            parmtag { "usdvaluetype" "float" }
+            name    "xn__moonrayvisible_glossy_reflection_7sb"
+            label   "Visible Glossy Reflection"
+            type    toggle
+            default { "1" }
+            help    "Whether the light is visible in glossy reflection."
+            disablewhen "{ xn__moonrayvisible_glossy_reflection_control_85b == block } { xn__moonrayvisible_glossy_reflection_control_85b == none }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            parmtag { "usdvaluetype" "bool" }
         }
         parm {
-            name    "xn__moonrayinner_cone_angle_control_lrb"
-            label   "moonray:inner_cone_angle"
+            name    "xn__moonrayvisible_glossy_transmission_control_i9b"
+            label   "moonray:visible_glossy_transmission"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -1342,29 +1335,21 @@
             }
         }
         parm {
-            name    "xn__moonrayinner_cone_angle_keb"
-            label   "Inner Cone Angle"
-            type    float
-            default { "30" }
-            help    "The apex angle of the bright inner cone of the light emitted by the SpotLight. Full illumination takes place inside this region. This is a full angle, measured from one side to the other. There is a falloff function applied between the outer and inner cones - see the angle_falloff_type attribute."
-            disablewhen "{ xn__moonrayinner_cone_angle_control_lrb == block } { xn__moonrayinner_cone_angle_control_lrb == none }"
-            hidewhen "{ primtype != UsdLuxDiskLight createprims == on }"
-            range   { 0 10 }
-            parmtag { "usdvaluetype" "float" }
+            name    "xn__moonrayvisible_glossy_transmission_hwb"
+            label   "Visible Glossy Transmission"
+            type    toggle
+            default { "1" }
+            help    "Whether the light is visible in glossy transmission (refraction)."
+            disablewhen "{ xn__moonrayvisible_glossy_transmission_control_i9b == block } { xn__moonrayvisible_glossy_transmission_control_i9b == none }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            parmtag { "usdvaluetype" "bool" }
         }
-    }
-
-    group {
-        name    "folder5"
-        label   "Falloff"
-        hidewhen "{ primtype != UsdLuxDiskLight createprims == on }"
-
         parm {
-            name    "xn__moonrayangle_falloff_type_control_uub"
-            label   "moonray:angle_falloff_type"
+            name    "xn__moonrayvisible_mirror_reflection_control_85b"
+            label   "moonray:visible_mirror_reflection"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -1373,28 +1358,21 @@
             }
         }
         parm {
-            name    "xn__moonrayangle_falloff_type_thb"
-            label   "Angle Falloff Type"
-            type    string
-            default { "ease in/out" }
-            help    "The falloff function applied between the outer and inner cones. To calculate this, the angle from the cone's axis to the the point being illuminated is measured as seen from the SpotLight's position. This angle is converted into a fractional value representing the fraction from the outer cone angle to the inner cone angle, clamped to the range [0,1]. The resulting value is then fed into one of the following user-selectable functions to determine the final 0-1 scaling value to be applied to thelight's radiance: \n  0 (off)         - no fallof, a step function at the outer cone boundary is applied\n  1 (linear)      - a linear ramp, i.e. the fractional parameter is applied as-is\n  2 (ease in)     - a quadratic ramp with zero gradient at the start point (outer cone)\n  3 (ease out)    - a quadratic ramp with zero gradient at the end point (inner cone)\n  4 (ease in/out) - a cubic ramp with zero gradient at both ends (outer and inner cone)\n"
-            disablewhen "{ xn__moonrayangle_falloff_type_control_uub == block } { xn__moonrayangle_falloff_type_control_uub == none }"
-            hidewhen "{ primtype != UsdLuxDiskLight createprims == on }"
-            menu {
-                "off"           "Off"
-                "linear"        "Linear"
-                "ease in"       "Ease In"
-                "ease out"      "Ease Out"
-                "ease in/out"   "Ease In/Out"
-            }
-            parmtag { "usdvaluetype" "token" }
+            name    "xn__moonrayvisible_mirror_reflection_7sb"
+            label   "Visible Mirror Reflection"
+            type    toggle
+            default { "1" }
+            help    "Whether the light is visible in miror reflection."
+            disablewhen "{ xn__moonrayvisible_mirror_reflection_control_85b == block } { xn__moonrayvisible_mirror_reflection_control_85b == none }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            parmtag { "usdvaluetype" "bool" }
         }
         parm {
-            name    "xn__moonrayblack_level_control_gjb"
-            label   "moonray:black_level"
+            name    "xn__moonrayvisible_mirror_transmission_control_i9b"
+            label   "moonray:visible_mirror_transmission"
             type    string
             default { "none" }
-            hidewhen "{ primtype != UsdLuxDiskLight createprims == on }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
             menujoin {
                 "set"           "Set Or Create"
                 "setexisting"   "Set if Exists"
@@ -1403,15 +1381,46 @@
             }
         }
         parm {
-            name    "xn__moonrayblack_level_f5a"
-            label   "Black Level"
-            type    float
-            default { "0.001" }
-            help    "The radiance used for rendering the SpotLight lens as seen through the camera via a primary ray, when the true computed radiance would otherwise be black. This is simply a convenience feature to make the SpotLight lens visible in the camera view."
-            disablewhen "{ xn__moonrayblack_level_control_gjb == block } { xn__moonrayblack_level_control_gjb == none }"
-            hidewhen "{ primtype != UsdLuxDiskLight createprims == on }"
-            range   { 0 10 }
-            parmtag { "usdvaluetype" "float" }
+            name    "xn__moonrayvisible_mirror_transmission_hwb"
+            label   "Visible Mirror Transmission"
+            type    toggle
+            default { "1" }
+            help    "Whether the light is visible in miror transmission (refraction)."
+            disablewhen "{ xn__moonrayvisible_mirror_transmission_control_i9b == block } { xn__moonrayvisible_mirror_transmission_control_i9b == none }"
+            hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+            parmtag { "usdvaluetype" "bool" }
+        }
+    }
+
+    parm {
+        name    "xn__moonraylight_filters_control_pmb"
+        label   "moonray:light_filters"
+        type    string
+        default { "none" }
+        hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+        menujoin {
+            "set"           "Set Or Create"
+            "setexisting"   "Set if Exists"
+            "block"         "Block"
+            "none"          "Do Nothing"
+        }
+    }
+    multiparm {
+        name    "light_filters"
+        label    "Light Filters"
+        default 0
+        disablewhen "{ xn__moonraylight_filters_control_pmb == block } { xn__moonraylight_filters_control_pmb == none }"
+        hidewhen "{ primtype != UsdLuxCylinderLight primtype != UsdLuxDiskLight primtype != UsdLuxDistantLight primtype != UsdLuxDomeLight primtype != UsdLuxDomeLight_1 primtype != DomeLight_1 primtype != UsdLuxGeometryLight primtype != UsdLuxRectLight primtype != UsdLuxSphereLight primtype != UsdLuxDiskLight createprims == on }"
+        parmtag { "usdvaluetype" "<class 'pxr.Usd.Relationship'>" }
+
+        parm {
+            name    "xn__moonraylight_filters_o8a#"
+            label   "Light Filters"
+            type    oppath
+            default { "" }
+            help    "Vector of LightFilters associated with the light."
+            parmtag { "moonray::is_parm" "1" }
+            parmtag { "oprelative" "." }
         }
     }
 
diff --git a/houdini/tests/dev_validate_moonray_render_settings_lop.py b/houdini/tests/dev_validate_moonray_render_settings_lop.py
new file mode 100755
index 0000000..796b056
--- /dev/null
+++ b/houdini/tests/dev_validate_moonray_render_settings_lop.py
@@ -0,0 +1,808 @@
+#!/usr/bin/env hython
+"""Development validation for the MoonRay Render Settings LOP lifecycle.
+
+Run with Houdini 20.5 hython:
+/Applications/Houdini/Houdini20.5.584/Frameworks/Houdini.framework/Versions/20.5/Resources/bin/hython \
+  /Applications/MoonRay/openmoonray/moonray/moonray_dcc_plugins/houdini/tests/dev_validate_moonray_render_settings_lop.py
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import tempfile
+
+import hou
+from pxr import Usd, UsdRender
+
+OPERATOR_TYPE = "Lop::DW_MOONRAY::moonrayrendersettings::1"
+ROP_NODE_TYPE = "usdrender_rop"
+OUT_ROP_NODE_TYPE = "usdrender"
+RENDERER_TOKEN = "HdMoonrayRendererPlugin"
+OWNER_LOP_KEY = "moonray_render_settings_lop"
+OWNER_OPERATOR_KEY = "moonray_render_settings_operator"
+OWNER_SESSION_KEY = "moonray_render_settings_lop_session_id"
+EXPECTED_SCENE_VARIABLE_COUNT = 50
+EXPECTED_MODULE_SUFFIX = "/plugin/houdini/python3.11libs/moonray_render_settings.py"
+
+
+RESULTS = []
+
+
+def _print(status: str, name: str, details: object) -> None:
+    RESULTS.append((status, name, str(details)))
+    print(f"{status} {name}: {details}")
+
+
+def pass_(name: str, details: object) -> None:
+    _print("PASS", name, details)
+
+
+def fail(name: str, details: object) -> None:
+    _print("FAIL", name, details)
+
+
+def skip(name: str, details: object) -> None:
+    _print("SKIP", name, details)
+
+
+def check(name: str, condition: bool, details: object) -> None:
+    if condition:
+        pass_(name, details)
+    else:
+        fail(name, details)
+
+
+def disable_when(parm: hou.Parm) -> str | None:
+    return parm.parmTemplate().conditionals().get(hou.parmCondType.DisableWhen)
+
+
+def folder_template_names_and_labels(container) -> list[tuple[str, str]]:
+    if hasattr(container, "entries"):
+        entries = container.entries()
+    else:
+        entries = container.parmTemplates()
+    names_and_labels = []
+    for entry in entries:
+        if entry.type() == hou.parmTemplateType.Folder:
+            names_and_labels.append((entry.name(), entry.label()))
+            names_and_labels.extend(folder_template_names_and_labels(entry))
+    return names_and_labels
+
+
+def clear_scene() -> hou.Node:
+    hou.hipFile.clear(suppress_save_prompt=True)
+    stage = hou.node("/stage") or hou.node("/").createNode("lopnet", "stage")
+    for child in tuple(stage.children()):
+        child.destroy()
+    return stage
+
+
+def render_setting_nodes(parent: hou.Node):
+    return [child for child in parent.children() if child.type().name() == OPERATOR_TYPE]
+
+
+def usd_render_rops(parent: hou.Node):
+    return [child for child in parent.children() if child.type().name() == ROP_NODE_TYPE]
+
+
+def out_usd_render_rops():
+    out = hou.node("/out")
+    if out is None:
+        return []
+    return [child for child in out.children() if child.type().name() == OUT_ROP_NODE_TYPE]
+
+
+def owned_rops(parent: hou.Node):
+    return [rop for rop in usd_render_rops(parent) if rop.userData(OWNER_OPERATOR_KEY) == OPERATOR_TYPE]
+
+
+def rop_loppath_target(rop: hou.Node):
+    parm = rop.parm("loppath")
+    if parm is None:
+        return None
+    value = parm.eval()
+    if value.startswith("/"):
+        target = hou.node(value)
+    else:
+        target = rop.node(value)
+        if target is None and rop.parent() is not None:
+            target = rop.parent().node(value)
+    return target.path() if target is not None else value
+
+
+def rop_info(rop: hou.Node):
+    info = {
+        "path": rop.path(),
+        "input0": rop.input(0).path() if rop.input(0) is not None else None,
+        "renderer": rop.parm("renderer").eval() if rop.parm("renderer") else None,
+        "loppath": rop.parm("loppath").eval() if rop.parm("loppath") else None,
+        "loppath_target": rop_loppath_target(rop),
+        "rendersettings": rop.parm("rendersettings").eval() if rop.parm("rendersettings") else None,
+        "outputimage": rop.parm("outputimage").eval() if rop.parm("outputimage") else None,
+        "owner_path": rop.userData(OWNER_LOP_KEY),
+        "owner_operator": rop.userData(OWNER_OPERATOR_KEY),
+        "owner_session": rop.userData(OWNER_SESSION_KEY),
+    }
+    for name in ("loppath", "rendersettings", "outputimage"):
+        parm = rop.parm(name)
+        if parm is None:
+            continue
+        try:
+            info[name + "_raw"] = parm.rawValue()
+        except hou.OperationFailed:
+            info[name + "_raw"] = None
+        try:
+            info[name + "_expr"] = parm.expression()
+        except hou.OperationFailed:
+            info[name + "_expr"] = None
+        try:
+            info[name + "_unexpanded"] = parm.unexpandedString()
+        except hou.OperationFailed:
+            info[name + "_unexpanded"] = None
+        try:
+            info[name + "_keyframes"] = len(parm.keyframes())
+        except hou.OperationFailed:
+            info[name + "_keyframes"] = None
+        try:
+            info[name + "_time_dependent"] = parm.isTimeDependent()
+        except hou.OperationFailed:
+            info[name + "_time_dependent"] = None
+    return info
+
+
+def rop_graph_state(rop: hou.Node):
+    return {
+        **rop_info(rop),
+        "position": tuple(round(v, 4) for v in rop.position()),
+    }
+
+
+def owned_rop_for_node(node: hou.Node):
+    candidates = [rop for rop in owned_rops(node.parent()) if rop_loppath_target(rop) == node.path()]
+    return candidates
+
+
+def create_settings(parent: hou.Node, name: str | None = None) -> hou.Node:
+    if name is None:
+        return parent.createNode(OPERATOR_TYPE, exact_type_name=True)
+    return parent.createNode(OPERATOR_TYPE, name, exact_type_name=True)
+
+
+def press_repair(node: hou.Node) -> None:
+    node.parm("create_update_usd_render_rop").pressButton()
+
+
+def assert_one_owned_rop(test_name: str, node: hou.Node):
+    rops = owned_rop_for_node(node)
+    ok = len(rops) == 1 and rops[0].input(0) == node and rops[0].parm("renderer").eval() == RENDERER_TOKEN
+    check(test_name, ok, [rop_info(rop) for rop in rops])
+    return rops[0] if rops else None
+
+
+def assert_owned_rop_wiring(test_name: str, node: hou.Node, rop: hou.Node | None) -> None:
+    if rop is None:
+        fail(test_name, "no owned ROP")
+        return
+    info = rop_info(rop)
+    expected_loppath_raw = '`opinput(".", 0)`'
+    expected_settings_raw = '`chs("%s/render_settings_prim")`' % node.path()
+    expected_output_raw = '`chs("%s/product_name")`' % node.path()
+    ok = (
+        info.get("loppath_target") == node.path()
+        and info.get("loppath_raw") == expected_loppath_raw
+        and info.get("loppath_keyframes") == 0
+        and info.get("loppath_time_dependent") is False
+        and info.get("rendersettings") == node.parm("render_settings_prim").eval()
+        and info.get("rendersettings_raw") == expected_settings_raw
+        and info.get("rendersettings_keyframes") == 0
+        and info.get("rendersettings_time_dependent") is False
+        and info.get("outputimage") == node.parm("product_name").eval()
+        and info.get("outputimage_raw") == expected_output_raw
+        and info.get("outputimage_keyframes") == 0
+        and info.get("outputimage_time_dependent") is False
+    )
+    check(test_name, ok, info)
+
+
+def test_module_and_hda() -> None:
+    import moonray_render_settings
+
+    module_file = moonray_render_settings.__file__
+    check("module_import_path", module_file.endswith(EXPECTED_MODULE_SUFFIX), module_file)
+    check("scene_variable_count", len(moonray_render_settings.SCENE_VARIABLES) == EXPECTED_SCENE_VARIABLE_COUNT, len(moonray_render_settings.SCENE_VARIABLES))
+    check("native_aov_definition_count", len(moonray_render_settings.AOV_DEFINITIONS) == 9, [aov["parm"] for aov in moonray_render_settings.AOV_DEFINITIONS])
+    check(
+        "material_aov_definition_count",
+        len(moonray_render_settings.MATERIAL_AOV_DEFINITIONS) == 7,
+        [aov["parm"] for aov in moonray_render_settings.MATERIAL_AOV_DEFINITIONS],
+    )
+    all_aov_parms = [aov["parm"] for aov in moonray_render_settings.AOV_DEFINITIONS] + [
+        aov["parm"] for aov in moonray_render_settings.MATERIAL_AOV_DEFINITIONS
+    ]
+    forbidden = ("aov_camera_" + "depth", "aov_cryptomatte", "aov_lpe", "aov_visibility", "aov_motion_vector")
+    check("forbidden_aov_parms_absent", not any(name in all_aov_parms for name in forbidden), all_aov_parms)
+    node_type = hou.lopNodeTypeCategory().nodeTypes().get(OPERATOR_TYPE)
+    check("operator_type_name", node_type is not None, OPERATOR_TYPE)
+    definition = node_type.definition() if node_type is not None else None
+    check("hda_definition_library_path", definition is not None and definition.libraryFilePath().endswith("Lop::DW_MOONRAY::moonrayrendersettings::1.hda"), definition.libraryFilePath() if definition else None)
+    matches = []
+    for name, node_type in sorted(hou.lopNodeTypeCategory().nodeTypes().items()):
+        desc = node_type.description()
+        if "moonray" in (name + " " + desc).lower() and "rendersettings" in name.lower():
+            node_definition = node_type.definition()
+            matches.append(
+                {
+                    "name": name,
+                    "label": desc,
+                    "definition": node_definition.libraryFilePath() if node_definition else None,
+                }
+            )
+    check("single_moonray_render_settings_operator_definition", len(matches) == 1 and matches[0]["name"] == OPERATOR_TYPE, matches)
+
+
+def test_basic_creation_and_repair() -> hou.Node:
+    stage = clear_scene()
+    before_out = len(out_usd_render_rops())
+    node = create_settings(stage, "moonrayrendersettings1")
+    check("node_creation", node.type().name() == OPERATOR_TYPE and not node.errors(), {"path": node.path(), "errors": node.errors()})
+    product_name = node.parm("product_name")
+    check(
+        "default_product_name_not_time_dependent",
+        product_name is not None and product_name.rawValue().endswith("\\$F4.exr") and not product_name.isTimeDependent(),
+        {
+            "raw": product_name.rawValue() if product_name else None,
+            "eval": product_name.eval() if product_name else None,
+            "time_dependent": product_name.isTimeDependent() if product_name else None,
+        },
+    )
+    rop = assert_one_owned_rop("one_owned_connected_usdrender_rop", node)
+    assert_owned_rop_wiring("owned_usdrender_rop_uses_lop_expressions", node, rop)
+    check("no_out_usdrender_creation", len(out_usd_render_rops()) == before_out, {"before": before_out, "after": len(out_usd_render_rops())})
+    before_repair = rop_graph_state(rop) if rop is not None else None
+    press_repair(node)
+    press_repair(node)
+    rop = assert_one_owned_rop("repair_button_idempotency", node)
+    assert_owned_rop_wiring("repair_preserves_lop_expression_wiring", node, rop)
+    after_repair = rop_graph_state(rop) if rop is not None else None
+    check("initial_creation_matches_post_repair_graph", before_repair == after_repair, {"before": before_repair, "after": after_repair})
+    return stage
+
+
+def test_lifecycle_scenarios() -> None:
+    stage = clear_scene()
+
+    node1 = create_settings(stage, "moonrayrendersettings1")
+    node2 = create_settings(stage, "moonrayrendersettings2")
+    distinct = owned_rop_for_node(node1) + owned_rop_for_node(node2)
+    check("two_lops_two_distinct_owned_rops", len(distinct) == 2 and len({rop.path() for rop in distinct}) == 2, [rop_info(rop) for rop in distinct])
+    check(
+        "settings_nodes_do_not_share_rops",
+        len(owned_rop_for_node(node1)) == 1
+        and len(owned_rop_for_node(node2)) == 1
+        and owned_rop_for_node(node1)[0] is not owned_rop_for_node(node2)[0],
+        {"node1": [rop_info(rop) for rop in owned_rop_for_node(node1)], "node2": [rop_info(rop) for rop in owned_rop_for_node(node2)]},
+    )
+
+    node1.setName("moonraysettings_renamed")
+    press_repair(node1)
+    rop1 = assert_one_owned_rop("rename_owner_then_repair_updates_by_session", node1)
+    assert_owned_rop_wiring("rename_owner_then_repair_refreshes_expressions", node1, rop1)
+
+    if rop1 is not None:
+        rop1.setName("artist_renamed_rop")
+        press_repair(node1)
+        check("rename_owned_rop_then_repair_preserves_renamed_rop", rop1.name() == "artist_renamed_rop" and rop1.input(0) == node1, rop_info(rop1))
+        assert_owned_rop_wiring("rename_owned_rop_then_repair_keeps_expressions", node1, rop1)
+
+        rop1.destroy()
+        press_repair(node1)
+        rop1 = assert_one_owned_rop("delete_owned_rop_then_repair_recreates", node1)
+        assert_owned_rop_wiring("delete_owned_rop_then_repair_recreates_expressions", node1, rop1)
+
+    if rop1 is not None:
+        rop1.setInput(0, None)
+        press_repair(node1)
+        check("disconnect_owned_rop_then_repair_rewires", rop1.input(0) == node1, rop_info(rop1))
+        assert_owned_rop_wiring("disconnect_owned_rop_then_repair_keeps_expressions", node1, rop1)
+
+    # Raw HOM copy of only the LOP does not run OnCreated; this is an accepted limitation.
+    copied_lop = hou.copyNodesTo((node1,), stage)[0]
+    copied_owned = owned_rop_for_node(copied_lop)
+    if copied_owned:
+        pass_("raw_hom_copy_lop_only", [rop_info(rop) for rop in copied_owned])
+    else:
+        skip("raw_hom_copy_lop_only", "HOM copy of an existing node does not run OnCreated; press repair on the copied LOP.")
+        press_repair(copied_lop)
+        assert_one_owned_rop("raw_hom_copy_lop_only_repair", copied_lop)
+
+    pair_node = create_settings(stage, "pairsettings")
+    pair_rop = owned_rop_for_node(pair_node)[0]
+    copied_items = hou.copyNodesTo((pair_node, pair_rop), stage)
+    copied_pair_lops = [item for item in copied_items if item.type().name() == OPERATOR_TYPE]
+    copied_pair_rops = [item for item in copied_items if item.type().name() == ROP_NODE_TYPE]
+    check("duplicate_lop_rop_pair_raw_copy_non_destructive", len(copied_pair_lops) == 1 and len(copied_pair_rops) == 1, {"lops": [n.path() for n in copied_pair_lops], "rops": [rop_info(r) for r in copied_pair_rops]})
+    if copied_pair_lops:
+        press_repair(copied_pair_lops[0])
+        copied_pair_rop = assert_one_owned_rop("duplicate_lop_rop_pair_repair_refreshes_ownership", copied_pair_lops[0])
+        assert_owned_rop_wiring("duplicate_lop_rop_pair_repair_refreshes_expressions", copied_pair_lops[0], copied_pair_rop)
+
+    collision_stage = stage
+    foreign = collision_stage.createNode(ROP_NODE_TYPE, "moonrayrendersettings1_usdrender")
+    foreign.parm("renderer").set("BRAY_HdKarma")
+    collision_node = create_settings(collision_stage, "moonrayrendersettings1")
+    check("unrelated_colliding_rop_preserved", foreign.parm("renderer").eval() == "BRAY_HdKarma" and foreign not in owned_rop_for_node(collision_node), [rop_info(rop) for rop in usd_render_rops(collision_stage) if "moonrayrendersettings1_usdrender" in rop.name()])
+
+    fake = stage.createNode(ROP_NODE_TYPE, "moonrayfake_usdrender")
+    fake.setUserData(OWNER_OPERATOR_KEY, OPERATOR_TYPE)
+    fake.setUserData(OWNER_LOP_KEY, "/stage/not_real")
+    fake.parm("renderer").set("BRAY_HdKarma")
+    fake_node = create_settings(stage, "moonrayfake")
+    check("fake_stale_ownership_not_overwritten", fake.parm("renderer").eval() == "BRAY_HdKarma" and fake not in owned_rop_for_node(fake_node), [rop_info(rop) for rop in usd_render_rops(stage) if "moonrayfake" in rop.name()])
+
+    before_save = len(usd_render_rops(stage))
+    hip_path = os.path.join(tempfile.gettempdir(), "moonray_render_settings_lifecycle_validation.hip")
+    hou.hipFile.save(hip_path)
+    hou.hipFile.clear(suppress_save_prompt=True)
+    hou.hipFile.load(hip_path, suppress_save_prompt=True, ignore_load_warnings=True)
+    loaded_stage = hou.node("/stage")
+    after_load = len(usd_render_rops(loaded_stage))
+    check("save_reopen_no_extra_rops", before_save == after_load, {"before": before_save, "after": after_load, "file": hip_path})
+
+    node_type = hou.lopNodeTypeCategory().nodeTypes().get(OPERATOR_TYPE)
+    definition = node_type.definition() if node_type is not None else None
+    if definition is None:
+        skip("hda_reload_no_extra_rops", "operator definition unavailable")
+    else:
+        before_reload = len(usd_render_rops(loaded_stage))
+        hou.hda.reloadFile(definition.libraryFilePath())
+        after_reload = len(usd_render_rops(loaded_stage))
+        check("hda_reload_no_extra_rops", before_reload == after_reload, {"before": before_reload, "after": after_reload, "library": definition.libraryFilePath()})
+
+    loaded_settings = next((child for child in loaded_stage.children() if child.type().name() == OPERATOR_TYPE), None)
+    if loaded_settings is None:
+        skip("parameter_change_and_cook_no_extra_rops", "no loaded MoonRay Render Settings node found")
+    else:
+        before_change = len(usd_render_rops(loaded_stage))
+        loaded_settings.parm("product_name").set("/tmp/moonray_lifecycle.\\$F4.exr")
+        try:
+            loaded_settings.cook(force=True)
+            details = {"errors": loaded_settings.errors(), "warnings": loaded_settings.warnings()}
+        except hou.OperationFailed as exc:
+            details = {"exception": str(exc), "errors": loaded_settings.errors(), "warnings": loaded_settings.warnings()}
+        after_change = len(usd_render_rops(loaded_stage))
+        check("parameter_change_and_cook_no_extra_rops", before_change == after_change, {"before": before_change, "after": after_change, **details})
+        loaded_rops = owned_rop_for_node(loaded_settings)
+        follows_product = bool(loaded_rops) and loaded_rops[0].parm("outputimage").eval() == loaded_settings.parm("product_name").eval()
+        check(
+            "owned_rop_outputimage_follows_product_name",
+            follows_product,
+            {"rops": [rop_info(rop) for rop in loaded_rops], "product_name": loaded_settings.parm("product_name").eval()},
+        )
+
+    skip("undo_redo_creation", "Houdini hython does not provide a reliable undo/redo UI event test for this lifecycle; validate manually in UI if needed.")
+
+
+
+def test_manual_ui_creation_paths() -> None:
+    skip(
+        "moonray_menu_tool_creation_path",
+        "Requires graphical Houdini 20.5 hou.ui interaction; hython cannot exercise the real MoonRay Tab/shelf UI path.",
+    )
+    skip(
+        "digital_assets_creation_path",
+        "Requires graphical Houdini 20.5 Tab menu interaction; hython can report the operator definition but cannot click the Digital Assets entry.",
+    )
+    skip(
+        "mixed_menu_path_two_node_sharing",
+        "Requires graphical Houdini 20.5 creation from both menu presentation paths; not claimable from hython.",
+    )
+
+def test_resolution_and_usd_contract() -> None:
+    stage = clear_scene()
+    setup = stage.createNode("pythonscript", "camera_setup")
+    setup.parm("python").set(
+        "import hou\n"
+        "from pxr import UsdGeom, Gf\n"
+        "stage = hou.pwd().editableStage()\n"
+        "cam = UsdGeom.Camera.Define(stage, '/cameras/camera1')\n"
+        "UsdGeom.Xformable(cam).AddTranslateOp().Set(Gf.Vec3d(0, 0, 5))\n"
+        "cam.GetHorizontalApertureAttr().Set(40)\n"
+        "cam.GetVerticalApertureAttr().Set(20)\n"
+    )
+    node = create_settings(stage, "moonrayrendersettings1")
+    node.setInput(0, setup)
+
+    check("computed_resolution_modes_removed", node.parm("res_mode") is None, "res_mode parm absent")
+    mode_note = node.parm("resolution_mode_note")
+    check("manual_resolution_mode_note", mode_note is not None, mode_note.eval() if mode_note is not None else None)
+    ptg_text = str(node.parmTemplateGroup())
+    check(
+        "computed_resolution_callbacks_absent",
+        "computeResolutionParameter" not in ptg_text and "updateResolutionParameters" not in ptg_text,
+        "no loputils computed-resolution callback references",
+    )
+    import moonray_render_settings
+
+    scene_variable_names = {name for name, _ in moonray_render_settings.SCENE_VARIABLES}
+    check(
+        "scene_variables_exclude_image_width_height",
+        "image_width" not in scene_variable_names and "image_height" not in scene_variable_names,
+        sorted(name for name in scene_variable_names if name in ("image_width", "image_height")),
+    )
+    expected_aov_toggles = sorted(
+        ["aov_beauty"]
+        + [aov["parm"] for aov in moonray_render_settings.AOV_DEFINITIONS]
+        + [aov["parm"] for aov in moonray_render_settings.MATERIAL_AOV_DEFINITIONS]
+    )
+    aov_toggles = sorted(
+        parm.name()
+        for parm in node.parms()
+        if parm.name().startswith("aov_")
+        and parm.parmTemplate().type() == hou.parmTemplateType.Toggle
+    )
+    check("aov_toggle_set", aov_toggles == expected_aov_toggles, aov_toggles)
+    check("beauty_internal_name_preserved", "aov_beauty" in aov_toggles, aov_toggles)
+    beauty = node.parm("aov_beauty")
+    beauty_template = beauty.parmTemplate() if beauty is not None else None
+    check("beauty_default_on_for_disk_output", beauty is not None and bool(beauty.eval()), beauty.eval() if beauty is not None else None)
+    check(
+        "beauty_disk_output_label",
+        beauty_template is not None and beauty_template.label() == "Beauty RenderVar / Disk Output Path",
+        beauty_template.label() if beauty_template is not None else None,
+    )
+    aov_defaults = {aov["parm"]: node.parm(aov["parm"]).eval() if node.parm(aov["parm"]) is not None else None for aov in moonray_render_settings.AOV_DEFINITIONS}
+    check("native_aov_toggles_default_off", all(value == 0 for value in aov_defaults.values()), aov_defaults)
+    folders = folder_template_names_and_labels(node.parmTemplateGroup())
+    check("native_aov_folder_present", any(label == "AOVs" for _, label in folders), folders)
+    check("material_denoise_aov_folder_present", any(label == "Material / Denoise AOVs" for _, label in folders), folders)
+    check(
+        "deferred_aov_families_not_exposed",
+        not any(name in aov_toggles for name in ("aov_camera_" + "depth", "aov_lpe", "aov_cryptomatte", "aov_visibility", "aov_motionvec")),
+        aov_toggles,
+    )
+    sampling_mode_template = node.parm("sceneVariable_sampling_mode").parmTemplate()
+    light_sampling_mode_template = node.parm("sceneVariable_light_sampling_mode").parmTemplate()
+    sampling_mode_items = sampling_mode_template.menuItems()
+    light_sampling_mode_items = light_sampling_mode_template.menuItems()
+    check("sampling_menu_items", sampling_mode_items == ("uniform", "adaptive"), sampling_mode_items)
+    check("light_sampling_menu_items", light_sampling_mode_items == ("uniform", "adaptive"), light_sampling_mode_items)
+    uniform_token, adaptive_token = sampling_mode_items
+    _, light_adaptive_token = light_sampling_mode_items
+    sampling_conditions = {
+        "sceneVariable_pixel_samples": "{ sceneVariable_sampling_mode != %s }" % uniform_token,
+        "sceneVariable_min_adaptive_samples": "{ sceneVariable_sampling_mode != %s }" % adaptive_token,
+        "sceneVariable_max_adaptive_samples": "{ sceneVariable_sampling_mode != %s }" % adaptive_token,
+        "sceneVariable_target_adaptive_error": "{ sceneVariable_sampling_mode != %s }" % adaptive_token,
+        "sceneVariable_light_sampling_quality": "{ sceneVariable_light_sampling_mode != %s }" % light_adaptive_token,
+    }
+    for parm_name, expected in sampling_conditions.items():
+        parm = node.parm(parm_name)
+        actual = disable_when(parm) if parm is not None else None
+        check("sampling_disablewhen_" + parm_name, actual == expected, actual)
+
+    node.parm("camera").set("/cameras/camera1")
+    node.parm("resolutionx").set(512)
+    node.parm("resolutiony").set(256)
+    value = tuple(node.parmTuple("resolution").eval())
+    check("manual_resolution", value == (512, 256), value)
+
+    node.cook(force=True)
+    usd_path = os.path.join(tempfile.gettempdir(), "moonray_render_settings_lifecycle_validation.usda")
+    node.stage().Flatten().Export(usd_path)
+    text = open(usd_path, "r", encoding="utf-8").read()
+    default_checks = {
+        "RenderSettings": 'def RenderSettings "rendersettings"' in text,
+        "RenderProduct": 'def RenderProduct "renderproduct"' in text,
+        "RenderVar_by_default": 'def RenderVar "beauty"' in text,
+        "products_rel": 'rel products = </Render/Products/renderproduct>' in text,
+        "orderedVars_by_default": 'rel orderedVars = </Render/Products/Vars/beauty>' in text,
+        "camera_rel": 'rel camera = </cameras/camera1>' in text,
+        "resolution": 'uniform int2 resolution = (512, 256)' in text,
+        "no_custom_image_width": 'moonray:sceneVariable:image_width' not in text,
+        "no_custom_image_height": 'moonray:sceneVariable:image_height' not in text,
+    }
+    for test_name, ok in default_checks.items():
+        check("usd_default_contract_" + test_name, ok, usd_path)
+    default_non_beauty_absent = {
+        aov["render_var"]: ('def RenderVar "%s"' % aov["render_var"]) not in text
+        for aov in moonray_render_settings.AOV_DEFINITIONS
+    }
+    check("usd_default_contract_non_beauty_aovs_absent", all(default_non_beauty_absent.values()), default_non_beauty_absent)
+
+    node.parm("sceneVariable_sampling_mode").set(1)
+    node.parm("sceneVariable_min_adaptive_samples").set(3)
+    node.parm("sceneVariable_max_adaptive_samples").set(99)
+    node.parm("sceneVariable_target_adaptive_error").set(7)
+    node.cook(force=True)
+    adaptive_usd_path = os.path.join(tempfile.gettempdir(), "moonray_render_settings_lifecycle_validation_adaptive.usda")
+    node.stage().Flatten().Export(adaptive_usd_path)
+    adaptive_text = open(adaptive_usd_path, "r", encoding="utf-8").read()
+    adaptive_checks = {
+        "sampling_mode_adaptive": 'custom token moonray:sceneVariable:sampling_mode = "adaptive"' in adaptive_text,
+        "min_adaptive_samples": "custom int moonray:sceneVariable:min_adaptive_samples = 3" in adaptive_text,
+        "max_adaptive_samples": "custom int moonray:sceneVariable:max_adaptive_samples = 99" in adaptive_text,
+        "target_adaptive_error": "custom float moonray:sceneVariable:target_adaptive_error = 7" in adaptive_text,
+        "pixel_samples_still_authored": "custom int moonray:sceneVariable:pixel_samples = 8" in adaptive_text,
+    }
+    for test_name, ok in adaptive_checks.items():
+        check("usd_sampling_toggle_" + test_name, ok, adaptive_usd_path)
+
+    node.parm("sceneVariable_sampling_mode").set(0)
+    node.cook(force=True)
+    uniform_usd_path = os.path.join(tempfile.gettempdir(), "moonray_render_settings_lifecycle_validation_uniform.usda")
+    node.stage().Flatten().Export(uniform_usd_path)
+    uniform_text = open(uniform_usd_path, "r", encoding="utf-8").read()
+    uniform_checks = {
+        "sampling_mode_uniform": 'custom token moonray:sceneVariable:sampling_mode = "uniform"' in uniform_text,
+        "adaptive_values_preserved_but_inactive": "custom int moonray:sceneVariable:max_adaptive_samples = 99" in uniform_text,
+    }
+    for test_name, ok in uniform_checks.items():
+        check("usd_sampling_toggle_" + test_name, ok, uniform_usd_path)
+
+    node.parm("aov_beauty").set(0)
+    node.cook(force=True)
+    diagnostic_usd_path = os.path.join(tempfile.gettempdir(), "moonray_render_settings_lifecycle_validation_no_beauty.usda")
+    node.stage().Flatten().Export(diagnostic_usd_path)
+    diagnostic_text = open(diagnostic_usd_path, "r", encoding="utf-8").read()
+    diagnostic_checks = {
+        "no_RenderVar_when_disabled": 'def RenderVar "beauty"' not in diagnostic_text,
+        "empty_orderedVars_when_disabled": 'rel orderedVars' in diagnostic_text and 'rel orderedVars = </Render/Products/Vars/beauty>' not in diagnostic_text,
+    }
+    for test_name, ok in diagnostic_checks.items():
+        check("usd_diagnostic_no_beauty_contract_" + test_name, ok, diagnostic_usd_path)
+
+    node.parm("aov_beauty").set(1)
+    node.cook(force=True)
+    debug_usd_path = os.path.join(tempfile.gettempdir(), "moonray_render_settings_lifecycle_validation_debug_beauty.usda")
+    node.stage().Flatten().Export(debug_usd_path)
+    debug_text = open(debug_usd_path, "r", encoding="utf-8").read()
+    debug_checks = {
+        "RenderVar_when_enabled": 'def RenderVar "beauty"' in debug_text,
+        "orderedVars_when_enabled": 'rel orderedVars = </Render/Products/Vars/beauty>' in debug_text,
+        "beauty_dataType": 'uniform token dataType = "color4f"' in debug_text,
+        "beauty_sourceType": 'uniform token sourceType = "raw"' in debug_text,
+        "beauty_format": 'driver:parameters:aov:format = "color4f"' in debug_text,
+        "beauty_multiSampled": 'driver:parameters:aov:multiSampled = 0' in debug_text,
+        "beauty_clearValue": 'driver:parameters:aov:clearValue = 0' in debug_text,
+        "beauty_only_orderedVars": debug_text.count("rel orderedVars = </Render/Products/Vars/beauty>") == 1,
+    }
+    for test_name, ok in debug_checks.items():
+        check("usd_debug_beauty_contract_" + test_name, ok, debug_usd_path)
+
+    for aov in moonray_render_settings.AOV_DEFINITIONS:
+        node.parm(aov["parm"]).set(1)
+    node.cook(force=True)
+    native_aov_usd_path = os.path.join(tempfile.gettempdir(), "moonray_render_settings_lifecycle_validation_native_aovs.usda")
+    node.stage().Flatten().Export(native_aov_usd_path)
+    stage_obj = node.stage()
+    product = UsdRender.Product(stage_obj.GetPrimAtPath("/Render/Products/renderproduct"))
+    targets = [str(target) for target in product.GetOrderedVarsRel().GetTargets()]
+    expected_targets = ["/Render/Products/Vars/beauty"] + [
+        "/Render/Products/Vars/" + aov["render_var"]
+        for aov in moonray_render_settings.AOV_DEFINITIONS
+    ]
+    check("usd_native_aovs_orderedVars", targets == expected_targets, targets)
+    expected_render_vars = {"beauty"} | {aov["render_var"] for aov in moonray_render_settings.AOV_DEFINITIONS}
+    vars_prim = stage_obj.GetPrimAtPath("/Render/Products/Vars")
+    authored_render_vars = {child.GetName() for child in vars_prim.GetChildren()} if vars_prim.IsValid() else set()
+    check("usd_native_aovs_no_extra_renderVars", authored_render_vars == expected_render_vars, sorted(authored_render_vars))
+    for aov in moonray_render_settings.AOV_DEFINITIONS:
+        path = "/Render/Products/Vars/" + aov["render_var"]
+        render_var = UsdRender.Var(stage_obj.GetPrimAtPath(path))
+        attrs = {
+            "dataType": str(render_var.GetDataTypeAttr().Get()),
+            "sourceName": render_var.GetSourceNameAttr().Get(),
+            "sourceType": str(render_var.GetSourceTypeAttr().Get()),
+            "aov_name": render_var.GetPrim().GetAttribute("driver:parameters:aov:name").Get(),
+            "aov_format": str(render_var.GetPrim().GetAttribute("driver:parameters:aov:format").Get()),
+            "multiSampled": render_var.GetPrim().GetAttribute("driver:parameters:aov:multiSampled").Get(),
+            "clearValue": render_var.GetPrim().GetAttribute("driver:parameters:aov:clearValue").Get(),
+        }
+        ok = (
+            attrs["dataType"] == aov["data_type"]
+            and attrs["sourceName"] == aov["source_name"]
+            and attrs["sourceType"] == "raw"
+            and attrs["aov_name"] == aov["source_name"]
+            and attrs["aov_format"] == aov["data_type"]
+            and attrs["multiSampled"] is False
+            and attrs["clearValue"] == 0
+        )
+        check("usd_native_aov_contract_" + aov["render_var"], ok, {"path": path, **attrs})
+
+    stage = clear_scene()
+    node = create_settings(stage, "moonrayrendersettings1")
+    folder_labels = folder_template_names_and_labels(node.parmTemplateGroup())
+    check(
+        "material_denoise_aov_folder_exists",
+        any(label == "Material / Denoise AOVs" for _, label in folder_labels),
+        folder_labels,
+    )
+    for aov in moonray_render_settings.MATERIAL_AOV_DEFINITIONS:
+        parm = node.parm(aov["parm"])
+        check("material_aov_toggle_default_off_" + aov["parm"], parm is not None and parm.eval() == 0, parm.eval() if parm else None)
+
+    required_controls = {"aov_denoise_albedo", "aov_denoise_normal"}
+    material_controls = {aov["parm"] for aov in moonray_render_settings.MATERIAL_AOV_DEFINITIONS}
+    check("required_denoise_controls_exist", required_controls <= material_controls, sorted(material_controls))
+
+    for aov in moonray_render_settings.MATERIAL_AOV_DEFINITIONS:
+        node.parm(aov["parm"]).set(1)
+    node.cook(force=True)
+    material_aov_usd_path = os.path.join(tempfile.gettempdir(), "moonray_render_settings_lifecycle_validation_material_aovs.usda")
+    node.stage().Flatten().Export(material_aov_usd_path)
+    stage_obj = node.stage()
+    product = UsdRender.Product(stage_obj.GetPrimAtPath("/Render/Products/renderproduct"))
+    targets = [str(target) for target in product.GetOrderedVarsRel().GetTargets()]
+    expected_targets = ["/Render/Products/Vars/beauty"] + [
+        "/Render/Products/Vars/" + aov["render_var"]
+        for aov in moonray_render_settings.MATERIAL_AOV_DEFINITIONS
+    ]
+    check("usd_material_aovs_orderedVars", targets == expected_targets, targets)
+    expected_render_vars = {"beauty"} | {aov["render_var"] for aov in moonray_render_settings.MATERIAL_AOV_DEFINITIONS}
+    vars_prim = stage_obj.GetPrimAtPath("/Render/Products/Vars")
+    authored_render_vars = {child.GetName() for child in vars_prim.GetChildren()} if vars_prim.IsValid() else set()
+    check("usd_material_aovs_no_extra_renderVars", authored_render_vars == expected_render_vars, sorted(authored_render_vars))
+    diagnostic_depth_token = "camera" + "Depth"
+    check("usd_material_aovs_no_diagnostic_depth_token", diagnostic_depth_token not in authored_render_vars, sorted(authored_render_vars))
+    for aov in moonray_render_settings.MATERIAL_AOV_DEFINITIONS:
+        path = "/Render/Products/Vars/" + aov["render_var"]
+        render_var = UsdRender.Var(stage_obj.GetPrimAtPath(path))
+        prim = render_var.GetPrim()
+        attrs = {
+            "dataType": str(render_var.GetDataTypeAttr().Get()),
+            "sourceName": render_var.GetSourceNameAttr().Get(),
+            "sourceType": str(render_var.GetSourceTypeAttr().Get()),
+            "aov_name": prim.GetAttribute("driver:parameters:aov:name").Get(),
+            "aov_format": str(prim.GetAttribute("driver:parameters:aov:format").Get()),
+            "multiSampled": prim.GetAttribute("driver:parameters:aov:multiSampled").Get(),
+            "clearValue": prim.GetAttribute("driver:parameters:aov:clearValue").Get(),
+        }
+        for attr_name in aov.get("extra_attrs", {}):
+            attrs[attr_name] = prim.GetAttribute(attr_name).Get()
+        ok = (
+            attrs["dataType"] == aov["data_type"]
+            and attrs["sourceName"] == aov["source_name"]
+            and attrs["sourceType"] == aov.get("source_type", "raw")
+            and attrs["aov_name"] == aov["source_name"]
+            and attrs["aov_format"] == aov["data_type"]
+            and attrs["multiSampled"] is False
+            and attrs["clearValue"] == 0
+        )
+        for attr_name, (_, expected_value) in aov.get("extra_attrs", {}).items():
+            ok = ok and attrs[attr_name] == expected_value
+        check("usd_material_aov_contract_" + aov["render_var"], ok, {"path": path, **attrs})
+
+def test_rdla_receipt() -> None:
+    # RDLA export is practical but can be slow; use a tiny lit fixture and a timeout.
+    stage = clear_scene()
+    setup = stage.createNode("pythonscript", "rdla_setup")
+    setup.parm("python").set(
+        "import hou\n"
+        "from pxr import UsdGeom, UsdLux, Gf\n"
+        "stage = hou.pwd().editableStage()\n"
+        "cam = UsdGeom.Camera.Define(stage, '/cameras/camera1')\n"
+        "UsdGeom.Xformable(cam).AddTranslateOp().Set(Gf.Vec3d(0, 0, 5))\n"
+        "UsdGeom.Sphere.Define(stage, '/World/Sphere')\n"
+        "light = UsdLux.SphereLight.Define(stage, '/World/Light')\n"
+        "light.CreateIntensityAttr().Set(500.0)\n"
+        "UsdGeom.Xformable(light).AddTranslateOp().Set(Gf.Vec3d(0, 3, 3))\n"
+    )
+    node = create_settings(stage, "moonrayrendersettings1")
+    node.setInput(0, setup)
+    node.parm("rdlOutput").set(os.path.join(tempfile.gettempdir(), "moonray_lifecycle_validation.rdla"))
+    node.parm("sceneVariable_target_adaptive_error").set(7.5)
+    node.parm("sceneVariable_roughness_clamping_factor").set(0.35)
+    node.parm("sceneVariable_light_sampling_quality").set(0.77)
+    node.cook(force=True)
+    usd_path = os.path.join(tempfile.gettempdir(), "moonray_lifecycle_rdla.usda")
+    node.stage().Flatten().Export(usd_path)
+    rdla_path = node.parm("rdlOutput").eval()
+    husk = "/Applications/Houdini/Houdini20.5.584/Frameworks/Houdini.framework/Versions/20.5/Resources/bin/husk"
+    if not os.path.exists(husk):
+        skip("rdla_scenevariable_receipt", "husk not found")
+        return
+    log_path = "/tmp/moonray_lifecycle_validation_husk.log"
+    cmd = [husk, "-R", "HdMoonrayRendererPlugin", "--settings", "/Render/rendersettings", "-o", "/tmp/moonray_lifecycle_validation.exr", usd_path]
+    try:
+        with open(log_path, "w", encoding="utf-8") as log:
+            result = subprocess.run(cmd, stdout=log, stderr=subprocess.STDOUT, timeout=90)
+    except subprocess.TimeoutExpired:
+        skip("rdla_scenevariable_receipt", f"husk timed out; see {log_path}")
+        return
+    if result.returncode != 0 or not os.path.exists(rdla_path):
+        skip("rdla_scenevariable_receipt", f"husk/RDLA unavailable rc={result.returncode}; see {log_path}")
+        return
+    text = open(rdla_path, "r", encoding="utf-8", errors="replace").read()
+    ok = all(key in text for key in ("target_adaptive_error", "roughness_clamping_factor", "light_sampling_quality"))
+    check("rdla_scenevariable_receipt", ok, rdla_path)
+
+
+def _time_sampled_attrs(stage: Usd.Stage) -> list[tuple[str, str, tuple[float, ...]]]:
+    samples = []
+    for prim in stage.Traverse():
+        for attr in prim.GetAttributes():
+            times = attr.GetTimeSamples()
+            if times:
+                samples.append((str(prim.GetPath()), attr.GetName(), tuple(times)))
+    return samples
+
+
+def test_native_spotlight_toggle_is_static() -> None:
+    stage = clear_scene()
+    light = stage.createNode("light", "moonray_spotlight_static_probe")
+    light.cook(force=True)
+
+    enable = light.parm("xn__moonraynative_spotlight_rqa")
+    control = light.parm("xn__moonrayclass_control_o8a")
+    klass = light.parm("xn__moonrayclass_nva")
+    if enable is None or control is None or klass is None:
+        skip("native_spotlight_static_toggle", "MoonRay Light DS parameters are unavailable")
+        return
+
+    before_samples = _time_sampled_attrs(light.stage())
+    before_helper = light.userData("moonray_native_spotlight_helper")
+    callback = enable.parmTemplate().tags().get("script_callback")
+    if not callback:
+        fail("native_spotlight_static_toggle", "missing callback")
+        return
+
+    enable.set(1)
+    exec(callback, {"hou": hou}, {"kwargs": {"node": light, "parm": enable}})
+    light.cook(force=True)
+
+    try:
+        klass_expression = klass.expression()
+    except hou.OperationFailed:
+        klass_expression = None
+
+    after_samples = _time_sampled_attrs(light.stage())
+    after_helper = light.userData("moonray_native_spotlight_helper")
+    details = {
+        "node_time_dependent": light.isTimeDependent(),
+        "enable": enable.evalAsString(),
+        "control": control.evalAsString(),
+        "class": klass.evalAsString(),
+        "class_raw": klass.rawValue(),
+        "class_expression": klass_expression,
+        "class_keyframes": [(kf.frame(), kf.expression()) for kf in klass.keyframes()],
+        "before_helper_user_data": before_helper,
+        "after_helper_user_data": after_helper,
+        "before_time_samples": before_samples,
+        "after_time_samples": after_samples,
+    }
+    check(
+        "native_spotlight_static_toggle",
+        not light.isTimeDependent()
+        and enable.eval() == 1
+        and control.evalAsString() == "set"
+        and klass.evalAsString() == "SpotLight"
+        and klass.rawValue() == "SpotLight"
+        and klass_expression is None
+        and not klass.keyframes()
+        and before_helper is None
+        and after_helper is None
+        and not before_samples
+        and not after_samples,
+        details,
+    )
+
+
+def main() -> int:
+    test_module_and_hda()
+    test_basic_creation_and_repair()
+    test_lifecycle_scenarios()
+    test_manual_ui_creation_paths()
+    test_resolution_and_usd_contract()
+    test_native_spotlight_toggle_is_static()
+    test_rdla_receipt()
+
+    counts = {"PASS": 0, "FAIL": 0, "SKIP": 0}
+    for status, _, _ in RESULTS:
+        counts[status] = counts.get(status, 0) + 1
+    print("SUMMARY PASS={PASS} FAIL={FAIL} SKIP={SKIP}".format(**counts))
+    return 1 if counts.get("FAIL", 0) else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/houdini/toolbar/MoonRayTools.shelf b/houdini/toolbar/MoonRayTools.shelf
new file mode 100644
index 0000000..8cb0dd9
--- /dev/null
+++ b/houdini/toolbar/MoonRayTools.shelf
@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<shelfDocument>
+  <tool name="moonraymaterialbuilder" label="MoonRay Material Builder" icon="VOP_raytrace">
+    <helpText><![CDATA[Create an editable MoonRay-native material subnet with DwaBaseMaterial connected to the MoonRay surface output and a valid no-op NormalDisplacement path connected to displacement.]]></helpText>
+    <toolMenuContext name="network">
+      <contextOpType>Vop/materialbuilder</contextOpType>
+    </toolMenuContext>
+    <toolSubmenu>MoonRay</toolSubmenu>
+    <script scriptType="python"><![CDATA[
+import moonray_material_builder
+moonray_material_builder.create_moonray_material_builder(kwargs)
+]]></script>
+    <keywordList>
+      <keyword>MoonRay</keyword>
+      <keyword>DW_MOONRAY</keyword>
+      <keyword>DwaBaseMaterial</keyword>
+      <keyword>dwa</keyword>
+      <keyword>material builder</keyword>
+    </keywordList>
+  </tool>
+  <tool name="moonrayrendersettings" label="MoonRay Render Settings" icon="ROP_usdrender">
+    <helpText><![CDATA[Create a MoonRay Solaris Render Settings node that authors USD RenderSettings, RenderProduct, a beauty RenderVar, and hdMoonRay moonray:sceneVariable renderer settings.]]></helpText>
+    <toolMenuContext name="viewer">
+      <contextNetType>LOP</contextNetType>
+    </toolMenuContext>
+    <toolMenuContext name="network">
+      <contextNetType>LOP</contextNetType>
+    </toolMenuContext>
+    <toolSubmenu>MoonRay</toolSubmenu>
+    <script scriptType="python"><![CDATA[
+import loptoolutils
+node = loptoolutils.genericTool(kwargs, "Lop::DW_MOONRAY::moonrayrendersettings::1", "moonrayrendersettings")
+node.setCurrent(True)
+node.setSelected(True)
+]]></script>
+    <keywordList>
+      <keyword>MoonRay</keyword>
+      <keyword>Render Settings</keyword>
+      <keyword>HdMoonrayRendererPlugin</keyword>
+      <keyword>husk</keyword>
+      <keyword>rdl</keyword>
+    </keywordList>
+  </tool>
+</shelfDocument>