@zephyr3d/editor 0.3.0 → 0.3.1

package/dist/modules/zephyr3d_scene.js

@@ -5616,25 +5616,25 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
         dstClip.addTrack(remap.dstNode, track);
     }
 }
-/**
- * Animation set
- *
- * Manages a collection of named animation clips for a model and orchestrates:
- * - Playback state (time, loops, speed, weights, fade-in/out).
- * - Blending across multiple tracks targeting the same property via weighted averages.
- * - Skeleton usage and application for clips that drive skeletal animation.
- * - Active track registration and cleanup as clips start/stop.
- *
- * Usage:
- * - Create or retrieve `AnimationClip`s by name.
- * - Start playback with `playAnimation(name, options)`.
- * - Advance animation with `update(deltaSeconds)`.
- * - Optionally adjust weight while playing with `setAnimationWeight(name, weight)`.
- *
- * Lifetime:
- * - Disposing the set releases references to the model, clips, and clears active state.
- *
- * @public
+/**
+ * Animation set
+ *
+ * Manages a collection of named animation clips for a model and orchestrates:
+ * - Playback state (time, loops, speed, weights, fade-in/out).
+ * - Blending across multiple tracks targeting the same property via weighted averages.
+ * - Skeleton usage and application for clips that drive skeletal animation.
+ * - Active track registration and cleanup as clips start/stop.
+ *
+ * Usage:
+ * - Create or retrieve `AnimationClip`s by name.
+ * - Start playback with `playAnimation(name, options)`.
+ * - Advance animation with `update(deltaSeconds)`.
+ * - Optionally adjust weight while playing with `setAnimationWeight(name, weight)`.
+ *
+ * Lifetime:
+ * - Disposing the set releases references to the model, clips, and clears active state.
+ *
+ * @public
  */ class AnimationSet extends Disposable {
     /** @internal */ _model;
     /** @internal */ _animations;
@@ -5642,10 +5642,10 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
     /** @internal */ _activeTracks;
     /** @internal */ _activeSkeletons;
     /** @internal */ _activeAnimations;
-    /**
-   * Create an AnimationSet controlling the provided model.
-   *
-   * @param model - The SceneNode (model root) controlled by this animation set.
+    /**
+   * Create an AnimationSet controlling the provided model.
+   *
+   * @param model - The SceneNode (model root) controlled by this animation set.
    */ constructor(model){
         super();
         this._model = model;
@@ -5655,35 +5655,35 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
         this._activeAnimations = new Map();
         this._skeletons = [];
     }
-    /**
-   * The model (SceneNode) controlled by this animation set.
+    /**
+   * The model (SceneNode) controlled by this animation set.
    */ get model() {
         return this._model;
     }
-    /**
-   * Number of animation clips registered in this set.
+    /**
+   * Number of animation clips registered in this set.
    */ get numAnimations() {
         return Object.getOwnPropertyNames(this._animations).length;
     }
-    /**
-   * The skeletons used by animations in this set.
+    /**
+   * The skeletons used by animations in this set.
    */ get skeletons() {
         return this._skeletons;
     }
-    /**
-   * Retrieve an animation clip by name.
-   *
-   * @param name - Name of the animation.
-   * @returns The clip if present; otherwise null.
+    /**
+   * Retrieve an animation clip by name.
+   *
+   * @param name - Name of the animation.
+   * @returns The clip if present; otherwise null.
    */ get(name) {
         return this._animations[name] ?? null;
     }
-    /**
-   * Create and register a new animation clip.
-   *
-   * @param name - Unique name for the animation clip.
-   * @param embedded - Whether the clip is embedded/owned (implementation-specific). Default false.
-   * @returns The created clip, or null if the name is empty or not unique.
+    /**
+   * Create and register a new animation clip.
+   *
+   * @param name - Unique name for the animation clip.
+   * @param embedded - Whether the clip is embedded/owned (implementation-specific). Default false.
+   * @returns The created clip, or null if the name is empty or not unique.
    */ createAnimation(name, embedded = false) {
         if (!name || this._animations[name]) {
             console.error('Animation must have unique name');
@@ -5695,12 +5695,12 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
             return animation;
         }
     }
-    /**
-   * Delete and dispose an animation clip by name.
-   *
-   * - If the animation is currently playing, it is first stopped (immediately).
-   *
-   * @param name - Name of the animation to remove.
+    /**
+   * Delete and dispose an animation clip by name.
+   *
+   * - If the animation is currently playing, it is first stopped (immediately).
+   *
+   * @param name - Name of the animation to remove.
    */ deleteAnimation(name) {
         const animation = this._animations[name];
         if (animation) {
@@ -5709,24 +5709,24 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
             animation.dispose();
         }
     }
-    /**
-   * Get the list of all registered animation names.
-   *
-   * @returns An array of clip names.
+    /**
+   * Get the list of all registered animation names.
+   *
+   * @returns An array of clip names.
    */ getAnimationNames() {
         return Object.keys(this._animations);
     }
-    /**
-   * Advance and apply active animations.
-   *
-   * Responsibilities per call:
-   * - Update time cursor for each active clip (respecting speedRatio and looping).
-   * - Enforce repeat limits and apply fade-out termination if configured.
-   * - For each animated target, blend active tracks (weighted by clip weight × fade-in × fade-out)
-   *   and apply the resulting state to the target.
-   * - Apply all active skeletons to update skinning transforms.
-   *
-   * @param deltaInSeconds - Time step in seconds since last update.
+    /**
+   * Advance and apply active animations.
+   *
+   * Responsibilities per call:
+   * - Update time cursor for each active clip (respecting speedRatio and looping).
+   * - Enforce repeat limits and apply fade-out termination if configured.
+   * - For each animated target, blend active tracks (weighted by clip weight × fade-in × fade-out)
+   *   and apply the resulting state to the target.
+   * - Apply all active skeletons to update skinning transforms.
+   *
+   * @param deltaInSeconds - Time step in seconds since last update.
    */ update(deltaInSeconds) {
         this._activeAnimations.forEach((v, k)=>{
             if (v.fadeOut > 0 && v.fadeOutStart < 0) {
@@ -5788,11 +5788,11 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
             v.get()?.apply(deltaInSeconds);
         });
     }
-    /**
-   * Check whether an animation is currently playing.
-   *
-   * @param name - Optional animation name. If omitted, returns true if any animation is playing.
-   * @returns True if playing; otherwise false.
+    /**
+   * Check whether an animation is currently playing.
+   *
+   * @param name - Optional animation name. If omitted, returns true if any animation is playing.
+   * @returns True if playing; otherwise false.
    */ isPlayingAnimation(name) {
         if (name) {
             const animation = this._animations[name];
@@ -5800,23 +5800,23 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
         }
         return this._activeAnimations.size > 0;
     }
-    /**
-   * Get an animation clip by name.
-   *
-   * Alias of `get(name)` returning a nullable type.
-   *
-   * @param name - Name of the animation.
-   * @returns The clip if present; otherwise null.
+    /**
+   * Get an animation clip by name.
+   *
+   * Alias of `get(name)` returning a nullable type.
+   *
+   * @param name - Name of the animation.
+   * @returns The clip if present; otherwise null.
    */ getAnimationClip(name) {
         return this._animations[name] ?? null;
     }
-    /**
-   * Set the runtime blend weight for a currently playing animation.
-   *
-   * Has no effect if the clip is not active.
-   *
-   * @param name - Name of the playing animation.
-   * @param weight - New weight value used during blending.
+    /**
+   * Set the runtime blend weight for a currently playing animation.
+   *
+   * Has no effect if the clip is not active.
+   *
+   * @param name - Name of the playing animation.
+   * @param weight - New weight value used during blending.
    */ setAnimationWeight(name, weight) {
         const ani = this._animations[name];
         if (!ani) {
@@ -5828,16 +5828,16 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
             info.weight = weight;
         }
     }
-    /**
-   * Start (or update) playback of an animation clip.
-   *
-   * Behavior:
-   * - If the clip is already playing, updates its fade-in (resets fade-out).
-   * - Otherwise initializes playback state (repeat counter, speed, weight, initial time).
-   * - Registers clip tracks and skeletons into the active sets for blending and application.
-   *
-   * @param name - Name of the animation to play.
-   * @param options - Playback options (repeat, speedRatio, fadeIn).
+    /**
+   * Start (or update) playback of an animation clip.
+   *
+   * Behavior:
+   * - If the clip is already playing, updates its fade-in (resets fade-out).
+   * - Otherwise initializes playback state (repeat counter, speed, weight, initial time).
+   * - Registers clip tracks and skeletons into the active sets for blending and application.
+   *
+   * @param name - Name of the animation to play.
+   * @param options - Playback options (repeat, speedRatio, fadeIn).
    */ playAnimation(name, options) {
         const ani = this._animations[name];
         if (!ani) {
@@ -5895,18 +5895,18 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
             });
         }
     }
-    /**
-   * Stop playback of an animation clip.
-   *
-   * Behavior:
-   * - If `options.fadeOut > 0`, marks the clip for fade-out; actual removal occurs after fade completes.
-   * - If `fadeOut` is 0 or omitted, immediately:
-   *   - Removes the clip from active animations.
-   *   - Unregisters its tracks from active track maps.
-   *   - Decrements skeleton reference counts; resets and removes skeletons when refcount reaches 0.
-   *
-   * @param name - Name of the animation to stop.
-   * @param options - Optional fade-out configuration.
+    /**
+   * Stop playback of an animation clip.
+   *
+   * Behavior:
+   * - If `options.fadeOut > 0`, marks the clip for fade-out; actual removal occurs after fade completes.
+   * - If `fadeOut` is 0 or omitted, immediately:
+   *   - Removes the clip from active animations.
+   *   - Unregisters its tracks from active track maps.
+   *   - Decrements skeleton reference counts; resets and removes skeletons when refcount reaches 0.
+   *
+   * @param name - Name of the animation to stop.
+   * @param options - Optional fade-out configuration.
    */ stopAnimation(name, options) {
         const ani = this._animations[name];
         if (!ani) {
@@ -5941,18 +5941,18 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
             }
         }
     }
-    /**
-   * Copy a humanoid animation clip from another AnimationSet into this one via humanoid rig mapping.
-   *
-   * Prerequisites:
-   * - Both source and destination skeletons must have a non-null `humanoidJointMapping`.
-   * - Joints are matched by shared `HumanoidBodyRig` / `HumanoidHandRig` keys instead of joint names.
-   * - The source clip must exist in `sourceSet` and must be driven by exactly one skeleton.
-   *
-   * @param sourceSet - The AnimationSet to copy from.
-   * @param animationName - Name of the clip to copy.
-   * @param targetName - Name for the new clip in this set. Defaults to `animationName`.
-   * @returns The newly created AnimationClip, or null on failure.
+    /**
+   * Copy a humanoid animation clip from another AnimationSet into this one via humanoid rig mapping.
+   *
+   * Prerequisites:
+   * - Both source and destination skeletons must have a non-null `humanoidJointMapping`.
+   * - Joints are matched by shared `HumanoidBodyRig` / `HumanoidHandRig` keys instead of joint names.
+   * - The source clip must exist in `sourceSet` and must be driven by exactly one skeleton.
+   *
+   * @param sourceSet - The AnimationSet to copy from.
+   * @param animationName - Name of the clip to copy.
+   * @param targetName - Name for the new clip in this set. Defaults to `animationName`.
+   * @returns The newly created AnimationClip, or null on failure.
    */ copyHumanoidAnimationFrom(sourceSet, animationName, targetName) {
         const destName = targetName ?? animationName;
         const sourceClip = sourceSet.get(animationName);
@@ -6120,21 +6120,21 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
         }
         return dstClip;
     }
-    /**
-   * Copy an animation clip from another AnimationSet into this one.
-   *
-   * Prerequisites:
-   * - Both sets must reference skeletons with identical joint names and counts.
-   * - The source clip must exist in `sourceSet`.
-   *
-   * @param sourceSet - The AnimationSet to copy from.
-   * @param animationName - Name of the clip to copy.
-   * @param targetName - Name for the new clip in this set. Defaults to `animationName`.
-   * @param excludeJoint - Optional predicate; joints whose name returns true are excluded from
-   *   skeleton structure matching.
-   * @returns The newly created AnimationClip, or null on failure.
-   *
-   * @deprecated Use the new {@link AnimationSet.copyHumanoidAnimationFrom} method instead.
+    /**
+   * Copy an animation clip from another AnimationSet into this one.
+   *
+   * Prerequisites:
+   * - Both sets must reference skeletons with identical joint names and counts.
+   * - The source clip must exist in `sourceSet`.
+   *
+   * @param sourceSet - The AnimationSet to copy from.
+   * @param animationName - Name of the clip to copy.
+   * @param targetName - Name for the new clip in this set. Defaults to `animationName`.
+   * @param excludeJoint - Optional predicate; joints whose name returns true are excluded from
+   *   skeleton structure matching.
+   * @returns The newly created AnimationClip, or null on failure.
+   *
+   * @deprecated Use the new {@link AnimationSet.copyHumanoidAnimationFrom} method instead.
    */ copyAnimationFrom(sourceSet, animationName, targetName, excludeJoint) {
         const destName = targetName ?? animationName;
         const sourceClip = sourceSet.get(animationName);
@@ -6284,12 +6284,12 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
             return ordered;
         }
     }
-    /**
-   * Dispose the animation set and release owned resources.
-   *
-   * - Disposes the weak reference to the model.
-   * - Disposes all registered animation clips.
-   * - Clears active animations, tracks, and skeleton references.
+    /**
+   * Dispose the animation set and release owned resources.
+   *
+   * - Disposes the weak reference to the model.
+   * - Disposes all registered animation clips.
+   * - Clears active animations, tracks, and skeleton references.
    */ onDispose() {
         super.onDispose();
         for(const k in this._animations){
@@ -10670,99 +10670,99 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
     }
 }
 
-/**
- * Base class for all materials.
- *
- * Responsibilities:
- * - Defines a multi-pass rendering interface (`numPasses`, `apply`, `bind`, `draw`, `drawPrimitive`).
- * - Builds and caches GPU shader programs per pass and per-render-context hash.
- * - Manages a per-material bind group (typically at index 2) for uniforms and resources.
- * - Updates render states per pass (`updateRenderStates`) and uploads uniforms (`_applyUniforms`).
- * - Tracks "option" changes that affect shader variant hashing and render bundles.
- *
- * Caching and hashing:
- * - `createHash(pass)` produces a stable hash representing shader variant options for a pass.
- *   Override `_createHash()` in subclasses to encode feature toggles (defines, keywords, macros).
- * - The global hash used to key `MaterialState` also includes `ctx.materialFlags` and
- *   `ctx.renderPassHash`, allowing context-sensitive variants (e.g., MSAA, MRT layout).
- * - GPU programs are additionally memoized in a global static `_programCache` across materials
- *   by `constructor.name` + hash, to avoid recompilation of identical variants.
- *
- * Bind groups and uniforms:
- * - If a program declares a bind group layout at index 2 (i.e., `bindGroupLayouts.length > 2`),
- *   `apply()` will allocate the group and keep it in the state. Subclasses should fill it in
- *   `_applyUniforms()`.
- * - `applyUniforms()` only calls `_applyUniforms()` when `needUpdate` is true, based on
- *   `_optionTag` changes (see `optionChanged()`).
- *
- * Lifecycle:
- * - Constructed materials register a persistent ID into a global registry for serialization.
- * - `apply(ctx)` prepares all passes: creates/gets state, programs, bind groups, render states,
- *   and uploads uniforms as needed.
- * - `bind(device, pass)` binds the program, bind group (index 2), and render states.
- * - `draw(primitive, ctx, numInstances)` runs all passes, calling `bind()` and `drawPrimitive()`.
- * - `onDispose()` releases bind groups and registry entries.
- *
- * Extending:
- * - Override `_createProgram(pb, ctx, pass)` to build a shader.
- * - Override `_applyUniforms(bindGroup, ctx, pass)` to upload uniforms and resources.
- * - Override `updateRenderStates(pass, renderStates, ctx)` to set depth, blend, cull, etc.
- * - Override `_createHash()` to encode options that affect program compilation.
- * - Override `supportLighting`, `supportInstancing`, `isTransparentPass`, `getQueueType`, etc.
- *
- * Thread-safety:
- * - Intended for main-thread use in a renderer driving WebGPU/WebGL-like devices.
- *
- * @public
+/**
+ * Base class for all materials.
+ *
+ * Responsibilities:
+ * - Defines a multi-pass rendering interface (`numPasses`, `apply`, `bind`, `draw`, `drawPrimitive`).
+ * - Builds and caches GPU shader programs per pass and per-render-context hash.
+ * - Manages a per-material bind group (typically at index 2) for uniforms and resources.
+ * - Updates render states per pass (`updateRenderStates`) and uploads uniforms (`_applyUniforms`).
+ * - Tracks "option" changes that affect shader variant hashing and render bundles.
+ *
+ * Caching and hashing:
+ * - `createHash(pass)` produces a stable hash representing shader variant options for a pass.
+ *   Override `_createHash()` in subclasses to encode feature toggles (defines, keywords, macros).
+ * - The global hash used to key `MaterialState` also includes `ctx.materialFlags` and
+ *   `ctx.renderPassHash`, allowing context-sensitive variants (e.g., MSAA, MRT layout).
+ * - GPU programs are additionally memoized in a global static `_programCache` across materials
+ *   by `constructor.name` + hash, to avoid recompilation of identical variants.
+ *
+ * Bind groups and uniforms:
+ * - If a program declares a bind group layout at index 2 (i.e., `bindGroupLayouts.length > 2`),
+ *   `apply()` will allocate the group and keep it in the state. Subclasses should fill it in
+ *   `_applyUniforms()`.
+ * - `applyUniforms()` only calls `_applyUniforms()` when `needUpdate` is true, based on
+ *   `_optionTag` changes (see `optionChanged()`).
+ *
+ * Lifecycle:
+ * - Constructed materials register a persistent ID into a global registry for serialization.
+ * - `apply(ctx)` prepares all passes: creates/gets state, programs, bind groups, render states,
+ *   and uploads uniforms as needed.
+ * - `bind(device, pass)` binds the program, bind group (index 2), and render states.
+ * - `draw(primitive, ctx, numInstances)` runs all passes, calling `bind()` and `drawPrimitive()`.
+ * - `onDispose()` releases bind groups and registry entries.
+ *
+ * Extending:
+ * - Override `_createProgram(pb, ctx, pass)` to build a shader.
+ * - Override `_applyUniforms(bindGroup, ctx, pass)` to upload uniforms and resources.
+ * - Override `updateRenderStates(pass, renderStates, ctx)` to set depth, blend, cull, etc.
+ * - Override `_createHash()` to encode options that affect program compilation.
+ * - Override `supportLighting`, `supportInstancing`, `isTransparentPass`, `getQueueType`, etc.
+ *
+ * Thread-safety:
+ * - Intended for main-thread use in a renderer driving WebGPU/WebGL-like devices.
+ *
+ * @public
  */ class Material extends Disposable {
-    /**
-   * Monotonic instance ID counter.
-   * @internal
+    /**
+   * Monotonic instance ID counter.
+   * @internal
    */ static _nextId = 0;
-    /**
-   * Global program cache keyed by global hash
+    /**
+   * Global program cache keyed by global hash
    */ static _programCache = {};
-    /**
-   * Per-material state cache keyed by global hash (material + context + pass).
-   * @internal
+    /**
+   * Per-material state cache keyed by global hash (material + context + pass).
+   * @internal
    */ _states;
-    /**
-   * Number of rendering passes.
-   * Subclasses can increase this to implement multi-pass rendering.
-   * @internal
+    /**
+   * Number of rendering passes.
+   * Subclasses can increase this to implement multi-pass rendering.
+   * @internal
    */ _numPasses;
-    /**
-   * Per-pass hash cached results. Length scales with `numPasses`.
-   * @internal
+    /**
+   * Per-pass hash cached results. Length scales with `numPasses`.
+   * @internal
    */ _hash;
-    /**
-   * Incremented each time options change (via `optionChanged`), used to decide whether
-   * uniforms need update on next `apply()`.
-   * @internal
+    /**
+   * Incremented each time options change (via `optionChanged`), used to decide whether
+   * uniforms need update on next `apply()`.
+   * @internal
    */ _optionTag;
-    /**
-   * Unique runtime instance ID.
-   * @internal
+    /**
+   * Unique runtime instance ID.
+   * @internal
    */ _id;
-    /**
-   * Latest computed global hash per pass, set during `apply()`, read in `bind()`.
-   * @internal
+    /**
+   * Latest computed global hash per pass, set during `apply()`, read in `bind()`.
+   * @internal
    */ _currentHash;
-    /**
-   * Incremented when material states affecting render bundles change (e.g., bind group id changes
-   * or `optionChanged(true)`), used to trigger re-recording of render bundles.
-   * @internal
+    /**
+   * Incremented when material states affecting render bundles change (e.g., bind group id changes
+   * or `optionChanged(true)`), used to trigger re-recording of render bundles.
+   * @internal
    */ _changeTag;
-    /**
-   * Unique program id counter for naming compiled programs.
-   * @internal
+    /**
+   * Unique program id counter for naming compiled programs.
+   * @internal
    */ _nextProgramId = 0;
-    /**
-   * Create a new material instance.
-   *
-   * - Initializes one pass by default.
-   * - Prepares per-pass hash storage and change tracking.
-   * - Registers a persistent ID in the global registry.
+    /**
+   * Create a new material instance.
+   *
+   * - Initializes one pass by default.
+   * - Prepares per-pass hash storage and change tracking.
+   * - Registers a persistent ID in the global registry.
    */ constructor(){
         super();
         this._id = ++Material._nextId;
@@ -10776,46 +10776,46 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
         this._changeTag = 0;
         this._currentHash = [];
     }
-    /**
-   * Create a shallow clone of this material.
-   *
-   * Note: The base implementation returns a base `Material`. Subclasses should
-   * override to return their own type and copy custom fields.
+    /**
+   * Create a shallow clone of this material.
+   *
+   * Note: The base implementation returns a base `Material`. Subclasses should
+   * override to return their own type and copy custom fields.
    */ clone() {
         const other = new Material();
         other.copyFrom(this);
         return other;
     }
-    /**
-   * Copy basic properties from another material.
-   *
-   * Disposes existing bind groups/states, copies `numPasses`. Subclasses should
-   * extend this to copy their own fields and call `optionChanged(true)` if
-   * shader-affecting options differ.
-   *
-   * @param other - Source material.
+    /**
+   * Copy basic properties from another material.
+   *
+   * Disposes existing bind groups/states, copies `numPasses`. Subclasses should
+   * extend this to copy their own fields and call `optionChanged(true)` if
+   * shader-affecting options differ.
+   *
+   * @param other - Source material.
    */ copyFrom(other) {
         this.clearCache();
         this._numPasses = other._numPasses;
         getEngine().resourceManager.setAssetId(this, getEngine().resourceManager.getAssetId(other.coreMaterial));
     }
-    /**
-   * Incremented when the material’s GPU-relevant state changes and render bundles
-   * may need to be rebuilt.
+    /**
+   * Incremented when the material’s GPU-relevant state changes and render bundles
+   * may need to be rebuilt.
    */ get changeTag() {
         return this._changeTag;
     }
-    /**
-   * Runtime-unique numeric identifier for the material instance.
+    /**
+   * Runtime-unique numeric identifier for the material instance.
    */ get instanceId() {
         return this._id;
     }
-    /**
-   * Number of rendering passes this material uses.
-   *
-   * Increasing this will expand the per-pass hash cache; make sure to implement
-   * `createHash(pass)`, `_createProgram(pb, ctx, pass)`, and `updateRenderStates(pass, ...)`
-   * accordingly for each pass.
+    /**
+   * Number of rendering passes this material uses.
+   *
+   * Increasing this will expand the per-pass hash cache; make sure to implement
+   * `createHash(pass)`, `_createProgram(pb, ctx, pass)`, and `updateRenderStates(pass, ...)`
+   * accordingly for each pass.
    */ get numPasses() {
         return this._numPasses;
     }
@@ -10825,86 +10825,86 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
         }
         this._numPasses = val;
     }
-    /**
-   * Get or compute the per-pass shader hash used for program caching.
-   *
-   * Calls `createHash(pass)` lazily and caches the result.
-   * @internal
+    /**
+   * Get or compute the per-pass shader hash used for program caching.
+   *
+   * Calls `createHash(pass)` lazily and caches the result.
+   * @internal
    */ getHash(pass) {
         if (this._hash[pass] === null) {
             this._hash[pass] = this.createHash(pass);
         }
         return this._hash[pass];
     }
-    /**
-   * Return the queue type to which this material belongs.
-   *
-   * Override this in transparent or special materials (e.g., post-process).
+    /**
+   * Return the queue type to which this material belongs.
+   *
+   * Override this in transparent or special materials (e.g., post-process).
    */ getQueueType() {
         return QUEUE_OPAQUE;
     }
-    /**
-   * Whether the given pass is transparent.
-   *
-   * Used to place draw calls into appropriate render queues and set blending states.
+    /**
+   * Whether the given pass is transparent.
+   *
+   * Used to place draw calls into appropriate render queues and set blending states.
    */ isTransparentPass(_pass) {
         return false;
     }
-    /**
-   * Whether this material's shading is affected by scene lights.
-   *
-   * Override and return `false` for unlit materials.
+    /**
+   * Whether this material's shading is affected by scene lights.
+   *
+   * Override and return `false` for unlit materials.
    */ supportLighting() {
         return true;
     }
-    /**
-   * Whether this material supports hardware instancing.
-   *
-   * Override and return `false` if per-instance data is not supported in the shader.
+    /**
+   * Whether this material supports hardware instancing.
+   *
+   * Override and return `false` if per-instance data is not supported in the shader.
    */ supportInstancing() {
         return true;
     }
     /** Returns true if this is a instance of material */ isBatchable() {
         return false;
     }
-    /**
-   * Whether this material requires the scene color texture (e.g., for refraction).
+    /**
+   * Whether this material requires the scene color texture (e.g., for refraction).
    */ needSceneColor() {
         return false;
     }
-    /**
-   * Whether this material requires the linear scene depth texture (e.g., for depth-aware effects).
+    /**
+   * Whether this material requires the linear scene depth texture (e.g., for depth-aware effects).
    */ needSceneDepth() {
         return false;
     }
-    /**
-   * Create a material instance (instance-uniform-driven variant).
-   *
-   * Base returns `null`. Subclasses that support instancing can return a lightweight instance.
+    /**
+   * Create a material instance (instance-uniform-driven variant).
+   *
+   * Base returns `null`. Subclasses that support instancing can return a lightweight instance.
    */ createInstance() {
         throw new Error('Abstract function call');
     }
-    /**
-   * Returns the core material that owns GPU state.
-   *
-   * Instances may delegate to a shared core to reuse compiled programs and caches.
-   * @public
+    /**
+   * Returns the core material that owns GPU state.
+   *
+   * Instances may delegate to a shared core to reuse compiled programs and caches.
+   * @public
    */ get coreMaterial() {
         return this;
     }
-    /**
-   * Prepare the material for drawing across all passes for the given draw context.
-   *
-   * Steps per pass:
-   * - Compute global hash (material variant + context).
-   * - Retrieve or build the GPU program, cache in `_programCache`.
-   * - Create per-material bind group (index 2) if the program exposes it.
-   * - Update uniforms if `_optionTag` indicates changes since last apply.
-   * - Update and cache render states for the pass.
-   * - Detect bind group GPU ID changes to bump `changeTag` and notify `RenderBundleWrapper`.
-   *
-   * @param ctx - Draw context (device, flags, pass hash, instance data, etc.).
-   * @returns `true` if successful; `false` if any pass lacks a valid program.
+    /**
+   * Prepare the material for drawing across all passes for the given draw context.
+   *
+   * Steps per pass:
+   * - Compute global hash (material variant + context).
+   * - Retrieve or build the GPU program, cache in `_programCache`.
+   * - Create per-material bind group (index 2) if the program exposes it.
+   * - Update uniforms if `_optionTag` indicates changes since last apply.
+   * - Update and cache render states for the pass.
+   * - Detect bind group GPU ID changes to bump `changeTag` and notify `RenderBundleWrapper`.
+   *
+   * @param ctx - Draw context (device, flags, pass hash, instance data, etc.).
+   * @returns `true` if successful; `false` if any pass lacks a valid program.
    */ apply(ctx) {
         for(let pass = 0; pass < this._numPasses; pass++){
             const hash = this.calcGlobalHash(ctx, pass);
@@ -10946,15 +10946,15 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
         }
         return true;
     }
-    /**
-   * Bind the program, bind group, and render states for the specified pass.
-   *
-   * Must be called after `apply(ctx)` for the same pass.
-   *
-   * @param device - Rendering device.
-   * @param pass - Pass index to bind.
-   * @returns `true` on success; `false` if state or program missing.
-   * @internal
+    /**
+   * Bind the program, bind group, and render states for the specified pass.
+   *
+   * Must be called after `apply(ctx)` for the same pass.
+   *
+   * @param device - Rendering device.
+   * @param pass - Pass index to bind.
+   * @returns `true` on success; `false` if state or program missing.
+   * @internal
    */ bind(device, pass) {
         const hash = this._currentHash[pass];
         const state = this._states[hash];
@@ -10972,56 +10972,56 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
         device.setRenderStates(state.renderStateSet);
         return true;
     }
-    /**
-   * Compute the global hash for the given pass and draw context.
-   *
-   * Includes:
-   * - Per-pass material hash from `getHash(pass)`.
-   * - `ctx.materialFlags` for context-dependent toggles.
-   * - `ctx.renderPassHash` for framebuffer/attachment layout variants.
-   * @internal
+    /**
+   * Compute the global hash for the given pass and draw context.
+   *
+   * Includes:
+   * - Per-pass material hash from `getHash(pass)`.
+   * - `ctx.materialFlags` for context-dependent toggles.
+   * - `ctx.renderPassHash` for framebuffer/attachment layout variants.
+   * @internal
    */ calcGlobalHash(ctx, pass) {
         return `${this.getHash(pass)}:${ctx.materialFlags}:${ctx.renderPassHash}`;
     }
-    /**
-   * Draw a primitive for all passes using this material.
-   *
-   * Calls `bind()` then `drawPrimitive()` per pass. If `numInstances` is zero,
-   * and `ctx.instanceData` exists, uses `ctx.instanceData.numInstances`.
-   *
-   * @param primitive - Geometry to draw.
-   * @param ctx - Draw context.
-   * @param numInstances - Instance count; 0 means auto-detect from context.
-   * @internal
+    /**
+   * Draw a primitive for all passes using this material.
+   *
+   * Calls `bind()` then `drawPrimitive()` per pass. If `numInstances` is zero,
+   * and `ctx.instanceData` exists, uses `ctx.instanceData.numInstances`.
+   *
+   * @param primitive - Geometry to draw.
+   * @param ctx - Draw context.
+   * @param numInstances - Instance count; 0 means auto-detect from context.
+   * @internal
    */ draw(primitive, ctx, numInstances = 0) {
         for(let pass = 0; pass < this._numPasses; pass++){
             this.bind(ctx.device, pass);
             this.drawPrimitive(pass, primitive, ctx, numInstances);
         }
     }
-    /**
-   * Conditionally update uniforms/resources into the material bind group.
-   *
-   * Delegates to `_applyUniforms()` when `needUpdate` is true (based on `_optionTag` check).
-   *
-   * @param bindGroup - Material bind group at index 2 (may be `null` if program has no layout).
-   * @param ctx - Draw context.
-   * @param needUpdate - Whether uniforms need to be refreshed.
-   * @param pass - Pass index.
+    /**
+   * Conditionally update uniforms/resources into the material bind group.
+   *
+   * Delegates to `_applyUniforms()` when `needUpdate` is true (based on `_optionTag` check).
+   *
+   * @param bindGroup - Material bind group at index 2 (may be `null` if program has no layout).
+   * @param ctx - Draw context.
+   * @param needUpdate - Whether uniforms need to be refreshed.
+   * @param pass - Pass index.
    */ applyUniforms(bindGroup, ctx, needUpdate, pass) {
         if (needUpdate) {
             this._applyUniforms(bindGroup, ctx, pass);
         }
     }
-    /**
-   * Notify the material that some option changed.
-   *
-   * - Always increments `_optionTag`. This will trigger uniforms update on next `apply()`.
-   * - If `changeHash` is true, clears per-pass hashes so programs/states will be rebuilt,
-   *   increments `_changeTag`, and notifies `RenderBundleWrapper` to regenerate recorded bundles.
-   *
-   * @param changeHash - Set true if the change affects shader compilation or render states.
-   * @internal
+    /**
+   * Notify the material that some option changed.
+   *
+   * - Always increments `_optionTag`. This will trigger uniforms update on next `apply()`.
+   * - If `changeHash` is true, clears per-pass hashes so programs/states will be rebuilt,
+   *   increments `_changeTag`, and notifies `RenderBundleWrapper` to regenerate recorded bundles.
+   *
+   * @param changeHash - Set true if the change affects shader compilation or render states.
+   * @internal
    */ optionChanged(changeHash) {
         this._optionTag++;
         if (changeHash) {
@@ -11040,39 +11040,39 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
         }
         this._states = {};
     }
-    /**
-   * Convert a pass index to a hash seed string.
-   *
-   * Subclasses may override to encode per-pass role (e.g., "depth", "forward", "shadow").
-   *
-   * @param pass - Pass number.
-   * @returns String used when building full hash.
+    /**
+   * Convert a pass index to a hash seed string.
+   *
+   * Subclasses may override to encode per-pass role (e.g., "depth", "forward", "shadow").
+   *
+   * @param pass - Pass number.
+   * @returns String used when building full hash.
    */ passToHash(pass) {
         return String(pass);
     }
-    /**
-   * Build the material hash for a pass (excluding context-dependent parts).
-   *
-   * Default formula: `${constructor.name}|${pass}|${_createHash()}`
-   *
-   * @param pass - Pass number.
-   * @returns Hash string used in program caching.
-   * @internal
+    /**
+   * Build the material hash for a pass (excluding context-dependent parts).
+   *
+   * Default formula: `${constructor.name}|${pass}|${_createHash()}`
+   *
+   * @param pass - Pass number.
+   * @returns Hash string used in program caching.
+   * @internal
    */ createHash(pass) {
         return `${this.constructor.name}|${pass}|${this._createHash()}`;
     }
-    /**
-   * Issue the actual draw call for a pass.
-   *
-   * Override for custom per-pass draw behavior if necessary. The default implementation:
-   * - Draws instanced if `numInstances > 0`.
-   * - Else uses `ctx.instanceData.numInstances` if available.
-   * - Else issues a non-instanced draw.
-   *
-   * @param pass - Pass number.
-   * @param primitive - Primitive to draw.
-   * @param ctx - Draw context.
-   * @param numInstances - Explicit instance count (0 = auto).
+    /**
+   * Issue the actual draw call for a pass.
+   *
+   * Override for custom per-pass draw behavior if necessary. The default implementation:
+   * - Draws instanced if `numInstances > 0`.
+   * - Else uses `ctx.instanceData.numInstances` if available.
+   * - Else issues a non-instanced draw.
+   *
+   * @param pass - Pass number.
+   * @param primitive - Primitive to draw.
+   * @param ctx - Draw context.
+   * @param numInstances - Explicit instance count (0 = auto).
    */ drawPrimitive(pass, primitive, ctx, numInstances) {
         if (numInstances > 0) {
             primitive.drawInstanced(numInstances);
@@ -11082,88 +11082,88 @@ const UNIFORM_NAME_MORPH_INFO = 'Z_UniformMorphInfo';
             primitive.draw();
         }
     }
-    /**
-   * Dispose the material and release GPU-side resource references.
-   *
-   * - Unregisters from the global registry.
-   * - Disposes the per-material bind groups kept in `_states`.
+    /**
+   * Dispose the material and release GPU-side resource references.
+   *
+   * - Unregisters from the global registry.
+   * - Disposes the per-material bind groups kept in `_states`.
    */ onDispose() {
         super.onDispose();
         this.clearCache();
     }
-    /**
-   * Build the GPU program for a pass.
-   *
-   * Default creates a `ProgramBuilder` and calls `_createProgram(pb, ctx, pass)`.
-   * Subclasses should override `_createProgram` instead of this method unless
-   * they need to replace builder instantiation.
-   *
-   * @param ctx - Draw context.
-   * @param pass - Pass number.
-   * @returns The compiled `GPUProgram`, or `null` on failure.
-   * @internal
+    /**
+   * Build the GPU program for a pass.
+   *
+   * Default creates a `ProgramBuilder` and calls `_createProgram(pb, ctx, pass)`.
+   * Subclasses should override `_createProgram` instead of this method unless
+   * they need to replace builder instantiation.
+   *
+   * @param ctx - Draw context.
+   * @param pass - Pass number.
+   * @returns The compiled `GPUProgram`, or `null` on failure.
+   * @internal
    */ createProgram(ctx, pass) {
         const pb = new ProgramBuilder(ctx.device);
         return this._createProgram(pb, ctx, pass);
     }
-    /**
-   * Create and compile the shader program for this material/pass.
-   *
-   * Implement in subclasses:
-   * - Define shader stages, entry points, macros/defines, and resource layouts.
-   * - Return a compiled `GPUProgram`.
-   *
-   * @param pb - Program builder.
-   * @param ctx - Draw context.
-   * @param _pass - Pass number.
-   * @returns The created program, or `null` on failure.
+    /**
+   * Create and compile the shader program for this material/pass.
+   *
+   * Implement in subclasses:
+   * - Define shader stages, entry points, macros/defines, and resource layouts.
+   * - Return a compiled `GPUProgram`.
+   *
+   * @param pb - Program builder.
+   * @param ctx - Draw context.
+   * @param _pass - Pass number.
+   * @returns The created program, or `null` on failure.
    */ _createProgram(_pb, _ctx, _pass) {
         throw new Error('Abstract function call');
     }
-    /**
-   * Upload uniforms and bind resources to the per-material bind group (index 2).
-   *
-   * Implement in subclasses to:
-   * - Write uniform buffers/textures/samplers to the `bindGroup`.
-   * - Respect the current `pass` and `ctx`.
-   *
-   * @param _bindGroup - The bind group to populate.
-   * @param _ctx - Draw context.
-   * @param _pass - Pass number.
+    /**
+   * Upload uniforms and bind resources to the per-material bind group (index 2).
+   *
+   * Implement in subclasses to:
+   * - Write uniform buffers/textures/samplers to the `bindGroup`.
+   * - Respect the current `pass` and `ctx`.
+   *
+   * @param _bindGroup - The bind group to populate.
+   * @param _ctx - Draw context.
+   * @param _pass - Pass number.
    */ _applyUniforms(_bindGroup, _ctx, _pass) {}
-    /**
-   * Update render states (depth/stencil, blending, rasterization) for the pass.
-   *
-   * Implement in subclasses based on transparency, double-sidedness, depth writes/tests,
-   * color mask, stencil ops, etc., and any context flags in `ctx`.
-   *
-   * @param _pass - Current pass index.
-   * @param _renderStates - Render state set to mutate.
-   * @param _ctx - Draw context.
+    /**
+   * Update render states (depth/stencil, blending, rasterization) for the pass.
+   *
+   * Implement in subclasses based on transparency, double-sidedness, depth writes/tests,
+   * color mask, stencil ops, etc., and any context flags in `ctx`.
+   *
+   * @param _pass - Current pass index.
+   * @param _renderStates - Render state set to mutate.
+   * @param _ctx - Draw context.
    */ updateRenderStates(_pass, _renderStates, _ctx) {}
-    /**
-   * Compute the material-specific portion of the shader hash for the current options.
-   *
-   * Subclasses should override to include macro/define sets that influence program compilation.
-   * Example return: `"USE_NORMALMAP=1;ALPHA_MODE=BLEND;RECEIVE_SHADOWS=1"`.
-   *
-   * @returns Hash fragment string (no context/pass info).
+    /**
+   * Compute the material-specific portion of the shader hash for the current options.
+   *
+   * Subclasses should override to include macro/define sets that influence program compilation.
+   * Example return: `"USE_NORMALMAP=1;ALPHA_MODE=BLEND;RECEIVE_SHADOWS=1"`.
+   *
+   * @returns Hash fragment string (no context/pass info).
    */ _createHash() {
         return '';
     }
-    /**
-   * Whether this is a lightweight instance of a core material.
-   *
-   * Instances typically share GPU programs with a core and only override instance uniforms.
-   * @internal
+    /**
+   * Whether this is a lightweight instance of a core material.
+   *
+   * Instances typically share GPU programs with a core and only override instance uniforms.
+   * @internal
    */ get $isInstance() {
         return false;
     }
-    /**
-   * Instance-uniform buffer for material instances, if supported.
-   *
-   * Returned as a typed Float32 view over a backing ArrayBuffer.
-   * @internal
+    /**
+   * Instance-uniform buffer for material instances, if supported.
+   *
+   * Returned as a typed Float32 view over a backing ArrayBuffer.
+   * @internal
    */ get $instanceUniforms() {
         throw new Error('Abstract function call');
     }
@@ -16623,10 +16623,10 @@ const PBR_REFLECTION_MODE$1 = {
     };
 }
 
-/**
- * Returns the property accessor list unchanged while preserving typing.
- *
- * @public
+/**
+ * Returns the property accessor list unchanged while preserving typing.
+ *
+ * @public
  */ function defineProps(accessors) {
     return accessors;
 }
@@ -25422,26 +25422,26 @@ let paramId = 1;
     }
 }
 
-/**
- * Abstract base class for intermediate representation expressions
- *
- * @remarks
- * Represents a node in the IR tree that can be compiled to shader code.
- * Uses reference counting to determine if intermediate variables are needed.
- * Each expression can be referenced multiple times in the final shader code.
- *
- * The IR expression tree is built during compilation and then translated
- * to actual shader code via the `create()` method.
- *
- * @public
+/**
+ * Abstract base class for intermediate representation expressions
+ *
+ * @remarks
+ * Represents a node in the IR tree that can be compiled to shader code.
+ * Uses reference counting to determine if intermediate variables are needed.
+ * Each expression can be referenced multiple times in the final shader code.
+ *
+ * The IR expression tree is built during compilation and then translated
+ * to actual shader code via the `create()` method.
+ *
+ * @public
  */ class IRExpression {
     /** Reference count for this expression (number of times it's used) */ _ref;
     /** Cached output expressions for each output slot */ _outputs;
-    /**
-   * Creates a new IR expression
-   *
-   * @remarks
-   * Initializes reference count to 0 and empty outputs array.
+    /**
+   * Creates a new IR expression
+   *
+   * @remarks
+   * Initializes reference count to 0 and empty outputs array.
    */ constructor(){
         this._ref = 0;
         this._outputs = [];
@@ -25449,26 +25449,26 @@ let paramId = 1;
     /** Gets the array of output expressions */ get outputs() {
         return this._outputs;
     }
-    /**
-   * Increments the reference count
-   *
-   * @returns This expression for method chaining
-   *
-   * @remarks
-   * Called when this expression is referenced by another expression.
-   * Reference count is used to determine if a temporary variable is needed.
+    /**
+   * Increments the reference count
+   *
+   * @returns This expression for method chaining
+   *
+   * @remarks
+   * Called when this expression is referenced by another expression.
+   * Reference count is used to determine if a temporary variable is needed.
    */ addRef() {
         this._ref++;
         return this;
     }
-    /**
-   * Generates a unique temporary variable name
-   *
-   * @param scope - The shader scope to check for name conflicts
-   * @returns A unique temporary variable name (e.g., 'tmp0', 'tmp1')
-   *
-   * @remarks
-   * Ensures the generated name doesn't conflict with existing variables in the scope.
+    /**
+   * Generates a unique temporary variable name
+   *
+   * @param scope - The shader scope to check for name conflicts
+   * @returns A unique temporary variable name (e.g., 'tmp0', 'tmp1')
+   *
+   * @remarks
+   * Ensures the generated name doesn't conflict with existing variables in the scope.
    */ getTmpName(scope) {
         let tmp = 0;
         for(;;){
@@ -25478,60 +25478,60 @@ let paramId = 1;
             }
         }
     }
-    /**
-   * Converts this expression to a uniform value if applicable
-   *
-   * @param _node - The graph node associated with this expression
-   * @returns The uniform value descriptor, or null if not a uniform
-   *
-   * @remarks
-   * Only constant expressions can be converted to uniforms.
-   * Returns null by default; overridden by constant expression types.
+    /**
+   * Converts this expression to a uniform value if applicable
+   *
+   * @param _node - The graph node associated with this expression
+   * @returns The uniform value descriptor, or null if not a uniform
+   *
+   * @remarks
+   * Only constant expressions can be converted to uniforms.
+   * Returns null by default; overridden by constant expression types.
    */ asUniformValue(_node) {
         return null;
     }
-    /**
-   * Converts this expression to a uniform texture if applicable
-   *
-   * @param _node - The graph node associated with this expression
-   * @returns The uniform texture descriptor, or null if not a texture uniform
-   *
-   * @remarks
-   * Only texture constant expressions can be converted to texture uniforms.
-   * Returns null by default; overridden by texture constant expression types.
+    /**
+   * Converts this expression to a uniform texture if applicable
+   *
+   * @param _node - The graph node associated with this expression
+   * @returns The uniform texture descriptor, or null if not a texture uniform
+   *
+   * @remarks
+   * Only texture constant expressions can be converted to texture uniforms.
+   * Returns null by default; overridden by texture constant expression types.
    */ asUniformTexture(_node) {
         return null;
     }
-    /**
-   * Reset state for creation
+    /**
+   * Reset state for creation
    */ reset() {}
 }
-/**
- * IR expression for a constant scalar (float) value
- *
- * @public
+/**
+ * IR expression for a constant scalar (float) value
+ *
+ * @public
  */ class IRConstantf extends IRExpression {
     /** The constant float value */ value;
     /** The uniform parameter name, or empty string for literals */ name;
-    /**
-   * Creates a constant float expression
-   *
-   * @param value - The float value
-   * @param paramName - The uniform parameter name, or empty string for literals
+    /**
+   * Creates a constant float expression
+   *
+   * @param value - The float value
+   * @param paramName - The uniform parameter name, or empty string for literals
    */ constructor(value, paramName){
         super();
         this.value = value;
         this.name = paramName;
     }
-    /**
-   * Generates shader code for this constant
-   *
-   * @param pb - The program builder
-   * @returns A uniform reference or literal number
-   *
-   * @remarks
-   * If a parameter name exists, creates a uniform in the global scope.
-   * Otherwise, returns the literal value.
+    /**
+   * Generates shader code for this constant
+   *
+   * @param pb - The program builder
+   * @returns A uniform reference or literal number
+   *
+   * @remarks
+   * If a parameter name exists, creates a uniform in the global scope.
+   * Otherwise, returns the literal value.
    */ create(pb) {
         if (this.name) {
             if (!pb.getGlobalScope()[this.name]) {
@@ -25541,11 +25541,11 @@ let paramId = 1;
         }
         return this.value;
     }
-    /**
-   * Converts to a uniform value descriptor
-   *
-   * @param node - The graph node
-   * @returns Uniform value descriptor if this is a uniform parameter, null otherwise
+    /**
+   * Converts to a uniform value descriptor
+   *
+   * @param node - The graph node
+   * @returns Uniform value descriptor if this is a uniform parameter, null otherwise
    */ asUniformValue() {
         return this.name ? {
             name: this.name,
@@ -25556,57 +25556,57 @@ let paramId = 1;
         } : null;
     }
 }
-/**
- * IR expression for a constant scalar (boolean) value
- *
- * @public
+/**
+ * IR expression for a constant scalar (boolean) value
+ *
+ * @public
  */ class IRConstantb extends IRExpression {
     /** The constant boolean value */ value;
-    /**
-   * Creates a constant boolean expression
-   *
-   * @param value - The boolean value
+    /**
+   * Creates a constant boolean expression
+   *
+   * @param value - The boolean value
    */ constructor(value){
         super();
         this.value = value;
     }
-    /**
-   * Generates shader code for this constant
-   *
-   * @returns The literal boolean value
-   *
+    /**
+   * Generates shader code for this constant
+   *
+   * @returns The literal boolean value
+   *
    */ create() {
         return this.value;
     }
 }
-/**
- * IR expression for a constant vector value
- *
- * @public
+/**
+ * IR expression for a constant vector value
+ *
+ * @public
  */ class IRConstantfv extends IRExpression {
     /** The constant vector value as an array of floats */ value;
     /** The uniform parameter name, or empty string for literals */ name;
     /** vector type */ type;
-    /**
-   * Creates a constant vector expression
-   *
-   * @param value - The vector value as an array (length 2-4)
-   * @param paramName - The uniform parameter name, or empty string for literals
+    /**
+   * Creates a constant vector expression
+   *
+   * @param value - The vector value as an array (length 2-4)
+   * @param paramName - The uniform parameter name, or empty string for literals
    */ constructor(value, paramName, type){
         super();
         this.value = value;
         this.name = paramName;
         this.type = type;
     }
-    /**
-   * Generates shader code for this constant vector
-   *
-   * @param pb - The program builder
-   * @returns A uniform reference or vector constructor expression
-   *
-   * @remarks
-   * If a parameter name exists, creates a uniform in the global scope.
-   * The vector size is determined by the array length (vec2/vec3/vec4).
+    /**
+   * Generates shader code for this constant vector
+   *
+   * @param pb - The program builder
+   * @returns A uniform reference or vector constructor expression
+   *
+   * @remarks
+   * If a parameter name exists, creates a uniform in the global scope.
+   * The vector size is determined by the array length (vec2/vec3/vec4).
    */ create(pb) {
         if (this.name) {
             if (!pb.getGlobalScope()[this.name]) {
@@ -25618,11 +25618,11 @@ let paramId = 1;
         return(// @ts-ignore
         Array.isArray(this.value) ? pb[`vec${this.value.length}`](...this.value) : this.value);
     }
-    /**
-   * Converts to a uniform value descriptor
-   *
-   * @param node - The graph node
-   * @returns Uniform value descriptor if this is a uniform parameter, null otherwise
+    /**
+   * Converts to a uniform value descriptor
+   *
+   * @param node - The graph node
+   * @returns Uniform value descriptor if this is a uniform parameter, null otherwise
    */ asUniformValue() {
         return this.name ? {
             name: this.name,
@@ -25631,97 +25631,97 @@ let paramId = 1;
         } : null;
     }
 }
-/**
- * IR expression for a constant boolean vector value
- *
- * @public
+/**
+ * IR expression for a constant boolean vector value
+ *
+ * @public
  */ class IRConstantbv extends IRExpression {
     /** The constant vector value as an array of booleans */ value;
-    /**
-   * Creates a constant boolean vector expression
-   *
-   * @param value - The vector value as an array (length 2-4)
+    /**
+   * Creates a constant boolean vector expression
+   *
+   * @param value - The vector value as an array (length 2-4)
    */ constructor(value){
         super();
         this.value = value;
     }
-    /**
-   * Generates shader code for this constant vector
-   *
-   * @param pb - The program builder
-   *
-   * @returns A boolean vector constructor expression
+    /**
+   * Generates shader code for this constant vector
+   *
+   * @param pb - The program builder
+   *
+   * @returns A boolean vector constructor expression
    */ create(pb) {
         // @ts-ignore
         return pb[`bvec${this.value.length}`](...this.value);
     }
 }
-/**
- * IR expression for shader input variables
- *
- * @remarks
- * Represents variables that are passed into the shader from the vertex stage
- * or defined in the current scope. Examples include vertex attributes,
- * varyings, and built-in variables.
- *
- * @example
- * ```typescript
- * // Reference to vertex color
- * const vertexColor = new IRInput('zVertexColor');
- *
- * // Reference via function
- * const worldPos = new IRInput((scope) => scope.zWorldPos);
- * ```
- *
- * @public
+/**
+ * IR expression for shader input variables
+ *
+ * @remarks
+ * Represents variables that are passed into the shader from the vertex stage
+ * or defined in the current scope. Examples include vertex attributes,
+ * varyings, and built-in variables.
+ *
+ * @example
+ * ```typescript
+ * // Reference to vertex color
+ * const vertexColor = new IRInput('zVertexColor');
+ *
+ * // Reference via function
+ * const worldPos = new IRInput((scope) => scope.zWorldPos);
+ * ```
+ *
+ * @public
  */ class IRInput extends IRExpression {
     /** The variable name or a function that retrieves the variable from scope */ func;
-    /**
-   * Creates an input variable expression
-   *
-   * @param func - Variable name string or function to retrieve the variable
+    /**
+   * Creates an input variable expression
+   *
+   * @param func - Variable name string or function to retrieve the variable
    */ constructor(func){
         super();
         this.func = func;
     }
-    /**
-   * Generates shader code for this input variable
-   *
-   * @param pb - The program builder
-   * @returns The shader expression referencing the input variable
+    /**
+   * Generates shader code for this input variable
+   *
+   * @param pb - The program builder
+   * @returns The shader expression referencing the input variable
    */ create(pb) {
         return typeof this.func === 'string' ? pb.getCurrentScope()[this.func] : this.func(pb.getCurrentScope());
     }
 }
-/**
- * IR expression for function calls and operations
- *
- * @remarks
- * Represents built-in shader functions (add, mul, sin, etc.) or vector constructors.
- * Uses reference counting to determine if result should be stored in a temporary variable.
- *
- * @example
- * ```typescript
- * // Addition: a + b
- * const add = new IRFunc([exprA, exprB], 'add');
- *
- * // Vector constructor: vec3(x, y, z)
- * const vec = new IRFunc([x, y, z], 'vec3');
- * ```
- *
- * @public
+/**
+ * IR expression for function calls and operations
+ *
+ * @remarks
+ * Represents built-in shader functions (add, mul, sin, etc.) or vector constructors.
+ * Uses reference counting to determine if result should be stored in a temporary variable.
+ *
+ * @example
+ * ```typescript
+ * // Addition: a + b
+ * const add = new IRFunc([exprA, exprB], 'add');
+ *
+ * // Vector constructor: vec3(x, y, z)
+ * const vec = new IRFunc([x, y, z], 'vec3');
+ * ```
+ *
+ * @public
  */ class IRFunc extends IRExpression {
     /** Array of parameters (can be expressions or literal numbers) */ params;
     /** The function name (e.g., 'add', 'mul', 'sin', 'vec3') */ func;
     /** Cached temporary variable name if expression is referenced multiple times */ tmpName;
-    /**
-   * Creates a function call expression
-   *
-   * @param params - Array of parameters for the function
-   * @param func - The function name or function implementation
-   *
-   * @remarks
-   * Increments reference count for all expression parameters.
+    /**
+   * Creates a function call expression
+   *
+   * @param params - Array of parameters for the function
+   * @param func - The function name or function implementation
+   *
+   * @remarks
+   * Increments reference count for all expression parameters.
    */ constructor(params, func){
         super();
         this.params = params.map((param)=>param instanceof IRExpression ? param.addRef() : param);
@@ -25731,15 +25731,15 @@ let paramId = 1;
     /** Reset for next creation */ reset() {
         this.tmpName = '';
     }
-    /**
-   * Generates shader code for this function call
-   *
-   * @param pb - The program builder
-   * @returns The shader expression for the function result
-   *
-   * @remarks
-   * If referenced multiple times (_ref > 1), stores result in a temporary variable.
-   * Otherwise, generates the function call inline.
+    /**
+   * Generates shader code for this function call
+   *
+   * @param pb - The program builder
+   * @returns The shader expression for the function result
+   *
+   * @remarks
+   * If referenced multiple times (_ref > 1), stores result in a temporary variable.
+   * Otherwise, generates the function call inline.
    */ create(pb) {
         if (this.tmpName) {
             const exp = pb.getCurrentScope()[this.tmpName];
@@ -25761,27 +25761,27 @@ let paramId = 1;
         }
     }
 }
-/**
- * IR expression for function output values
- *
- * @remarks
- * Represents the output of a material function (subgraph).
- * Handles caching of output values when referenced multiple times.
- *
- * @example
- * ```typescript
- * // Function returns a processed color value
- * const output = new IRFunctionOutput(colorExpression);
- * ```
- *
- * @public
+/**
+ * IR expression for function output values
+ *
+ * @remarks
+ * Represents the output of a material function (subgraph).
+ * Handles caching of output values when referenced multiple times.
+ *
+ * @example
+ * ```typescript
+ * // Function returns a processed color value
+ * const output = new IRFunctionOutput(colorExpression);
+ * ```
+ *
+ * @public
  */ class IRFunctionOutput extends IRExpression {
     /** Cached temporary variable name for the output */ tmpName;
     /** The input expression to output */ input;
-    /**
-   * Creates a function output expression
-   *
-   * @param input - The expression or value to output
+    /**
+   * Creates a function output expression
+   *
+   * @param input - The expression or value to output
    */ constructor(input){
         super();
         this.input = input;
@@ -25790,14 +25790,14 @@ let paramId = 1;
     /** Reset for next creation */ reset() {
         this.tmpName = '';
     }
-    /**
-   * Generates shader code for this function output
-   *
-   * @param pb - The program builder
-   * @returns The shader expression or value
-   *
-   * @remarks
-   * If referenced multiple times, stores result in a temporary variable.
+    /**
+   * Generates shader code for this function output
+   *
+   * @param pb - The program builder
+   * @returns The shader expression or value
+   *
+   * @remarks
+   * If referenced multiple times, stores result in a temporary variable.
    */ create(pb) {
         if (this.tmpName) {
             return pb.getCurrentScope()[this.tmpName];
@@ -25812,30 +25812,30 @@ let paramId = 1;
         }
     }
 }
-/**
- * IR expression for calling user-defined material functions
- *
- * @remarks
- * Represents a call to a material function (subgraph) with parameters.
- * Generates both the function definition and the call site.
- * Uses a struct return type to return multiple outputs from the function.
- *
- * @example
- * ```typescript
- * // Call to a custom "calculateLighting" function
- * const call = new IRCallFunc(functionNode, [normalExpr, lightDirExpr]);
- * ```
- *
- * @public
+/**
+ * IR expression for calling user-defined material functions
+ *
+ * @remarks
+ * Represents a call to a material function (subgraph) with parameters.
+ * Generates both the function definition and the call site.
+ * Uses a struct return type to return multiple outputs from the function.
+ *
+ * @example
+ * ```typescript
+ * // Call to a custom "calculateLighting" function
+ * const call = new IRCallFunc(functionNode, [normalExpr, lightDirExpr]);
+ * ```
+ *
+ * @public
  */ class IRCallFunc extends IRExpression {
     /** The function call node from the graph */ node;
     /** Array of argument expressions */ args;
     /** Cached temporary variable name if result is referenced multiple times */ tmpName;
-    /**
-   * Creates a function call expression
-   *
-   * @param node - The function call node
-   * @param args - Array of argument expressions
+    /**
+   * Creates a function call expression
+   *
+   * @param node - The function call node
+   * @param args - Array of argument expressions
    */ constructor(node, args){
         super();
         this.node = node;
@@ -25845,16 +25845,16 @@ let paramId = 1;
     /** Reset for next creation */ reset() {
         this.tmpName = '';
     }
-    /**
-   * Generates shader code for the function definition and call
-   *
-   * @param pb - The program builder
-   * @returns The shader expression for the function result
-   *
-   * @remarks
-   * First generates the function definition (if not already defined),
-   * then generates the function call with the provided arguments.
-   * The function returns a struct containing all output values.
+    /**
+   * Generates shader code for the function definition and call
+   *
+   * @param pb - The program builder
+   * @returns The shader expression for the function result
+   *
+   * @remarks
+   * First generates the function definition (if not already defined),
+   * then generates the function call with the provided arguments.
+   * The function returns a struct containing all output values.
    */ create(pb) {
         if (this.tmpName) {
             return pb.getCurrentScope()[this.tmpName];
@@ -26021,82 +26021,82 @@ class IRComparison extends IRExpression {
         }
     }
 }
-/**
- * IR expression for vector component swizzling
- *
- * @remarks
- * Extracts specific components from a vector using swizzle notation.
- * For scalar sources, constructs a vector with replicated values.
- *
- * @example
- * ```typescript
- * // Extract xyz from vec4
- * const xyz = new IRSwizzle(vec4Expr, 'xyz');
- *
- * // Extract single component
- * const x = new IRSwizzle(vec3Expr, 'x');
- *
- * // Swizzle and reorder
- * const bgr = new IRSwizzle(rgbExpr, 'bgr');
- * ```
- *
- * @public
+/**
+ * IR expression for vector component swizzling
+ *
+ * @remarks
+ * Extracts specific components from a vector using swizzle notation.
+ * For scalar sources, constructs a vector with replicated values.
+ *
+ * @example
+ * ```typescript
+ * // Extract xyz from vec4
+ * const xyz = new IRSwizzle(vec4Expr, 'xyz');
+ *
+ * // Extract single component
+ * const x = new IRSwizzle(vec3Expr, 'x');
+ *
+ * // Swizzle and reorder
+ * const bgr = new IRSwizzle(rgbExpr, 'bgr');
+ * ```
+ *
+ * @public
  */ class IRSwizzle extends IRExpression {
     /** The source expression to swizzle */ src;
     /** The swizzle pattern (e.g., 'xyz', 'rgb', 'x', 'yzw') */ hash;
-    /**
-   * Creates a swizzle expression
-   *
-   * @param src - The source vector expression
-   * @param hash - The swizzle pattern using xyzw or rgba notation
+    /**
+   * Creates a swizzle expression
+   *
+   * @param src - The source vector expression
+   * @param hash - The swizzle pattern using xyzw or rgba notation
    */ constructor(src, hash){
         super();
         this.src = src.addRef();
         this.hash = hash;
     }
-    /**
-   * Generates shader code for the swizzle operation
-   *
-   * @param pb - The program builder
-   * @returns The swizzled shader expression
-   *
-   * @remarks
-   * If source is a scalar number, creates a vector with that value repeated.
-   * Otherwise, applies the swizzle notation to the source expression.
+    /**
+   * Generates shader code for the swizzle operation
+   *
+   * @param pb - The program builder
+   * @returns The swizzled shader expression
+   *
+   * @remarks
+   * If source is a scalar number, creates a vector with that value repeated.
+   * Otherwise, applies the swizzle notation to the source expression.
    */ create(pb) {
         const src = this.src.create(pb);
         // @ts-ignore
         return typeof src === 'number' ? pb[`vec${this.hash.length}`](src) : src[this.hash];
     }
 }
-/**
- * IR expression for type casting with padding
- *
- * @remarks
- * Converts a value to a different vector type by padding with zeros.
- * Used when a smaller vector needs to be converted to a larger one.
- *
- * @example
- * ```typescript
- * // Cast float to vec3: vec3(value, 0, 0)
- * const vec3 = new IRCast(floatExpr, 'vec3', 2);
- *
- * // Cast vec2 to vec4: vec4(value.xy, 0, 0)
- * const vec4 = new IRCast(vec2Expr, 'vec4', 2);
- * ```
- *
- * @public
+/**
+ * IR expression for type casting with padding
+ *
+ * @remarks
+ * Converts a value to a different vector type by padding with zeros.
+ * Used when a smaller vector needs to be converted to a larger one.
+ *
+ * @example
+ * ```typescript
+ * // Cast float to vec3: vec3(value, 0, 0)
+ * const vec3 = new IRCast(floatExpr, 'vec3', 2);
+ *
+ * // Cast vec2 to vec4: vec4(value.xy, 0, 0)
+ * const vec4 = new IRCast(vec2Expr, 'vec4', 2);
+ * ```
+ *
+ * @public
  */ class IRCast extends IRExpression {
     /** The source expression to cast */ src;
     /** The values to be filled */ fill;
     /** The target type name (e.g., 'vec2', 'vec3', 'vec4') */ type;
     /** Number of zero components to append */ cast;
-    /**
-   * Creates a type cast expression
-   *
-   * @param src - The source expression
-   * @param type - The target type name
-   * @param cast - Number of zero components to append
+    /**
+   * Creates a type cast expression
+   *
+   * @param src - The source expression
+   * @param type - The target type name
+   * @param cast - Number of zero components to append
    */ constructor(src, type, cast, fill){
         super();
         this.src = src.addRef();
@@ -26104,15 +26104,15 @@ class IRComparison extends IRExpression {
         this.fill = fill?.slice() ?? null;
         this.type = type;
     }
-    /**
-   * Generates shader code for the type cast
-   *
-   * @param pb - The program builder
-   * @returns The casted shader expression
-   *
-   * @remarks
-   * Creates a vector constructor with the source value followed by zeros.
-   * Example: vec4(src, 0, 0) for casting vec2 to vec4.
+    /**
+   * Generates shader code for the type cast
+   *
+   * @param pb - The program builder
+   * @returns The casted shader expression
+   *
+   * @remarks
+   * Creates a vector constructor with the source value followed by zeros.
+   * Example: vec4(src, 0, 0) for casting vec2 to vec4.
    */ create(pb) {
         // @ts-ignore
         return pb[this.type](this.src.create(pb), ...this.fill ?? Array.from({
@@ -26120,35 +26120,35 @@ class IRComparison extends IRExpression {
         }).fill(0));
     }
 }
-/**
- * IR expression for texture sampling
- *
- * @remarks
- * Represents a texture lookup operation with optional normal map decoding.
- * Handles both color and normal map sampling with appropriate transformations.
- * Uses reference counting to cache the sampled result if used multiple times.
- *
- * @example
- * ```typescript
- * // Sample color texture
- * const color = new IRSampleTexture(texExpr, uvExpr, 'Color');
- *
- * // Sample normal map (automatically decodes from [0,1] to [-1,1])
- * const normal = new IRSampleTexture(texExpr, uvExpr, 'Normal');
- * ```
- *
- * @public
+/**
+ * IR expression for texture sampling
+ *
+ * @remarks
+ * Represents a texture lookup operation with optional normal map decoding.
+ * Handles both color and normal map sampling with appropriate transformations.
+ * Uses reference counting to cache the sampled result if used multiple times.
+ *
+ * @example
+ * ```typescript
+ * // Sample color texture
+ * const color = new IRSampleTexture(texExpr, uvExpr, 'Color');
+ *
+ * // Sample normal map (automatically decodes from [0,1] to [-1,1])
+ * const normal = new IRSampleTexture(texExpr, uvExpr, 'Normal');
+ * ```
+ *
+ * @public
  */ class IRSampleTexture extends IRExpression {
     /** The texture expression */ tex;
     /** The texture coordinate expression */ coord;
     /** The sampler type determining how to interpret the sampled value */ samplerType;
     /** Cached temporary variable name if result is referenced multiple times */ tmpName;
-    /**
-   * Creates a texture sample expression
-   *
-   * @param tex - The texture to sample from
-   * @param coord - The texture coordinates
-   * @param samplerType - How to interpret the sampled value ('Color' or 'Normal')
+    /**
+   * Creates a texture sample expression
+   *
+   * @param tex - The texture to sample from
+   * @param coord - The texture coordinates
+   * @param samplerType - How to interpret the sampled value ('Color' or 'Normal')
    */ constructor(tex, coord, samplerType){
         super();
         this.tex = tex.addRef();
@@ -26159,18 +26159,18 @@ class IRComparison extends IRExpression {
     /** Reset for next creation */ reset() {
         this.tmpName = '';
     }
-    /**
-   * Generates shader code for the texture sample operation
-   *
-   * @param pb - The program builder
-   * @returns The sampled color value
-   *
-   * @remarks
-   * For normal maps, applies the transformation: normal * 2 - 1 to convert
-   * from [0,1] texture space to [-1,1] tangent space.
-   * Caches result in a temporary variable if referenced multiple times.
-   *
-   * @throws Error if texture coordinate is not a valid expression or array
+    /**
+   * Generates shader code for the texture sample operation
+   *
+   * @param pb - The program builder
+   * @returns The sampled color value
+   *
+   * @remarks
+   * For normal maps, applies the transformation: normal * 2 - 1 to convert
+   * from [0,1] texture space to [-1,1] tangent space.
+   * Caches result in a temporary variable if referenced multiple times.
+   *
+   * @throws Error if texture coordinate is not a valid expression or array
    */ create(pb) {
         if (this.tmpName) {
             return pb.getCurrentScope()[this.tmpName];
@@ -26205,27 +26205,27 @@ class IRComparison extends IRExpression {
         }
     }
 }
-/**
- * IR expression for texture uniform constants
- *
- * @remarks
- * Represents a texture parameter that will be bound as a uniform.
- * Includes sampler configuration for texture filtering and addressing modes.
- *
- * @example
- * ```typescript
- * const tex = new IRConstantTexture(
- *   'u_baseColorMap',
- *   'tex2d',
- *   'repeat',
- *   'repeat',
- *   'linear',
- *   'linear',
- *   'linear'
- * );
- * ```
- *
- * @public
+/**
+ * IR expression for texture uniform constants
+ *
+ * @remarks
+ * Represents a texture parameter that will be bound as a uniform.
+ * Includes sampler configuration for texture filtering and addressing modes.
+ *
+ * @example
+ * ```typescript
+ * const tex = new IRConstantTexture(
+ *   'u_baseColorMap',
+ *   'tex2d',
+ *   'repeat',
+ *   'repeat',
+ *   'linear',
+ *   'linear',
+ *   'linear'
+ * );
+ * ```
+ *
+ * @public
  */ class IRConstantTexture extends IRExpression {
     /** The uniform texture variable name */ name;
     /** The texture id */ id;
@@ -26237,18 +26237,18 @@ class IRComparison extends IRExpression {
     /** Magnification filter mode */ filterMag;
     /** Mipmap filter mode */ filterMip;
     /** Whether texture params is used */ useParams;
-    /**
-   * Creates a texture constant expression
-   *
-   * @param name - The uniform variable name
-   * @param id - The texture id
-   * @param type - The texture type
-   * @param sRGB - Whether this texture should be loaded in sRGB color space
-   * @param addressU - Horizontal addressing mode
-   * @param addressV - Vertical addressing mode
-   * @param minFilter - Minification filter
-   * @param magFilter - Magnification filter
-   * @param mipFilter - Mipmap filter
+    /**
+   * Creates a texture constant expression
+   *
+   * @param name - The uniform variable name
+   * @param id - The texture id
+   * @param type - The texture type
+   * @param sRGB - Whether this texture should be loaded in sRGB color space
+   * @param addressU - Horizontal addressing mode
+   * @param addressV - Vertical addressing mode
+   * @param minFilter - Minification filter
+   * @param magFilter - Magnification filter
+   * @param mipFilter - Mipmap filter
    */ constructor(name, id, type, sRGB, addressU, addressV, minFilter, magFilter, mipFilter){
         super();
         this.name = name;
@@ -26262,14 +26262,14 @@ class IRComparison extends IRExpression {
         this.filterMip = mipFilter;
         this.useParams = false;
     }
-    /**
-   * Generates shader code for the texture uniform
-   *
-   * @param pb - The program builder
-   * @returns The texture uniform reference
-   *
-   * @remarks
-   * Creates the uniform declaration in the global scope if not already present.
+    /**
+   * Generates shader code for the texture uniform
+   *
+   * @param pb - The program builder
+   * @returns The texture uniform reference
+   *
+   * @remarks
+   * Creates the uniform declaration in the global scope if not already present.
    */ create(pb) {
         if (!pb.getGlobalScope()[this.name]) {
             // @ts-ignore
@@ -26277,11 +26277,11 @@ class IRComparison extends IRExpression {
         }
         return pb.getGlobalScope()[this.name];
     }
-    /**
-   * Converts to a uniform texture descriptor
-   *
-   * @param node - The texture node
-   * @returns Uniform texture descriptor with texture and sampler references
+    /**
+   * Converts to a uniform texture descriptor
+   *
+   * @param node - The texture node
+   * @returns Uniform texture descriptor with texture and sampler references
    */ asUniformTexture() {
         return {
             name: this.name,
@@ -26296,24 +26296,24 @@ class IRComparison extends IRExpression {
         };
     }
 }
-/**
- * Material Blueprint Intermediate Representation
- *
- * @remarks
- * The IR is a compiled representation of the material node graph that can be
- * efficiently translated to shader code. It performs:
- * - Type checking and validation
- * - Expression optimization (common subexpression elimination via reference counting)
- * - Uniform extraction (constants become shader uniforms)
- * - Dependency analysis (determines required vertex attributes)
- *
- * The compilation process:
- * 1. Traverse the DAG in topological order
- * 2. Build an IR expression tree
- * 3. Track uniforms and behaviors
- * 4. Generate optimized shader code from the IR
- *
- * @public
+/**
+ * Material Blueprint Intermediate Representation
+ *
+ * @remarks
+ * The IR is a compiled representation of the material node graph that can be
+ * efficiently translated to shader code. It performs:
+ * - Type checking and validation
+ * - Expression optimization (common subexpression elimination via reference counting)
+ * - Uniform extraction (constants become shader uniforms)
+ * - Dependency analysis (determines required vertex attributes)
+ *
+ * The compilation process:
+ * 1. Traverse the DAG in topological order
+ * 2. Build an IR expression tree
+ * 3. Track uniforms and behaviors
+ * 4. Generate optimized shader code from the IR
+ *
+ * @public
  */ class MaterialBlueprintIR {
     /** The directed acyclic graph of material nodes */ _dag;
     /** Unique hash identifying this material configuration */ _hash;
@@ -26325,16 +26325,16 @@ class IRComparison extends IRExpression {
     /** Fallback texture uniforms generated for TextureSample nodes without texture input */ _textureSampleFallbackMap;
     /** Flags indicating which shader features are used */ _behaviors;
     /** Array of named output expressions (e.g., baseColor, normal, metallic) */ _outputs;
-    /**
-   * Creates and compiles a material blueprint IR
-   *
-   * @param dag - The material node graph DAG
-   * @param hash - Unique identifier for this material
-   * @param editorState - Editor state snapshot
-   *
-   * @remarks
-   * Automatically compiles the DAG during construction.
-   * Check the `ok` property to verify successful compilation.
+    /**
+   * Creates and compiles a material blueprint IR
+   *
+   * @param dag - The material node graph DAG
+   * @param hash - Unique identifier for this material
+   * @param editorState - Editor state snapshot
+   *
+   * @remarks
+   * Automatically compiles the DAG during construction.
+   * Check the `ok` property to verify successful compilation.
    */ constructor(dag, hash, editorState){
         this._dag = dag ?? {
             nodeMap: {},
@@ -26349,10 +26349,10 @@ class IRComparison extends IRExpression {
         this._editorState = editorState;
         this.compile();
     }
-    /**
-   * Whether the IR compiled successfully
-   *
-   * @returns True if compilation produced valid outputs
+    /**
+   * Whether the IR compiled successfully
+   *
+   * @returns True if compilation produced valid outputs
    */ get ok() {
         return this._outputs ? this._outputs.length > 0 : false;
     }
@@ -26377,17 +26377,17 @@ class IRComparison extends IRExpression {
     /** Gets the array of uniform textures to bind at runtime */ get uniformTextures() {
         return this._uniformTextures;
     }
-    /**
-   * Compiles the material node graph to IR
-   *
-   * @returns True if compilation succeeded, false otherwise
-   *
-   * @remarks
-   * Processes all root nodes (typically a single material output node)
-   * and builds IR expressions for all connected inputs.
-   * Collects all required uniforms and sets behavior flags.
-   *
-   * Compilation fails if any required input is missing.
+    /**
+   * Compiles the material node graph to IR
+   *
+   * @returns True if compilation succeeded, false otherwise
+   *
+   * @remarks
+   * Processes all root nodes (typically a single material output node)
+   * and builds IR expressions for all connected inputs.
+   * Collects all required uniforms and sets behavior flags.
+   *
+   * Compilation fails if any required input is missing.
    */ compile() {
         this.reset();
         this._outputs = [];
@@ -26427,24 +26427,24 @@ class IRComparison extends IRExpression {
         }
         return true;
     }
-    /**
-   * Generates shader code from the IR
-   *
-   * @param pb - The program builder to generate code with
-   * @returns Array of named shader expressions, or null if IR is invalid
-   *
-   * @remarks
-   * Translates all IR expressions to actual shader code.
-   * Should be called within a shader function scope.
-   *
-   * @example
-   * ```typescript
-   * pb.fragmentShader(function() {
-   *   const outputs = ir.create(this);
-   *   this.baseColor = outputs.find(o => o.name === 'baseColor').exp;
-   *   this.normal = outputs.find(o => o.name === 'normal').exp;
-   * });
-   * ```
+    /**
+   * Generates shader code from the IR
+   *
+   * @param pb - The program builder to generate code with
+   * @returns Array of named shader expressions, or null if IR is invalid
+   *
+   * @remarks
+   * Translates all IR expressions to actual shader code.
+   * Should be called within a shader function scope.
+   *
+   * @example
+   * ```typescript
+   * pb.fragmentShader(function() {
+   *   const outputs = ir.create(this);
+   *   this.baseColor = outputs.find(o => o.name === 'baseColor').exp;
+   *   this.normal = outputs.find(o => o.name === 'normal').exp;
+   * });
+   * ```
    */ create(pb) {
         if (!this._outputs) {
             return null;
@@ -26461,12 +26461,12 @@ class IRComparison extends IRExpression {
         }
         return outputs;
     }
-    /**
-   * Resets the IR state for recompilation
-   *
-   * @remarks
-   * Clears all compiled data including expressions, uniforms, and behaviors.
-   * Called at the start of compilation.
+    /**
+   * Resets the IR state for recompilation
+   *
+   * @remarks
+   * Clears all compiled data including expressions, uniforms, and behaviors.
+   * Called at the start of compilation.
    */ reset() {
         this._expressions = [];
         this._expressionMap = new Map();
@@ -26479,19 +26479,19 @@ class IRComparison extends IRExpression {
             useVertexUV: false
         };
     }
-    /**
-   * Converts a graph node to an IR expression
-   *
-   * @param node - The graph node to convert
-   * @param output - The output slot ID
-   * @param originType - Optional type override for type casting
-   * @returns The corresponding IR expression
-   *
-   * @remarks
-   * Main dispatch method that routes to specific converters based on node type.
-   * Handles automatic type casting when originType differs from node output type.
-   *
-   * @throws Error if type casting is invalid
+    /**
+   * Converts a graph node to an IR expression
+   *
+   * @param node - The graph node to convert
+   * @param output - The output slot ID
+   * @param originType - Optional type override for type casting
+   * @returns The corresponding IR expression
+   *
+   * @remarks
+   * Main dispatch method that routes to specific converters based on node type.
+   * Handles automatic type casting when originType differs from node output type.
+   *
+   * @throws Error if type casting is invalid
    */ ir(inputNode) {
         const node = inputNode.inputNode;
         const output = inputNode.inputId;
@@ -26619,19 +26619,19 @@ class IRComparison extends IRExpression {
         }
         return expr;
     }
-    /**
-   * Gets or creates an IR expression for a graph node
-   *
-   * @param node - The graph node
-   * @param outputId - The output slot ID
-   * @param ctor - The IR expression constructor
-   * @param args - Constructor arguments
-   * @returns The cached or newly created IR expression
-   *
-   * @remarks
-   * Implements common subexpression elimination by caching expressions per node.
-   * Handles output slot swizzling and type casting.
-   * Collects uniform values and textures.
+    /**
+   * Gets or creates an IR expression for a graph node
+   *
+   * @param node - The graph node
+   * @param outputId - The output slot ID
+   * @param ctor - The IR expression constructor
+   * @param args - Constructor arguments
+   * @returns The cached or newly created IR expression
+   *
+   * @remarks
+   * Implements common subexpression elimination by caching expressions per node.
+   * Handles output slot swizzling and type casting.
+   * Collects uniform values and textures.
    */ getOrCreateIRExpression(node, outputId, ctor, ...args) {
         let ir;
         if (!this._expressionMap.has(node)) {
@@ -26886,11 +26886,11 @@ class IRComparison extends IRExpression {
                 this.$l.objUp = pb.normalize(pb.div(pb.mul(this.cameraUp, this.rotation), this.objScale));
                 this.$l.objRight = pb.normalize(pb.div(pb.mul(this.cameraRight, this.rotation), this.objScale));
                 // make ortho
-                /*
-        this.objRight = pb.normalize(
-          pb.sub(this.objRight, pb.mul(this.objUp, pb.dot(this.objRight, this.objUp)))
-        );
-        this.objForward = pb.cross(this.objUp, this.objRight);
+                /*
+        this.objRight = pb.normalize(
+          pb.sub(this.objRight, pb.mul(this.objUp, pb.dot(this.objRight, this.objUp)))
+        );
+        this.objForward = pb.cross(this.objUp, this.objRight);
         */ // make rotation matrix
                 this.$l.billboardMatrix = pb.mat3(this.objRight.x, this.objUp.x, this.objForward.x, this.objRight.y, this.objUp.y, this.objForward.y, this.objRight.z, this.objUp.z, this.objForward.z);
                 this.$return(pb.transpose(this.billboardMatrix));
@@ -29734,14 +29734,14 @@ function buildHiZ(sourceTex, HiZFrameBuffer) {
 }
 
 // ─── Handles ────────────────────────────────────────────────────────────
-/**
- * Opaque handle referencing a resource within the render graph.
- *
- * Handles are obtained from {@link RGPassBuilder.createTexture}, {@link RGPassBuilder.createFramebuffer},
- * {@link RenderGraph.importTexture}, or {@link RGPassBuilder.write}. They are lightweight identifiers
- * used to declare dependencies between passes.
- *
- * @public
+/**
+ * Opaque handle referencing a resource within the render graph.
+ *
+ * Handles are obtained from {@link RGPassBuilder.createTexture}, {@link RGPassBuilder.createFramebuffer},
+ * {@link RenderGraph.importTexture}, or {@link RGPassBuilder.write}. They are lightweight identifiers
+ * used to declare dependencies between passes.
+ *
+ * @public
  */ class RGHandle {
     /** @internal */ _id;
     /** @internal */ _name;
@@ -29753,9 +29753,9 @@ function buildHiZ(sourceTex, HiZFrameBuffer) {
         return this._name;
     }
 }
-/**
- * Internal bookkeeping for a resource within the render graph.
- * @public
+/**
+ * Internal bookkeeping for a resource within the render graph.
+ * @public
  */ class RGResource {
     id;
     name;
@@ -29772,14 +29772,14 @@ function buildHiZ(sourceTex, HiZFrameBuffer) {
         this.physicalId = physicalId;
     }
 }
-/**
- * Ordered execution step inside a render graph pass.
- *
- * Subpasses share the parent pass's resource declarations, lifetime, culling,
- * and access validation. They are intended to make multi-step pass bodies
- * explicit without splitting graph-level resource dependencies.
- *
- * @public
+/**
+ * Ordered execution step inside a render graph pass.
+ *
+ * Subpasses share the parent pass's resource declarations, lifetime, culling,
+ * and access validation. They are intended to make multi-step pass bodies
+ * explicit without splitting graph-level resource dependencies.
+ *
+ * @public
  */ class RGSubpass {
     name;
     executeFn;
@@ -29788,9 +29788,9 @@ function buildHiZ(sourceTex, HiZFrameBuffer) {
         this.executeFn = executeFn;
     }
 }
-/**
- * Internal bookkeeping for a pass within the render graph.
- * @public
+/**
+ * Internal bookkeeping for a pass within the render graph.
+ * @public
  */ class RGPass {
     index;
     name;
@@ -30706,50 +30706,50 @@ function buildHiZ(sourceTex, HiZFrameBuffer) {
     }
 }
 
-/**
- * Manages cross-frame history resources that can be imported into a render graph.
- *
- * History resources are textures that persist across frames for temporal effects
- * like TAA, motion blur, or temporal upscaling. Previous-frame textures can be
- * imported into a {@link RenderGraph}, and current-frame textures are committed
- * only after graph execution succeeds.
- *
- * Usage:
- * ```ts
- * const historyMgr = new HistoryResourceManager(allocator);
- * historyMgr.beginFrame();
- * const prev = historyMgr.importPrevious(graph, 'taaColor');
- * // declare builder.read(prev) if non-null
- * historyMgr.bindImportedTextures(executor);
- * // after successful execution:
- * historyMgr.commitFrame();
- * ```
- *
- * @typeParam TTexture - The concrete texture type (e.g. `Texture2D`).
- * @public
+/**
+ * Manages cross-frame history resources that can be imported into a render graph.
+ *
+ * History resources are textures that persist across frames for temporal effects
+ * like TAA, motion blur, or temporal upscaling. Previous-frame textures can be
+ * imported into a {@link RenderGraph}, and current-frame textures are committed
+ * only after graph execution succeeds.
+ *
+ * Usage:
+ * ```ts
+ * const historyMgr = new HistoryResourceManager(allocator);
+ * historyMgr.beginFrame();
+ * const prev = historyMgr.importPrevious(graph, 'taaColor');
+ * // declare builder.read(prev) if non-null
+ * historyMgr.bindImportedTextures(executor);
+ * // after successful execution:
+ * historyMgr.commitFrame();
+ * ```
+ *
+ * @typeParam TTexture - The concrete texture type (e.g. `Texture2D`).
+ * @public
  */ class HistoryResourceManager {
     _resources = new Map();
     _allocator;
     _pendingImports = new Map();
     _pendingCommits = new Map();
     _readScopeStack = [];
-    /**
-   * Create a new history resource manager.
-   *
-   * @param allocator - Texture allocator for creating history textures.
+    /**
+   * Create a new history resource manager.
+   *
+   * @param allocator - Texture allocator for creating history textures.
    */ constructor(allocator){
         this._allocator = allocator;
     }
-    /**
-   * Get the previous-frame texture resolved by the current render graph pass.
-   *
-   * The resource must have been imported with {@link HistoryResourceManager.importPrevious} or
-   * {@link HistoryResourceManager.importPreviousIfCompatible}, declared as a pass read, and bound with
-   * {@link HistoryResourceManager.beginReadScope} before this method is called.
-   *
-   * @param name - Name of the history resource.
-   * @returns The graph-resolved previous-frame texture.
-   * @throws If no read scope is active for the resource.
+    /**
+   * Get the previous-frame texture resolved by the current render graph pass.
+   *
+   * The resource must have been imported with {@link HistoryResourceManager.importPrevious} or
+   * {@link HistoryResourceManager.importPreviousIfCompatible}, declared as a pass read, and bound with
+   * {@link HistoryResourceManager.beginReadScope} before this method is called.
+   *
+   * @param name - Name of the history resource.
+   * @returns The graph-resolved previous-frame texture.
+   * @throws If no read scope is active for the resource.
    */ getPrevious(name) {
         const scoped = this._getScopedRead(name);
         if (scoped) {
@@ -30757,32 +30757,32 @@ function buildHiZ(sourceTex, HiZFrameBuffer) {
         }
         throw new Error(`History resource '${name}' is not available in the current render graph read scope. ` + `Import it and declare a pass read before accessing it.`);
     }
-    /**
-   * Check whether a valid history resource exists and matches the descriptor.
-   *
-   * @param name - Name of the history resource.
-   * @param desc - Expected texture descriptor.
-   * @param size - Expected resolved size.
-   * @returns True if the resource exists, is valid, and matches.
+    /**
+   * Check whether a valid history resource exists and matches the descriptor.
+   *
+   * @param name - Name of the history resource.
+   * @param desc - Expected texture descriptor.
+   * @param size - Expected resolved size.
+   * @returns True if the resource exists, is valid, and matches.
    */ isCompatible(name, desc, size) {
         const resource = this._resources.get(name);
         return !!resource?.valid && this._matches(resource, desc, size);
     }
-    /**
-   * Start collecting graph imports and deferred commits for a new frame.
+    /**
+   * Start collecting graph imports and deferred commits for a new frame.
    */ beginFrame() {
         this.discardFrame();
         this._pendingImports.clear();
         this._readScopeStack.length = 0;
     }
-    /**
-   * Import the latest committed texture for a history resource into the graph.
-   *
-   * Returns null when the resource has no valid previous frame.
-   *
-   * @param graph - Render graph to import into.
-   * @param name - History resource name.
-   * @returns Imported graph handle, or null when no valid previous texture exists.
+    /**
+   * Import the latest committed texture for a history resource into the graph.
+   *
+   * Returns null when the resource has no valid previous frame.
+   *
+   * @param graph - Render graph to import into.
+   * @param name - History resource name.
+   * @returns Imported graph handle, or null when no valid previous texture exists.
    */ importPrevious(graph, name) {
         const resource = this._resources.get(name);
         const texture = resource?.valid ? resource.textures[resource.currentIndex] : null;
@@ -30793,34 +30793,34 @@ function buildHiZ(sourceTex, HiZFrameBuffer) {
         this._pendingImports.set(handle, texture);
         return handle;
     }
-    /**
-   * Import the latest committed texture only when it matches the expected shape.
-   *
-   * This is the preferred API for effects that can declare their history reads
-   * while building the graph: incompatible history is treated as absent, so the
-   * pass does not declare stale reads after resize or format changes.
-   *
-   * @param graph - Render graph to import into.
-   * @param name - History resource name.
-   * @param desc - Expected texture descriptor.
-   * @param size - Expected resolved size.
-   * @returns Imported graph handle, or null when no compatible history exists.
+    /**
+   * Import the latest committed texture only when it matches the expected shape.
+   *
+   * This is the preferred API for effects that can declare their history reads
+   * while building the graph: incompatible history is treated as absent, so the
+   * pass does not declare stale reads after resize or format changes.
+   *
+   * @param graph - Render graph to import into.
+   * @param name - History resource name.
+   * @param desc - Expected texture descriptor.
+   * @param size - Expected resolved size.
+   * @returns Imported graph handle, or null when no compatible history exists.
    */ importPreviousIfCompatible(graph, name, desc, size) {
         return this.isCompatible(name, desc, size) ? this.importPrevious(graph, name) : null;
     }
-    /**
-   * Bind all history imports created for this frame to the executor.
-   *
-   * @param executor - Render graph executor for the current frame.
+    /**
+   * Bind all history imports created for this frame to the executor.
+   *
+   * @param executor - Render graph executor for the current frame.
    */ bindImportedTextures(executor) {
         for (const [handle, texture] of this._pendingImports){
             executor.setImportedTexture(handle, texture);
         }
     }
-    /**
-   * Make resolved history textures available to code executing inside a pass.
-   *
-   * @param bindings - History name to resolved texture bindings.
+    /**
+   * Make resolved history textures available to code executing inside a pass.
+   *
+   * @param bindings - History name to resolved texture bindings.
    */ beginReadScope(bindings) {
         const scope = new Map();
         for (const binding of bindings){
@@ -30828,22 +30828,22 @@ function buildHiZ(sourceTex, HiZFrameBuffer) {
         }
         this._readScopeStack.push(scope);
     }
-    /**
-   * End the most recent history read scope.
+    /**
+   * End the most recent history read scope.
    */ endReadScope() {
         this._readScopeStack.pop();
     }
-    /**
-   * Queue a current-frame texture to become the next previous-frame history.
-   *
-   * The texture is committed only when {@link HistoryResourceManager.commitFrame} is called. If the
-   * frame fails, {@link HistoryResourceManager.discardFrame} releases owned pending textures instead.
-   *
-   * @param name - History resource name.
-   * @param desc - Texture descriptor.
-   * @param size - Resolved texture size.
-   * @param texture - Texture produced by the current frame.
-   * @param ownsTexture - Whether this manager should release the texture later.
+    /**
+   * Queue a current-frame texture to become the next previous-frame history.
+   *
+   * The texture is committed only when {@link HistoryResourceManager.commitFrame} is called. If the
+   * frame fails, {@link HistoryResourceManager.discardFrame} releases owned pending textures instead.
+   *
+   * @param name - History resource name.
+   * @param desc - Texture descriptor.
+   * @param size - Resolved texture size.
+   * @param texture - Texture produced by the current frame.
+   * @param ownsTexture - Whether this manager should release the texture later.
    */ queueCommit(name, desc, size, texture, ownsTexture = true) {
         const existing = this._pendingCommits.get(name);
         if (existing?.ownsTexture) {
@@ -30860,8 +30860,8 @@ function buildHiZ(sourceTex, HiZFrameBuffer) {
             ownsTexture
         });
     }
-    /**
-   * Commit all current-frame history writes.
+    /**
+   * Commit all current-frame history writes.
    */ commitFrame() {
         for (const [name, pending] of this._pendingCommits){
             let resource = this._resources.get(name);
@@ -30908,8 +30908,8 @@ function buildHiZ(sourceTex, HiZFrameBuffer) {
         this._pendingImports.clear();
         this._readScopeStack.length = 0;
     }
-    /**
-   * Discard all uncommitted frame history writes.
+    /**
+   * Discard all uncommitted frame history writes.
    */ discardFrame() {
         for (const pending of this._pendingCommits.values()){
             if (pending.ownsTexture) {
@@ -30920,10 +30920,10 @@ function buildHiZ(sourceTex, HiZFrameBuffer) {
         this._pendingImports.clear();
         this._readScopeStack.length = 0;
     }
-    /**
-   * Release all history resources and clear the manager.
-   *
-   * Call this when disposing the render context or when history is no longer needed.
+    /**
+   * Release all history resources and clear the manager.
+   *
+   * Call this when disposing the render context or when history is no longer needed.
    */ dispose() {
         this.discardFrame();
         for (const resource of this._resources.values()){
@@ -30962,9 +30962,9 @@ function buildHiZ(sourceTex, HiZFrameBuffer) {
     }
 }
 
-/**
- * Resource names for render graph history resources.
- * @public
+/**
+ * Resource names for render graph history resources.
+ * @public
  */ const RGHistoryResources = {
     TAA_COLOR: 'taaColor',
     TAA_MOTION_VECTOR: 'taaMotionVector'
@@ -36978,24 +36978,24 @@ class DepthLimitAOBlurBlitter extends BilateralBlurBlitter {
     }
 }
 
-/**
- * A renderable camera node that manages view/projection math, frusta,
- * input control, picking, and a post-processing chain via a compositor.
- *
- * Key features:
- * - Maintains projection, view, VP, and inverse VP matrices and lazily recomputes them when invalidated.
- * - Provides world- and view-space frusta for culling and clipping.
- * - Supports perspective and orthographic projections.
- * - Integrates with post effects (Tonemap, FXAA, TAA, Bloom, SSR, SSAO, Motion Blur) through an internal `Compositor`.
- * - Handles temporal jitter and history state when TAA or motion blur are enabled.
- * - Emits picking rays from screen coordinates and supports async GPU picking.
- * - Optional controller integration for user input handling.
- *
- * Performance notes:
- * - Matrices/frusta are computed on demand and cached until invalidation.
- * - Temporal jitter and history are set up only when required by enabled features and device support.
- *
- * @public
+/**
+ * A renderable camera node that manages view/projection math, frusta,
+ * input control, picking, and a post-processing chain via a compositor.
+ *
+ * Key features:
+ * - Maintains projection, view, VP, and inverse VP matrices and lazily recomputes them when invalidated.
+ * - Provides world- and view-space frusta for culling and clipping.
+ * - Supports perspective and orthographic projections.
+ * - Integrates with post effects (Tonemap, FXAA, TAA, Bloom, SSR, SSAO, Motion Blur) through an internal `Compositor`.
+ * - Handles temporal jitter and history state when TAA or motion blur are enabled.
+ * - Emits picking rays from screen coordinates and supports async GPU picking.
+ * - Optional controller integration for user input handling.
+ *
+ * Performance notes:
+ * - Matrices/frusta are computed on demand and cached until invalidation.
+ * - Temporal jitter and history are set up only when required by enabled features and device support.
+ *
+ * @public
  */ class Camera extends SceneNode {
     /** @internal Halton 2-3 sequence used for TAA jittering. */ static _halton23 = halton23(16);
     /** @internal Per-camera history resource manager. */ static _historyResourceManager = new WeakMap();
@@ -37084,14 +37084,14 @@ class DepthLimitAOBlurBlitter extends BilateralBlurBlitter {
     /** @internal Post-processing compositor attached to this camera. */ _compositor;
     /** @internal Pointer interaction rectangle in css pixels (relative to canvas) */ _interactionRect;
     /** @internal captured by which mouse button (-1 if not captured) */ _capturedButton;
-    /**
-   * Creates a new camera node.
-   *
-   * Initializes projection/view matrices, temporal fields, controller linkage, and
-   * builds the default post-processing pipeline on the internal compositor.
-   *
-   * @param scene - The scene that owns this camera.
-   * @param projectionMatrix - Optional projection matrix to initialize with.
+    /**
+   * Creates a new camera node.
+   *
+   * Initializes projection/view matrices, temporal fields, controller linkage, and
+   * builds the default post-processing pipeline on the internal compositor.
+   *
+   * @param scene - The scene that owns this camera.
+   * @param projectionMatrix - Optional projection matrix to initialize with.
    */ constructor(scene, projectionMatrix){
         super(scene);
         this._projMatrix = projectionMatrix || Matrix4x4.identity();
@@ -37184,73 +37184,73 @@ class DepthLimitAOBlurBlitter extends BilateralBlurBlitter {
             scene.mainCamera = this;
         }
     }
-    /**
-   * The compositor that owns and runs the camera's post-processing chain.
+    /**
+   * The compositor that owns and runs the camera's post-processing chain.
    */ get compositor() {
         return this._compositor;
     }
-    /**
-   * Pointer interaction rectangle in css pixels (relative to canvas)
+    /**
+   * Pointer interaction rectangle in css pixels (relative to canvas)
    */ get interactionRect() {
         return this._interactionRect;
     }
     set interactionRect(rect) {
         this._interactionRect = rect;
     }
-    /**
-   * Framebuffer clear color, or `null` to disable.
+    /**
+   * Framebuffer clear color, or `null` to disable.
    */ get clearColor() {
         return this._clearColor;
     }
     set clearColor(v) {
         this._clearColor = v?.clone() ?? null;
     }
-    /**
-   * Framebuffer stencil clear value, disabled when null. Default is 0.
+    /**
+   * Framebuffer stencil clear value, disabled when null. Default is 0.
    */ get clearDepth() {
         return this._clearDepth;
     }
     set clearDepth(v) {
         this._clearDepth = v;
     }
-    /**
-   * Framebuffer stencil clear value, disabled when null. Default is 0.
+    /**
+   * Framebuffer stencil clear value, disabled when null. Default is 0.
    */ get clearStencil() {
         return this._clearStencil;
     }
     set clearStencil(v) {
         this._clearStencil = v;
     }
-    /**
-   * Whether Hi-Z acceleration is enabled.
-   *
-   * Often improves SSR performance with little quality impact when supported.
+    /**
+   * Whether Hi-Z acceleration is enabled.
+   *
+   * Often improves SSR performance with little quality impact when supported.
    */ get HiZ() {
         return this._HiZ;
     }
     set HiZ(val) {
         this._HiZ = !!val;
     }
-    /**
-   * Whether HDR backbuffer is enabled.
-   *
-   * Tonemap should be disabled when not using HDR backbuffer.
+    /**
+   * Whether HDR backbuffer is enabled.
+   *
+   * Tonemap should be disabled when not using HDR backbuffer.
    */ get HDR() {
         return this._HDR;
     }
     set HDR(val) {
         this._HDR = !!val;
     }
-    /**
-   * Whether tonemapping is enabled via the post effect.
+    /**
+   * Whether tonemapping is enabled via the post effect.
    */ get toneMap() {
         return this._postEffectTonemap.get().enabled;
     }
     set toneMap(val) {
         this._postEffectTonemap.get().enabled = !!val;
     }
-    /**
-   * Whether motion blur is enabled via the post effect.
+    /**
+   * Whether motion blur is enabled via the post effect.
    */ get motionBlur() {
         return this._postEffectMotionBlur.get().enabled;
     }
@@ -37266,16 +37266,16 @@ class DepthLimitAOBlurBlitter extends BilateralBlurBlitter {
             this._postEffectMotionBlur.get().strength = this._motionBlurStrength;
         }
     }
-    /**
-   * Gets whether Bloom is enabled.
+    /**
+   * Gets whether Bloom is enabled.
    */ get bloom() {
         return this._postEffectBloom.get().enabled;
     }
     set bloom(val) {
         this._postEffectBloom.get().enabled = !!val;
     }
-    /**
-   * Maximum bloom downsample levels
+    /**
+   * Maximum bloom downsample levels
    */ get bloomMaxDownsampleLevels() {
         return this._bloomMaxDownsampleLevels;
     }
@@ -37285,8 +37285,8 @@ class DepthLimitAOBlurBlitter extends BilateralBlurBlitter {
             this._postEffectBloom.get().maxDownsampleLevel = val;
         }
     }
-    /**
-   * Bloom downsample limit
+    /**
+   * Bloom downsample limit
    */ get bloomDownsampleLimit() {
         return this._bloomDownsampleLimit;
     }
@@ -37296,8 +37296,8 @@ class DepthLimitAOBlurBlitter extends BilateralBlurBlitter {
             this._postEffectBloom.get().downsampleLimit = val;
         }
     }
-    /**
-   * Bloom threshold
+    /**
+   * Bloom threshold
    */ get bloomThreshold() {
         return this._bloomThreshold;
     }
@@ -37307,8 +37307,8 @@ class DepthLimitAOBlurBlitter extends BilateralBlurBlitter {
             this._postEffectBloom.get().threshold = val;
         }
     }
-    /**
-   * Bloom threshold knee
+    /**
+   * Bloom threshold knee
    */ get bloomThresholdKnee() {
         return this._bloomThresholdKnee;
     }
@@ -37318,8 +37318,8 @@ class DepthLimitAOBlurBlitter extends BilateralBlurBlitter {
             this._postEffectBloom.get().thresholdKnee = val;
         }
     }
-    /**
-   * Bloom intensity
+    /**
+   * Bloom intensity
    */ get bloomIntensity() {
         return this._bloomIntensity;
     }
@@ -37371,16 +37371,16 @@ class DepthLimitAOBlurBlitter extends BilateralBlurBlitter {
             this._postEffectColorAdjust.get().sharpen = val;
         }
     }
-    /**
-   * Gets whether FXAA is enabled.
+    /**
+   * Gets whether FXAA is enabled.
    */ get FXAA() {
         return this._postEffectFXAA.get().enabled;
     }
     set FXAA(val) {
         this._postEffectFXAA.get().enabled = !!val;
     }
-    /**
-   * Tonemap exposure
+    /**
+   * Tonemap exposure
    */ get toneMapExposure() {
         return this._tonemapExposure;
     }
@@ -37390,123 +37390,123 @@ class DepthLimitAOBlurBlitter extends BilateralBlurBlitter {
             this._postEffectTonemap.get().exposure = val;
         }
     }
-    /**
-   * Gets whether TAA is enabled.
+    /**
+   * Gets whether TAA is enabled.
    */ get TAA() {
         return this._postEffectTAA.get().enabled;
     }
     set TAA(val) {
         this._postEffectTAA.get().enabled = !!val;
     }
-    /**
-   * Gets the debug flag for TAA
+    /**
+   * Gets the debug flag for TAA
    */ get TAADebug() {
         return this._TAADebug;
     }
     set TAADebug(val) {
         this._TAADebug = val;
     }
-    /**
-   * Gets whether Screen Space Reflections (SSR) is enabled.
+    /**
+   * Gets whether Screen Space Reflections (SSR) is enabled.
    */ get SSR() {
         return this._postEffectSSR.get().enabled;
     }
     set SSR(val) {
         this._postEffectSSR.get().enabled = !!val;
     }
-    /**
-   * Gets the maximum roughness value for screen space reflections.
-   * Controls the cutoff point where surfaces are considered too rough for SSR.
+    /**
+   * Gets the maximum roughness value for screen space reflections.
+   * Controls the cutoff point where surfaces are considered too rough for SSR.
    */ get ssrMaxRoughness() {
         return this._ssrMaxRoughness;
     }
     set ssrMaxRoughness(val) {
         this._ssrMaxRoughness = val;
     }
-    /**
-   * Gets the roughness factor for SSR calculations.
-   * Affects how surface roughness influences reflection clarity.
+    /**
+   * Gets the roughness factor for SSR calculations.
+   * Affects how surface roughness influences reflection clarity.
    */ get ssrRoughnessFactor() {
         return this._ssrRoughnessFactor;
     }
     set ssrRoughnessFactor(val) {
         this._ssrRoughnessFactor = val;
     }
-    /**
-   * Gets the stride value for SSR ray marching.
-   * Controls the step size during ray marching. Larger values improve performance but may miss details.
+    /**
+   * Gets the stride value for SSR ray marching.
+   * Controls the step size during ray marching. Larger values improve performance but may miss details.
    */ get ssrStride() {
         return this._ssrStride;
     }
     set ssrStride(val) {
         this._ssrStride = val;
     }
-    /**
-   * Gets the maximum distance for SSR ray marching.
-   * Defines how far rays will travel when searching for reflection intersections.
+    /**
+   * Gets the maximum distance for SSR ray marching.
+   * Defines how far rays will travel when searching for reflection intersections.
    */ get ssrMaxDistance() {
         return this._ssrParams.x;
     }
     set ssrMaxDistance(val) {
         this._ssrParams.x = val;
     }
-    /**
-   * Gets the number of iterations for SSR ray marching.
-   * Higher values provide more accurate reflections but impact performance.
+    /**
+   * Gets the number of iterations for SSR ray marching.
+   * Higher values provide more accurate reflections but impact performance.
    */ get ssrIterations() {
         return this._ssrParams.y;
     }
     set ssrIterations(val) {
         this._ssrParams.y = val;
     }
-    /**
-   * Gets the thickness value for SSR calculations.
-   * Determines the thickness threshold for surfaces when calculating reflections.
+    /**
+   * Gets the thickness value for SSR calculations.
+   * Determines the thickness threshold for surfaces when calculating reflections.
    */ get ssrThickness() {
         return this._ssrParams.z;
     }
     set ssrThickness(val) {
         this._ssrParams.z = val;
     }
-    /**
-   * Gets whether SSR should calculate thickness automatically.
-   * When enabled, the system will dynamically compute surface thickness for reflections.
+    /**
+   * Gets whether SSR should calculate thickness automatically.
+   * When enabled, the system will dynamically compute surface thickness for reflections.
    */ get ssrCalcThickness() {
         return this._ssrCalcThickness;
     }
     set ssrCalcThickness(val) {
         this._ssrCalcThickness = !!val;
     }
-    /**
-   * Gets the blur scale factor for SSR.
-   * Controls the overall intensity of the blur effect applied to reflections.
+    /**
+   * Gets the blur scale factor for SSR.
+   * Controls the overall intensity of the blur effect applied to reflections.
    */ get ssrBlurScale() {
         return this._ssrBlurriness;
     }
     set ssrBlurScale(val) {
         this._ssrBlurriness = val;
     }
-    /**
-   * Gets the depth cutoff value for SSR blur.
-   * Determines at what depth difference the blur effect should be reduced or eliminated.
+    /**
+   * Gets the depth cutoff value for SSR blur.
+   * Determines at what depth difference the blur effect should be reduced or eliminated.
    */ get ssrBlurDepthCutoff() {
         return this._ssrBlurDepthCutoff;
     }
     set ssrBlurDepthCutoff(val) {
         this._ssrBlurDepthCutoff = val;
     }
-    /**
-   * Gets the kernel size for the SSR blur effect.
-   * Defines the size of the blur kernel. Larger values create softer, more spread-out blur.
+    /**
+   * Gets the kernel size for the SSR blur effect.
+   * Defines the size of the blur kernel. Larger values create softer, more spread-out blur.
    */ get ssrBlurKernelSize() {
         return this._ssrBlurKernelSize;
     }
     set ssrBlurKernelSize(val) {
         this._ssrBlurKernelSize = val;
     }
-    /**
-   * Gets the standard deviation for the SSR Gaussian blur.
-   * Controls the distribution of the blur effect. Higher values create more pronounced blur.
+    /**
+   * Gets the standard deviation for the SSR Gaussian blur.
+   * Controls the distribution of the blur effect. Higher values create more pronounced blur.
    */ get ssrBlurStdDev() {
         return this._ssrBlurStdDev;
     }
@@ -37516,8 +37516,8 @@ class DepthLimitAOBlurBlitter extends BilateralBlurBlitter {
     /** @internal */ get ssrParams() {
         return this._ssrParams;
     }
-    /**
-   * Gets whether SSAO is enabled.
+    /**
+   * Gets whether SSAO is enabled.
    */ get SSAO() {
         return this._postEffectSSAO.get().enabled;
     }
@@ -37657,27 +37657,27 @@ class DepthLimitAOBlurBlitter extends BilateralBlurBlitter {
         }
         return this._viewport;
     }
-    /**
-   * Screen configuration used for adapting the camera viewport
+    /**
+   * Screen configuration used for adapting the camera viewport
    */ get screenConfig() {
         return this._screenAdapter.config;
     }
     set screenConfig(config) {
         this._screenAdapter.config = config;
     }
-    /**
-   * Screen viewport used for adapting the camera viewport
+    /**
+   * Screen viewport used for adapting the camera viewport
    */ get screenViewport() {
         return this._screenAdapter.viewport;
     }
     set screenViewport(viewport) {
         this._screenAdapter.viewport = viewport;
     }
-    /**
-   * Handle input events
-   * @param ev - input event object
-   * @param type - event type, default to ev.type
-   * @returns Boolean value indicates whether the event was handled.
+    /**
+   * Handle input events
+   * @param ev - input event object
+   * @param type - event type, default to ev.type
+   * @returns Boolean value indicates whether the event was handled.
    */ handleEvent(ev, type) {
         let handled = false;
         if (this._controller) {
@@ -37710,14 +37710,14 @@ class DepthLimitAOBlurBlitter extends BilateralBlurBlitter {
         }
         return handled;
     }
-    /**
-   * Constructs a ray based on the given screen coordinates.
-   *
-   * @param x - The x-component of the screen coordinates, relative to the top-left corner of the viewport.
-   * @param y - The y-component of the screen coordinates, relative to the top-left corner of the viewport.
-   * @param viewportWidth - Optional width of the viewport for normalizing screen coordinates. If not provided, it will be derived from the camera's viewport or the device's viewport.
-   * @param viewportHeight - Optional height of the viewport for normalizing screen coordinates. If not provided, it will be derived from the camera's viewport or the device's viewport.
-   * @returns The ray originating from the camera position and passing through the given screen coordinates.
+    /**
+   * Constructs a ray based on the given screen coordinates.
+   *
+   * @param x - The x-component of the screen coordinates, relative to the top-left corner of the viewport.
+   * @param y - The y-component of the screen coordinates, relative to the top-left corner of the viewport.
+   * @param viewportWidth - Optional width of the viewport for normalizing screen coordinates. If not provided, it will be derived from the camera's viewport or the device's viewport.
+   * @param viewportHeight - Optional height of the viewport for normalizing screen coordinates. If not provided, it will be derived from the camera's viewport or the device's viewport.
+   * @returns The ray originating from the camera position and passing through the given screen coordinates.
    */ constructRay(x, y, viewportWidth, viewportHeight) {
         const width = viewportWidth ?? (this.viewport ? this.viewport[2] : getDevice().getViewport().width);
         const height = viewportHeight ?? (this.viewport ? this.viewport[3] : getDevice().getViewport().height);
@@ -37735,54 +37735,54 @@ class DepthLimitAOBlurBlitter extends BilateralBlurBlitter {
         const vDir = Vector3.sub(farWorld.xyz(), vEye).inplaceNormalize();
         return new Ray(vEye, vDir);
     }
-    /**
-   * Place the camera by specifying the camera position and the target point
-   * @param eye - The camera position
-   * @param target - The target point to look at
-   * @param up - The up vector
-   * @returns self
+    /**
+   * Place the camera by specifying the camera position and the target point
+   * @param eye - The camera position
+   * @param target - The target point to look at
+   * @param up - The up vector
+   * @returns self
    */ lookAt(eye, target, up) {
         return this.setLocalTransform(Matrix4x4.lookAt(eye, target, up));
     }
-    /**
-   * Place the camera to look at a given cube face at a given camera position
-   * @param face - The cube face to look at
-   * @param position - The camera position
-   * @returns self
+    /**
+   * Place the camera to look at a given cube face at a given camera position
+   * @param face - The cube face to look at
+   * @param position - The camera position
+   * @returns self
    */ lookAtCubeFace(face, position) {
         return this.setLocalTransform(Matrix4x4.lookAtCubeFace(face, position ?? this.position));
     }
-    /**
-   * Setup a perspective projection matrix for the camera
-   * @param fovY - The vertical field of view in radians.
-   * @param aspect - The aspect ratio
-   * @param zNear - The near clip plane
-   * @param zFar - The far clip plane
-   * @returns self
+    /**
+   * Setup a perspective projection matrix for the camera
+   * @param fovY - The vertical field of view in radians.
+   * @param aspect - The aspect ratio
+   * @param zNear - The near clip plane
+   * @param zFar - The far clip plane
+   * @returns self
    */ setPerspective(fovY, aspect, zNear, zFar) {
         this._projMatrix.perspective(fovY, aspect, zNear, zFar);
         Matrix4x4.invert(this._projMatrix, this._invProjMatrix);
         this._invalidate(true);
         return this;
     }
-    /**
-   * Setup a orthogonal projection matrix for the camera
-   * @param left - Left bound of the frustum
-   * @param right - Right bound of the frustum
-   * @param bottom - Bottom bound of the frustum
-   * @param top - Top bound of the frustum
-   * @param near - Near bound of the frustum.
-   * @param far - Far bound of the frustum.
-   * @returns self
+    /**
+   * Setup a orthogonal projection matrix for the camera
+   * @param left - Left bound of the frustum
+   * @param right - Right bound of the frustum
+   * @param bottom - Bottom bound of the frustum
+   * @param top - Top bound of the frustum
+   * @param near - Near bound of the frustum.
+   * @param far - Far bound of the frustum.
+   * @returns self
    */ setOrtho(left, right, bottom, top, near, far) {
         this._projMatrix.ortho(left, right, bottom, top, near, far);
         Matrix4x4.invert(this._projMatrix, this._invProjMatrix);
         this._invalidate(true);
         return this;
     }
-    /**
-   * Setup a projection matrix for the camera
-   * @param matrix - The projection matrix
+    /**
+   * Setup a projection matrix for the camera
+   * @param matrix - The projection matrix
    */ setProjectionMatrix(matrix) {
         if (matrix && matrix !== this._projMatrix) {
             this._projMatrix = matrix;
@@ -37790,18 +37790,18 @@ class DepthLimitAOBlurBlitter extends BilateralBlurBlitter {
             this._invalidate(true);
         }
     }
-    /**
-   * Gets the projection matrix of the camera
-   * @returns The projection matrix
+    /**
+   * Gets the projection matrix of the camera
+   * @returns The projection matrix
    */ getProjectionMatrix() {
         if (this.dirtyCheck()) {
             this._compute();
         }
         return this._projMatrix;
     }
-    /**
-   * Gets the inverse projection matrix of the camera
-   * @returns The projection matrix
+    /**
+   * Gets the inverse projection matrix of the camera
+   * @returns The projection matrix
    */ getInvProjectionMatrix() {
         if (this.dirtyCheck()) {
             this._compute();
@@ -37819,11 +37819,11 @@ class DepthLimitAOBlurBlitter extends BilateralBlurBlitter {
         rotationMatrix.setRow(2, new Vector4(zAxis.x, zAxis.y, zAxis.z, 0));
         return rotationMatrix;
     }
-    /**
-   * View matrix of the camera
-   *
-   * @remarks
-   * Camera's view matrix will transform a point from the world space to the camera space
+    /**
+   * View matrix of the camera
+   *
+   * @remarks
+   * Camera's view matrix will transform a point from the world space to the camera space
    */ get viewMatrix() {
         if (this.dirtyCheck()) {
             this._compute();
@@ -37836,11 +37836,11 @@ class DepthLimitAOBlurBlitter extends BilateralBlurBlitter {
         }
         return this._viewProjMatrix;
     }
-    /**
-   * The inverse-view-projection matrix of the camera
-   *
-   * @remarks
-   * The inverse-view-projection matrix transforms a point from the clip space to the camera space
+    /**
+   * The inverse-view-projection matrix of the camera
+   *
+   * @remarks
+   * The inverse-view-projection matrix transforms a point from the clip space to the camera space
    */ get invViewProjectionMatrix() {
         if (this.dirtyCheck()) {
             this._compute();
@@ -37892,9 +37892,9 @@ class DepthLimitAOBlurBlitter extends BilateralBlurBlitter {
     /** Returns true if the camera is orthographic */ isOrtho() {
         return this.getProjectionMatrix().isOrtho();
     }
-    /**
-   * Gets the camera history resource manager for temporal effects
-   * @returns History resource manager
+    /**
+   * Gets the camera history resource manager for temporal effects
+   * @returns History resource manager
    */ getHistoryResourceManager() {
         let manager = Camera._historyResourceManager.get(this);
         if (!manager) {
@@ -37904,14 +37904,14 @@ class DepthLimitAOBlurBlitter extends BilateralBlurBlitter {
         }
         return manager;
     }
-    /**
-   * Sets the camera history resource manager for temporal effects
-   * @internal
+    /**
+   * Sets the camera history resource manager for temporal effects
+   * @internal
    */ setHistoryResourceManager(manager) {
         Camera._historyResourceManager.set(this, manager);
     }
-    /**
-   * Clears the camera history data which is used in temporal reprojection
+    /**
+   * Clears the camera history data which is used in temporal reprojection
    */ clearHistoryData() {
         // Clear history resource manager
         const manager = Camera._historyResourceManager.get(this);
@@ -37991,10 +37991,10 @@ class DepthLimitAOBlurBlitter extends BilateralBlurBlitter {
             this._compositor.appendPostEffect(bloom);
         }
     }
-    /**
-   * Renders a scene
-   * @param scene - The scene to be rendered
-   * @param compositor - Compositor instance that will be used to apply postprocess effects
+    /**
+   * Renders a scene
+   * @param scene - The scene to be rendered
+   * @param compositor - Compositor instance that will be used to apply postprocess effects
    */ render(scene) {
         const device = getDevice();
         //this.updatePostProcessing(device);
@@ -38068,13 +38068,13 @@ class DepthLimitAOBlurBlitter extends BilateralBlurBlitter {
     /** @internal */ getPickPosY() {
         return this._pickPosY;
     }
-    /**
-   * Updates the controller state
+    /**
+   * Updates the controller state
    */ updateController() {
         this._controller?.update();
     }
-    /**
-   * Reset the controller
+    /**
+   * Reset the controller
    */ resetController() {
         this._controller?.reset();
     }
@@ -54516,16 +54516,16 @@ function isBoneFixed(roots, index) {
 }
 
 // High-level orchestrator - SPCRJointDynamicsController API
-/**
- * High-level controller for joint dynamics simulation.
- *
- * This class manages the physics simulation for a hierarchy of bones, including constraints,
- * colliders, and grabbers. It provides an API for initializing the system with bone data and
- * transforms, stepping the simulation each frame, and modifying colliders and grabbers at runtime.
- * The controller handles the internal state and logic for blending between animation and physics,
- * applying forces, and enforcing constraints.
- *
- * @public
+/**
+ * High-level controller for joint dynamics simulation.
+ *
+ * This class manages the physics simulation for a hierarchy of bones, including constraints,
+ * colliders, and grabbers. It provides an API for initializing the system with bone data and
+ * transforms, stepping the simulation each frame, and modifying colliders and grabbers at runtime.
+ * The controller handles the internal state and logic for blending between animation and physics,
+ * applying forces, and enforcing constraints.
+ *
+ * @public
  */ class JointDynamicsSystemController {
     _config;
     _pointsR = [];
@@ -54565,14 +54565,14 @@ function isBoneFixed(roots, index) {
     constructor(config){
         this._config = config;
     }
-    /**
-   * Initializes the physics system.
-   * @param rootTransform - Root bone transform used to detect root motion.
-   * @param rootPoints - Root nodes of the bone hierarchy. Multiple roots are allowed.
-   * @param pointTransforms - Transform array for all physics points. Order must match `BoneNode.index`.
-   * @param colliders - Collider array (spheres/capsules).
-   * @param grabbers - Grabber array used for interactions such as mouse dragging.
-   * @param flatPlanes - Plane limiters such as the floor to prevent penetration.
+    /**
+   * Initializes the physics system.
+   * @param rootTransform - Root bone transform used to detect root motion.
+   * @param rootPoints - Root nodes of the bone hierarchy. Multiple roots are allowed.
+   * @param pointTransforms - Transform array for all physics points. Order must match `BoneNode.index`.
+   * @param colliders - Collider array (spheres/capsules).
+   * @param grabbers - Grabber array used for interactions such as mouse dragging.
+   * @param flatPlanes - Plane limiters such as the floor to prevent penetration.
    */ initialize(rootTransform, rootPoints, pointTransforms, colliders, grabbers, flatPlanes) {
         this._rootTransform = rootTransform;
         this._pointTransforms = pointTransforms;
@@ -54662,11 +54662,11 @@ function isBoneFixed(roots, index) {
         }
         this._initialized = true;
     }
-    /**
-   * Advances the simulation by one frame.
-   * Internal flow: read current transforms, run Verlet integration and constraint solving,
-   * then write the result back to the transforms.
-   * @param deltaTime - Frame delta time in seconds. Internally subdivided by `subSteps`.
+    /**
+   * Advances the simulation by one frame.
+   * Internal flow: read current transforms, run Verlet integration and constraint solving,
+   * then write the result back to the transforms.
+   * @param deltaTime - Frame delta time in seconds. Internally subdivided by `subSteps`.
    */ step(deltaTime) {
         if (!this._initialized || !this._rootTransform) {
             return;
@@ -54741,10 +54741,10 @@ function isBoneFixed(roots, index) {
         this._previousRootPosition = rootPos;
         this._previousRootRotation = rootRot;
     }
-    /**
-   * Returns the simulated results for all points as world-space positions and rotations.
-   * Usually this does not need to be called manually because `step()` already writes the
-   * output back to the transforms.
+    /**
+   * Returns the simulated results for all points as world-space positions and rotations.
+   * Usually this does not need to be called manually because `step()` already writes the
+   * output back to the transforms.
    */ getResults() {
         const transformRots = this._pointTransforms.map((t)=>t.getWorldRotation());
         const transformLocalRots = this._pointTransforms.map((t)=>t.getLocalRotation());
@@ -54754,10 +54754,10 @@ function isBoneFixed(roots, index) {
                 rotation: o.rotation
             }));
     }
-    /**
-   * Compensates for teleportation by resetting the previous root transform to the current one.
-   * Call this after a character warp or teleport to avoid a large root-motion impulse on the
-   * next simulation step.
+    /**
+   * Compensates for teleportation by resetting the previous root transform to the current one.
+   * Call this after a character warp or teleport to avoid a large root-motion impulse on the
+   * next simulation step.
    */ warp() {
         if (!this._rootTransform) {
             return;
@@ -54765,10 +54765,10 @@ function isBoneFixed(roots, index) {
         this._previousRootPosition = this._rootTransform.getWorldPosition();
         this._previousRootRotation = this._rootTransform.getWorldRotation();
     }
-    /**
-   * Resets all physics state.
-   * Each simulated point is snapped back to the current transform position and grab state
-   * is cleared.
+    /**
+   * Resets all physics state.
+   * Each simulated point is snapped back to the current transform position and grab state
+   * is cleared.
    */ reset() {
         for(let i = 0; i < this._pointsRW.length; i++){
             const pos = this._pointTransforms[i].getWorldPosition();
@@ -54778,10 +54778,10 @@ function isBoneFixed(roots, index) {
         }
         this._fakeWaveCounter = 0;
     }
-    /**
-   * Releases a fixed point so it becomes dynamic, for example when cloth is detached.
-   * The point state is reset to avoid a sudden impulse.
-   * @param index - Point index.
+    /**
+   * Releases a fixed point so it becomes dynamic, for example when cloth is detached.
+   * The point state is reset to avoid a sudden impulse.
+   * @param index - Point index.
    */ releasePoint(index) {
         if (index < 0 || index >= this._pointsR.length) {
             return;
@@ -54792,10 +54792,10 @@ function isBoneFixed(roots, index) {
         this._pointsRW[index].positionPrevious = pos.clone();
         this._pointsRW[index].grabberIndex = -1;
     }
-    /**
-   * Fixes a dynamic point back to the animation pose, for example when an item is reattached.
-   * The point grab state is cleared.
-   * @param index - Point index.
+    /**
+   * Fixes a dynamic point back to the animation pose, for example when an item is reattached.
+   * The point grab state is cleared.
+   * @param index - Point index.
    */ fixPoint(index) {
         if (index < 0 || index >= this._pointsR.length) {
             return;
@@ -54803,9 +54803,9 @@ function isBoneFixed(roots, index) {
         this._pointsR[index].weight = 0;
         this._pointsRW[index].grabberIndex = -1;
     }
-    /**
-   * Returns whether a point is fixed to animation (`weight = 0`).
-   * @param index - Point index.
+    /**
+   * Returns whether a point is fixed to animation (`weight = 0`).
+   * @param index - Point index.
    */ isPointFixed(index) {
         if (index < 0 || index >= this._pointsR.length) {
             return false;
@@ -54815,34 +54815,34 @@ function isBoneFixed(roots, index) {
     /** Gets the total number of physics points. */ get pointCount() {
         return this._pointsR.length;
     }
-    /**
-   * Fades physics in by blending from animation pose to simulation.
-   * `blendRatio` moves from `1` (animation only) to `0` (physics only).
-   * @param seconds - Transition duration in seconds.
+    /**
+   * Fades physics in by blending from animation pose to simulation.
+   * `blendRatio` moves from `1` (animation only) to `0` (physics only).
+   * @param seconds - Transition duration in seconds.
    */ fadeIn(seconds) {
         this._fadeState = 'in';
         this._fadeTimer = 0;
         this._fadeDuration = seconds;
     }
-    /**
-   * Fades physics out by blending from simulation back to animation pose.
-   * `blendRatio` moves from `0` (physics only) to `1` (animation only).
-   * @param seconds - Transition duration in seconds.
+    /**
+   * Fades physics out by blending from simulation back to animation pose.
+   * `blendRatio` moves from `0` (physics only) to `1` (animation only).
+   * @param seconds - Transition duration in seconds.
    */ fadeOut(seconds) {
         this._fadeState = 'out';
         this._fadeTimer = 0;
         this._fadeDuration = seconds;
     }
-    /**
-   * Sets the global wind force vector.
-   * The final wind contribution is still scaled per point by `windForceScale` and mass.
-   * @param wind - Wind vector in world space.
+    /**
+   * Sets the global wind force vector.
+   * The final wind contribution is still scaled per point by `windForceScale` and mass.
+   * @param wind - Wind vector in world space.
    */ setWindForce(wind) {
         this._config.windForce = wind;
     }
-    /**
-   * Enable/disable broad-phase pruning for runtime performance comparison
-   * @param enabled - `true` to enable broad-phase, `false` to disable.
+    /**
+   * Enable/disable broad-phase pruning for runtime performance comparison
+   * @param enabled - `true` to enable broad-phase, `false` to disable.
    */ setBroadPhaseEnabled(enabled) {
         this._config.enableBroadPhase = enabled;
     }
@@ -54852,23 +54852,23 @@ function isBoneFixed(roots, index) {
     set blendRatio(value) {
         this._config.blendRatio = clamp01(value);
     }
-    /**
-   * Pauses or resumes the physics simulation.
-   * While paused, the system still follows root motion but skips force integration and
-   * constraint solving.
-   * @param paused - `true` to pause, `false` to resume.
+    /**
+   * Pauses or resumes the physics simulation.
+   * While paused, the system still follows root motion but skips force integration and
+   * constraint solving.
+   * @param paused - `true` to pause, `false` to resume.
    */ setPaused(paused) {
         this._isPaused = paused;
     }
-    /**
-   * Enable or disable a collider by current array index.
-   * Transform state is still read from the collider's TransformAccess each frame.
-   * Prefer setColliderEnabled(handle, enabled) for runtime-owned colliders.
-   *
-   * @param index - Collider index in the current array. Note that this may change when colliders are added or removed.
-   * @param enabled - `true` to enable the collider, `false` to disable it.
-   *
-   * @returns `true` if the index is valid and the collider was updated, `false` if the index is out of range.
+    /**
+   * Enable or disable a collider by current array index.
+   * Transform state is still read from the collider's TransformAccess each frame.
+   * Prefer setColliderEnabled(handle, enabled) for runtime-owned colliders.
+   *
+   * @param index - Collider index in the current array. Note that this may change when colliders are added or removed.
+   * @param enabled - `true` to enable the collider, `false` to disable it.
+   *
+   * @returns `true` if the index is valid and the collider was updated, `false` if the index is out of range.
    */ setColliderEnabledAt(index, enabled) {
         if (index >= 0 && index < this._collidersRW.length) {
             this._collidersRW[index].enabled = enabled ? 1 : 0;
@@ -54876,12 +54876,12 @@ function isBoneFixed(roots, index) {
         }
         return false;
     }
-    /**
-   * Enable or disable a runtime collider by stable handle.
-   *
-   * @param handle - Stable handle for the collider to enable or disable.
-   * @param enabled - `true` to enable the collider, `false` to disable it.
-   * @returns true if the handle is still valid.
+    /**
+   * Enable or disable a runtime collider by stable handle.
+   *
+   * @param handle - Stable handle for the collider to enable or disable.
+   * @param enabled - `true` to enable the collider, `false` to disable it.
+   * @returns true if the handle is still valid.
    */ setColliderEnabled(handle, enabled) {
         const index = this._getColliderIndex(handle);
         if (index === -1) {
@@ -54889,11 +54889,11 @@ function isBoneFixed(roots, index) {
         }
         return this.setColliderEnabledAt(index, enabled);
     }
-    /**
-   * Add a collider at runtime.
-   * @param r - Read-only collider data such as shape and size.
-   * @param transform - TransformAccess that provides the collider's position and rotation each frame.
-   * @returns A stable handle that remains valid until this collider is removed.
+    /**
+   * Add a collider at runtime.
+   * @param r - Read-only collider data such as shape and size.
+   * @param transform - TransformAccess that provides the collider's position and rotation each frame.
+   * @returns A stable handle that remains valid until this collider is removed.
    */ addCollider(r, transform) {
         const id = this._nextColliderHandleId++;
         this._collidersR.push(r);
@@ -54906,10 +54906,10 @@ function isBoneFixed(roots, index) {
             id
         };
     }
-    /**
-   * Remove a collider by stable handle.
-   * @param handle - Stable handle for the collider to remove.
-   * @returns true if the collider existed and was removed.
+    /**
+   * Remove a collider by stable handle.
+   * @param handle - Stable handle for the collider to remove.
+   * @returns true if the collider existed and was removed.
    */ removeCollider(handle) {
         const index = this._getColliderIndex(handle);
         if (index === -1) {
@@ -54917,10 +54917,10 @@ function isBoneFixed(roots, index) {
         }
         return this.removeColliderAt(index);
     }
-    /**
-   * Remove a collider by current array index.
-   * @param index - Collider index in the current array. Note that this may change when colliders are added or removed.
-   * Prefer removeCollider(handle) for runtime-owned colliders.
+    /**
+   * Remove a collider by current array index.
+   * @param index - Collider index in the current array. Note that this may change when colliders are added or removed.
+   * Prefer removeCollider(handle) for runtime-owned colliders.
    */ removeColliderAt(index) {
         if (index < 0 || index >= this._collidersR.length) {
             return false;
@@ -54932,11 +54932,11 @@ function isBoneFixed(roots, index) {
         this._rebuildColliderHandleMap();
         return true;
     }
-    /**
-   * Enable or disable a flat plane by current array index.
-   * @param index - Flat plane index in the current array. Note that this may change when flat planes are added or removed.
-   * @param enabled - `true` to enable the flat plane, `false` to disable it.
-   * @returns `true` if the index is valid and the flat plane was updated, `false` if the index is out of range.
+    /**
+   * Enable or disable a flat plane by current array index.
+   * @param index - Flat plane index in the current array. Note that this may change when flat planes are added or removed.
+   * @param enabled - `true` to enable the flat plane, `false` to disable it.
+   * @returns `true` if the index is valid and the flat plane was updated, `false` if the index is out of range.
    */ setFlatPlaneEnabledAt(index, enabled) {
         if (index < 0 || index >= this._flatPlaneAll.length) {
             return false;
@@ -54945,11 +54945,11 @@ function isBoneFixed(roots, index) {
         this._rebuildActiveFlatPlanes();
         return true;
     }
-    /**
-   * Enable or disable a runtime flat plane by stable handle.
-   * @param handle - Stable handle for the flat plane to enable or disable.
-   * @param enabled - `true` to enable the flat plane, `false` to disable it.
-   * @returns true if the handle is still valid.
+    /**
+   * Enable or disable a runtime flat plane by stable handle.
+   * @param handle - Stable handle for the flat plane to enable or disable.
+   * @param enabled - `true` to enable the flat plane, `false` to disable it.
+   * @returns true if the handle is still valid.
    */ setFlatPlaneEnabled(handle, enabled) {
         const index = this._getFlatPlaneIndex(handle);
         if (index === -1) {
@@ -54957,11 +54957,11 @@ function isBoneFixed(roots, index) {
         }
         return this.setFlatPlaneEnabledAt(index, enabled);
     }
-    /**
-   * Add a flat plane at runtime.
-   * @param up - Up direction of the plane. The normal is computed as `Vector3.normalize(up)`.
-   * @param position - A point on the plane. The distance is computed as `-Vector3.dot(normal, position)`.
-   * @returns A stable handle that remains valid until this flat plane is removed.
+    /**
+   * Add a flat plane at runtime.
+   * @param up - Up direction of the plane. The normal is computed as `Vector3.normalize(up)`.
+   * @param position - A point on the plane. The distance is computed as `-Vector3.dot(normal, position)`.
+   * @returns A stable handle that remains valid until this flat plane is removed.
    */ addFlatPlane(up, position) {
         const id = this._nextFlatPlaneHandleId++;
         const normal = Vector3.normalize(up);
@@ -54978,10 +54978,10 @@ function isBoneFixed(roots, index) {
             id
         };
     }
-    /**
-   * Remove a flat plane by stable handle.
-   * @param handle - Stable handle for the flat plane to remove.
-   * @returns true if the flat plane existed and was removed.
+    /**
+   * Remove a flat plane by stable handle.
+   * @param handle - Stable handle for the flat plane to remove.
+   * @returns true if the flat plane existed and was removed.
    */ removeFlatPlane(handle) {
         const index = this._getFlatPlaneIndex(handle);
         if (index === -1) {
@@ -54989,10 +54989,10 @@ function isBoneFixed(roots, index) {
         }
         return this.removeFlatPlaneAt(index);
     }
-    /**
-   * Remove a flat plane by current array index.
-   * @param index - Flat plane index in the current array. Note that this may change when flat planes are added or removed.
-   * @returns true if the index was valid and the flat plane was removed, false if the index was out of range.
+    /**
+   * Remove a flat plane by current array index.
+   * @param index - Flat plane index in the current array. Note that this may change when flat planes are added or removed.
+   * @returns true if the index was valid and the flat plane was removed, false if the index was out of range.
    */ removeFlatPlaneAt(index) {
         if (index < 0 || index >= this._flatPlaneAll.length) {
             return false;
@@ -55004,14 +55004,14 @@ function isBoneFixed(roots, index) {
         this._rebuildActiveFlatPlanes();
         return true;
     }
-    /**
-   * Enable or disable a grabber by current array index.
-   * Transform state is still read from the grabber's TransformAccess each frame.
-   * Prefer setGrabberEnabled(handle, enabled) for runtime-owned grabbers.
-   *
-   * @param index - Grabber index in the current array. Note that this may change when grabbers are added or removed.
-   * @param enabled - `true` to enable the grabber, `false` to disable it.
-   * @returns `true` if the index is valid and the grabber was updated, `false` if the index is out of range.
+    /**
+   * Enable or disable a grabber by current array index.
+   * Transform state is still read from the grabber's TransformAccess each frame.
+   * Prefer setGrabberEnabled(handle, enabled) for runtime-owned grabbers.
+   *
+   * @param index - Grabber index in the current array. Note that this may change when grabbers are added or removed.
+   * @param enabled - `true` to enable the grabber, `false` to disable it.
+   * @returns `true` if the index is valid and the grabber was updated, `false` if the index is out of range.
    */ setGrabberEnabledAt(index, enabled) {
         if (index >= 0 && index < this._grabbersRW.length) {
             this._grabbersRW[index].enabled = enabled ? 1 : 0;
@@ -55022,11 +55022,11 @@ function isBoneFixed(roots, index) {
         }
         return false;
     }
-    /**
-   * Enable or disable a runtime grabber by stable handle.
-   * @param handle - Stable handle for the grabber to enable or disable.
-   * @param enabled - `true` to enable the grabber, `false` to disable it.
-   * @returns true if the handle is still valid.
+    /**
+   * Enable or disable a runtime grabber by stable handle.
+   * @param handle - Stable handle for the grabber to enable or disable.
+   * @param enabled - `true` to enable the grabber, `false` to disable it.
+   * @returns true if the handle is still valid.
    */ setGrabberEnabled(handle, enabled) {
         const index = this._getGrabberIndex(handle);
         if (index === -1) {
@@ -55034,12 +55034,12 @@ function isBoneFixed(roots, index) {
         }
         return this.setGrabberEnabledAt(index, enabled);
     }
-    /**
-   * Add a grabber at runtime.
-   * @param r - Read-only grabber data such as interaction radius.
-   * @param transform - TransformAccess that provides the grabber's position each frame.
-   * @param enabled - Whether the grabber starts enabled. The grabber can still be moved by its transform while disabled, but it won't affect any points until enabled.
-   * @returns A stable handle that remains valid until this grabber is removed.
+    /**
+   * Add a grabber at runtime.
+   * @param r - Read-only grabber data such as interaction radius.
+   * @param transform - TransformAccess that provides the grabber's position each frame.
+   * @param enabled - Whether the grabber starts enabled. The grabber can still be moved by its transform while disabled, but it won't affect any points until enabled.
+   * @returns A stable handle that remains valid until this grabber is removed.
    */ addGrabber(r, transform, enabled = false) {
         const id = this._nextGrabberHandleId++;
         this._grabbersR.push(r);
@@ -55055,10 +55055,10 @@ function isBoneFixed(roots, index) {
             id
         };
     }
-    /**
-   * Remove a grabber by stable handle.
-   * @param handle - Stable handle for the grabber to remove.
-   * @returns true if the grabber existed and was removed.
+    /**
+   * Remove a grabber by stable handle.
+   * @param handle - Stable handle for the grabber to remove.
+   * @returns true if the grabber existed and was removed.
    */ removeGrabber(handle) {
         const index = this._getGrabberIndex(handle);
         if (index === -1) {
@@ -55066,12 +55066,12 @@ function isBoneFixed(roots, index) {
         }
         return this.removeGrabberAt(index);
     }
-    /**
-   * Remove a grabber by current array index.
-   * Prefer removeGrabber(handle) for runtime-owned grabbers.
-   *
-   * @param index - Grabber index in the current array. Note that this may change when grabbers are added or removed.
-   * @returns true if the index was valid and the grabber was removed, false if the index was out of range.
+    /**
+   * Remove a grabber by current array index.
+   * Prefer removeGrabber(handle) for runtime-owned grabbers.
+   *
+   * @param index - Grabber index in the current array. Note that this may change when grabbers are added or removed.
+   * @returns true if the index was valid and the grabber was removed, false if the index was out of range.
    */ removeGrabberAt(index) {
         if (index < 0 || index >= this._grabbersR.length) {
             return false;
@@ -73762,11 +73762,11 @@ const MAX_ACCUMULATED_SIMULATION_TIME$1 = 1 / 20;
 const MAX_SIMULATION_STEPS_PER_UPDATE$1 = Math.max(1, Math.ceil(MAX_ACCUMULATED_SIMULATION_TIME$1 / FIXED_SIMULATION_TIME_STEP$1));
 const DEFAULT_PARTICLE_TARGET_SMOOTHING_TIME = 1 / 30;
 const DEFAULT_COLLIDER_SMOOTHING_TIME$1 = 1 / 30;
-/**
- * Physics engine for spring-based particle simulation
- * Uses Verlet integration and iterative constraint solving
- *
- * @public
+/**
+ * Physics engine for spring-based particle simulation
+ * Uses Verlet integration and iterative constraint solving
+ *
+ * @public
  */ class SpringSystem {
     _chain;
     _iterations;
@@ -73812,9 +73812,9 @@ const DEFAULT_COLLIDER_SMOOTHING_TIME$1 = 1 / 30;
         this._smoothedCapsuleEndpoints = new WeakMap();
         this._smoothedPlaneData = new WeakMap();
     }
-    /**
-   * Updates the physics simulation
-   * @param deltaTime - Time step in seconds
+    /**
+   * Updates the physics simulation
+   * @param deltaTime - Time step in seconds
    */ update(deltaTime) {
         const frameDt = Math.min(Math.max(Number(deltaTime) || 0, 0), MAX_ACCUMULATED_SIMULATION_TIME$1);
         if (frameDt <= 0) {
@@ -73891,8 +73891,8 @@ const DEFAULT_COLLIDER_SMOOTHING_TIME$1 = 1 / 30;
             this.solveCollisions(inputDeltaTime);
         }
     }
-    /**
-   * Updates fixed particles to match their scene node positions
+    /**
+   * Updates fixed particles to match their scene node positions
    */ updateFixedParticles(deltaTime) {
         const blend = this.getTemporalBlendFactor(deltaTime, DEFAULT_PARTICLE_TARGET_SMOOTHING_TIME);
         for (const particle of this._chain.particles){
@@ -73920,9 +73920,9 @@ const DEFAULT_COLLIDER_SMOOTHING_TIME$1 = 1 / 30;
             }
         }
     }
-    /**
-   * Solves pose preservation (long-range attachment to animated pose).
-   * This keeps strands close to authored shape while preserving dynamic movement.
+    /**
+   * Solves pose preservation (long-range attachment to animated pose).
+   * This keeps strands close to authored shape while preserving dynamic movement.
    */ solvePosePreservation(totalIterations) {
         if (this._poseFollowRoot <= 0 && this._poseFollowTip <= 0) {
             return;
@@ -73955,9 +73955,9 @@ const DEFAULT_COLLIDER_SMOOTHING_TIME$1 = 1 / 30;
     lerp(a, b, t) {
         return a + (b - a) * t;
     }
-    /**
-   * Calculates global rotation parameters from fixed particle movements
-   * Uses position history to estimate rotation center
+    /**
+   * Calculates global rotation parameters from fixed particle movements
+   * Uses position history to estimate rotation center
    */ calculateGlobalRotation(dt) {
         // Collect fixed particles with movement
         const fixedParticles = [];
@@ -74015,9 +74015,9 @@ const DEFAULT_COLLIDER_SMOOTHING_TIME$1 = 1 / 30;
             omega: sumOmega
         };
     }
-    /**
-   * Estimates rotation center from a single particle's position history
-   * Uses circular motion fitting
+    /**
+   * Estimates rotation center from a single particle's position history
+   * Uses circular motion fitting
    */ estimateRotationCenterFromHistory(particle, currentVelocity) {
         const history = particle.positionHistory;
         if (!history || history.length < 3) {
@@ -74053,9 +74053,9 @@ const DEFAULT_COLLIDER_SMOOTHING_TIME$1 = 1 / 30;
         const center = this.calculateCircleCenter(p1, p2, p3);
         return center;
     }
-    /**
-   * Calculates the center of a circle passing through 3 points
-   * Uses perpendicular bisector method
+    /**
+   * Calculates the center of a circle passing through 3 points
+   * Uses perpendicular bisector method
    */ calculateCircleCenter(p1, p2, p3) {
         // Midpoints
         const mid12 = Vector3.scale(Vector3.add(p1, p2, new Vector3()), 0.5, new Vector3());
@@ -74092,8 +74092,8 @@ const DEFAULT_COLLIDER_SMOOTHING_TIME$1 = 1 / 30;
         // Fallback: use centroid
         return Vector3.scale(Vector3.add(Vector3.add(p1, p2, new Vector3()), p3, new Vector3()), 1.0 / 3.0, new Vector3());
     }
-    /**
-   * Calculates inertial acceleration for a particle in a rotating reference frame
+    /**
+   * Calculates inertial acceleration for a particle in a rotating reference frame
    */ calculateInertialAcceleration(particle, rotationCenter, angularVelocity, particleVelocity, centrifugalScale, coriolisScale) {
         // Vector from rotation center to particle
         const r = Vector3.sub(particle.position, rotationCenter, new Vector3());
@@ -74110,10 +74110,10 @@ const DEFAULT_COLLIDER_SMOOTHING_TIME$1 = 1 / 30;
         const totalAccel = Vector3.add(centrifugalAccel, coriolisAccel, new Vector3());
         return totalAccel;
     }
-    /**
-   * Solves a single spring constraint using XPBD (Extended Position-Based Dynamics).
-   *
-   * Reference: Müller et al., "Detailed Rigid Body Simulation with Extended Position Based Dynamics", 2020.
+    /**
+   * Solves a single spring constraint using XPBD (Extended Position-Based Dynamics).
+   *
+   * Reference: Müller et al., "Detailed Rigid Body Simulation with Extended Position Based Dynamics", 2020.
    */ solveConstraintXPBD(constraint, dt) {
         const pA = this._chain.particles[constraint.particleA];
         const pB = this._chain.particles[constraint.particleB];
@@ -74146,8 +74146,8 @@ const DEFAULT_COLLIDER_SMOOTHING_TIME$1 = 1 / 30;
             Vector3.add(pB.position, Vector3.scale(n, wB * deltaLambda, new Vector3()), pB.position);
         }
     }
-    /**
-   * Solves a single spring constraint (Verlet / PBD)
+    /**
+   * Solves a single spring constraint (Verlet / PBD)
    */ solveConstraint(constraint) {
         const pA = this._chain.particles[constraint.particleA];
         const pB = this._chain.particles[constraint.particleB];
@@ -74168,8 +74168,8 @@ const DEFAULT_COLLIDER_SMOOTHING_TIME$1 = 1 / 30;
             Vector3.sub(pB.position, correction, pB.position);
         }
     }
-    /**
-   * Solves collisions for all particles
+    /**
+   * Solves collisions for all particles
    */ solveCollisions(deltaTime) {
         // Update dynamic colliders from their nodes
         const blend = this.getTemporalBlendFactor(deltaTime, DEFAULT_COLLIDER_SMOOTHING_TIME$1);
@@ -74242,9 +74242,9 @@ const DEFAULT_COLLIDER_SMOOTHING_TIME$1 = 1 / 30;
             }
         }
     }
-    /**
-   * Applies simulation results to scene nodes
-   * @param weight - Blend weight [0-1] (default: 1.0)
+    /**
+   * Applies simulation results to scene nodes
+   * @param weight - Blend weight [0-1] (default: 1.0)
    */ applyToNodes(weight = 1.0) {
         for(let i = 0; i < this._chain.particles.length - 1; i++){
             const particle = this._chain.particles[i];
@@ -74292,8 +74292,8 @@ const DEFAULT_COLLIDER_SMOOTHING_TIME$1 = 1 / 30;
             }
         }
     }
-    /**
-   * Resets the simulation to initial state
+    /**
+   * Resets the simulation to initial state
    */ reset() {
         this._chain.reset();
         for (const particle of this._chain.particles){
@@ -74309,61 +74309,61 @@ const DEFAULT_COLLIDER_SMOOTHING_TIME$1 = 1 / 30;
         this._smoothedCapsuleEndpoints = new WeakMap();
         this._smoothedPlaneData = new WeakMap();
     }
-    /**
-   * Gets the spring chain
+    /**
+   * Gets the spring chain
    */ get chain() {
         return this._chain;
     }
-    /**
-   * Gets the current gravity
+    /**
+   * Gets the current gravity
    */ get gravity() {
         return this._gravity;
     }
     set gravity(gravity) {
         this._gravity.set(gravity);
     }
-    /**
-   * Gets the current wind
+    /**
+   * Gets the current wind
    */ get wind() {
         return this._wind;
     }
     set wind(wind) {
         this._wind.set(wind);
     }
-    /**
-   * Gets the number of iterations
+    /**
+   * Gets the number of iterations
    */ get iterations() {
         return this._iterations;
     }
     set iterations(count) {
         this._iterations = Math.max(1, count);
     }
-    /**
-   * Gets whether inertial forces are enabled
+    /**
+   * Gets whether inertial forces are enabled
    */ get enableInertialForces() {
         return this._enableInertialForces;
     }
     set enableInertialForces(enabled) {
         this._enableInertialForces = enabled;
     }
-    /**
-   * Gets the centrifugal force scale
+    /**
+   * Gets the centrifugal force scale
    */ get centrifugalScale() {
         return this._centrifugalScale;
     }
     set centrifugalScale(scale) {
         this._centrifugalScale = Math.max(0, scale);
     }
-    /**
-   * Gets the Coriolis force scale
+    /**
+   * Gets the Coriolis force scale
    */ get coriolisScale() {
         return this._coriolisScale;
     }
     set coriolisScale(scale) {
         this._coriolisScale = Math.max(0, scale);
     }
-    /**
-   * Gets the constraint solver type
+    /**
+   * Gets the constraint solver type
    */ get solver() {
         return this._solver;
     }
@@ -74377,8 +74377,8 @@ const DEFAULT_COLLIDER_SMOOTHING_TIME$1 = 1 / 30;
             }
         }
     }
-    /**
-   * Gets pose preservation strength [0-1]
+    /**
+   * Gets pose preservation strength [0-1]
    */ get poseFollow() {
         return this._poseFollow;
     }
@@ -74388,8 +74388,8 @@ const DEFAULT_COLLIDER_SMOOTHING_TIME$1 = 1 / 30;
         this._poseFollowRoot = v;
         this._poseFollowTip = v;
     }
-    /**
-   * Gets max allowed deviation from animated pose
+    /**
+   * Gets max allowed deviation from animated pose
    */ get maxPoseOffset() {
         return this._maxPoseOffset;
     }
@@ -74399,56 +74399,56 @@ const DEFAULT_COLLIDER_SMOOTHING_TIME$1 = 1 / 30;
         this._maxPoseOffsetRoot = v;
         this._maxPoseOffsetTip = v;
     }
-    /**
-   * Gets root pose follow strength [0-1]
+    /**
+   * Gets root pose follow strength [0-1]
    */ get poseFollowRoot() {
         return this._poseFollowRoot;
     }
     set poseFollowRoot(value) {
         this._poseFollowRoot = Math.max(0, Math.min(1, value));
     }
-    /**
-   * Gets tip pose follow strength [0-1]
+    /**
+   * Gets tip pose follow strength [0-1]
    */ get poseFollowTip() {
         return this._poseFollowTip;
     }
     set poseFollowTip(value) {
         this._poseFollowTip = Math.max(0, Math.min(1, value));
     }
-    /**
-   * Gets exponent for root-to-tip interpolation
+    /**
+   * Gets exponent for root-to-tip interpolation
    */ get poseFollowExponent() {
         return this._poseFollowExponent;
     }
     set poseFollowExponent(value) {
         this._poseFollowExponent = Math.max(0.1, value);
     }
-    /**
-   * Gets root max allowed deviation from animated pose
+    /**
+   * Gets root max allowed deviation from animated pose
    */ get maxPoseOffsetRoot() {
         return this._maxPoseOffsetRoot;
     }
     set maxPoseOffsetRoot(value) {
         this._maxPoseOffsetRoot = Math.max(0, value);
     }
-    /**
-   * Gets tip max allowed deviation from animated pose
+    /**
+   * Gets tip max allowed deviation from animated pose
    */ get maxPoseOffsetTip() {
         return this._maxPoseOffsetTip;
     }
     set maxPoseOffsetTip(value) {
         this._maxPoseOffsetTip = Math.max(0, value);
     }
-    /**
-   * Adds a collider to the system
+    /**
+   * Adds a collider to the system
    */ addCollider(collider) {
         this._colliders.push(collider);
         this._smoothedSphereCenters = new WeakMap();
         this._smoothedCapsuleEndpoints = new WeakMap();
         this._smoothedPlaneData = new WeakMap();
     }
-    /**
-   * Removes a collider from the system
+    /**
+   * Removes a collider from the system
    */ removeCollider(collider) {
         const index = this._colliders.indexOf(collider);
         if (index >= 0) {
@@ -74460,16 +74460,16 @@ const DEFAULT_COLLIDER_SMOOTHING_TIME$1 = 1 / 30;
         }
         return false;
     }
-    /**
-   * Clears all colliders
+    /**
+   * Clears all colliders
    */ clearColliders() {
         this._colliders = [];
         this._smoothedSphereCenters = new WeakMap();
         this._smoothedCapsuleEndpoints = new WeakMap();
         this._smoothedPlaneData = new WeakMap();
     }
-    /**
-   * Gets all colliders
+    /**
+   * Gets all colliders
    */ get colliders() {
         return this._colliders;
     }