@needle-tools/engine 5.1.0-alpha.8 → 5.1.0-beta

package/dist/needle-engine.d.ts

@@ -75,6 +75,7 @@ import { Pass } from 'postprocessing';
 import { peerjs } from 'peerjs';
 import { PeerJSOption } from 'peerjs';
 import { PerspectiveCamera } from 'three';
+import { Plane } from 'three';
 import { PositionalAudio } from 'three';
 import { postprocessing } from 'postprocessing';
 import { Particle as QParticle } from 'three.quarks';
@@ -117,11 +118,11 @@ import { XRHandSpace } from 'three';
 
 export declare const $componentName: unique symbol;
 
-export declare const $physicsKey: unique symbol;
+/* Excluded from this release type: $fwGZrGe */
 
-/* Excluded from this release type: _$QyV */
+export declare const $physicsKey: unique symbol;
 
-/* Excluded from this release type: __Carg */
+/* Excluded from this release type: _$qWUhYZU */
 
 export declare class __Ignore {
 }
@@ -1980,11 +1981,18 @@ export declare class AudioSource extends Component {
     private sound;
     private helper;
     private wasPlaying;
-    private audioLoader;
     private shouldPlay;
-    private _lastClipStartedLoading;
     private _loadedClip;
     private _audioElement;
+    /**
+     * True when {@link _audioElement} is a file-URL element routed through
+     * `sound.setMediaElementSource()` (the iOS-survivable string-clip path). For this path ALL
+     * playback control (play/pause/stop/loop/pitch/time/isPlaying) goes through the element,
+     * because three.js sets `hasPlaybackControl = false` once a media source is attached.
+     * It is `false` for the distinct MediaStream path (which uses an element with `srcObject`
+     * plus `setMediaStreamSource()` and is controlled differently).
+     */
+    private _usesMediaElementSource;
     private _entryNode;
     private _spatialGain;
     private _bypassGain;
@@ -2008,11 +2016,39 @@ export declare class AudioSource extends Component {
      * @returns The {@link AudioContext} or null if not available
      */
     get audioContext(): AudioContext | undefined;
+    /**
+     * Resumes the shared AudioContext if it is currently suspended/interrupted and the
+     * page is visible. Uses the same policy as the global resume handler so this never
+     * triggers the iOS `InvalidStateError: Failed to start the audio device` (which
+     * happens when resuming while the page is hidden). No-op when the context is already
+     * running or when resuming is not currently allowed.
+     */
+    private ensureContextResumed;
     /* Excluded from this release type: awake */
     /* Excluded from this release type: onEnable */
     /* Excluded from this release type: onDisable */
     private onVisibilityChanged;
     private onApplicationMuteChanged;
+    /**
+     * Sets up playback of a string (file URL) clip through an `HTMLAudioElement` routed into the
+     * Web Audio graph via `sound.setMediaElementSource()`.
+     *
+     * Why a media element instead of a decoded `AudioBuffer`: on iOS Safari an
+     * `AudioBufferSourceNode` has its output torn down after a device lock / audio-session
+     * interruption and cannot be reliably revived. A `MediaElementAudioSourceNode` survives the
+     * lock because the playing `<audio>` element keeps iOS's media session alive, so the shared
+     * AudioContext is never torn down and resumes cleanly. This is the same approach three.js's own
+     * `webaudio_orientation` example uses.
+     *
+     * This does NOT start playback — it only creates/wires the element so a later `.play()` (driven
+     * by a user gesture) is cheap.
+     */
+    private createAudioFromElement;
+    /**
+     * Sets up the {@link PositionalAudio} graph for a MediaStream clip (used for the MediaStream
+     * path only — string clips go through {@link createAudioFromElement}). The actual stream node
+     * is attached in {@link play} via `setMediaStreamSource`.
+     */
     private createAudio;
     private __onAllowAudioCallback;
     /**
@@ -2034,6 +2070,15 @@ export declare class AudioSource extends Component {
      * @returns A promise that resolves when playback starts successfully, or rejects on error
      */
     play(clip?: string | MediaStream | undefined): Promise<boolean>;
+    /**
+     * Smoothly ramp the spatial-graph entry-gain node to `target` (1 = audible, 0 = silent) over a
+     * few ms. A short *fade* — not a hard 0/1 gain change and not a connect/disconnect — is what
+     * avoids the click on pause/resume (an instant change or a graph (dis)connect steps the waveform
+     * → audible click). On iOS the MediaElementAudioSourceNode keeps feeding the graph after
+     * element.pause() following an interruption, so fading this gain to 0 is what actually silences a
+     * "paused" media clip; element.pause() only freezes its playback position.
+     */
+    private fadeEntryGain;
     /**
      * Pauses audio playback while maintaining the current position.
      * Use play() to resume from the paused position.
@@ -2217,6 +2262,24 @@ declare enum Axis {
     Vertical = "y"
 }
 
+/**
+ * Constrains a dragged object to rotate only around a fixed world-space axis.
+ * Uses swing-twist decomposition to extract only the twist component around
+ * the given axis from the delta rotation since drag start, discarding any
+ * perpendicular swing that would tilt the object.
+ *
+ * This is the correct constraint for XZ-plane dragging when the parent is
+ * rotated — it restricts the object to yaw around the plane normal regardless
+ * of how the plane is oriented in world space.
+ */
+export declare class AxisRotationConstraint implements IDragConstraint {
+    private readonly _startQuat;
+    private readonly _axis;
+    constructor(axis: Vector3);
+    init(ctx: IDragConstraintContext): void;
+    apply(followObject: GameObject): void;
+}
+
 declare type BalloonOptions = {
     type: LogType;
     /**
@@ -2466,8 +2529,6 @@ export declare class BloomEffect extends PostProcessingEffect {
     onCreateEffect(): BloomEffect_2;
 }
 
-/* Excluded from this release type: bLW */
-
 /**
  * BoxCollider represents a box-shaped (cuboid) collision volume.
  * Most common collider type, efficient for walls, floors, crates, and rectangular objects.
@@ -5989,7 +6050,7 @@ export declare enum DragMode {
  * All properties are lazy getters over the flat serialized fields on the owning `DragControls`,
  * so runtime writes to those fields are reflected immediately without any extra bookkeeping.
  */
-declare class DragProfile {
+export declare class DragProfile {
     private readonly _dc;
     private readonly _xr;
     /* Excluded from this release type: __constructor */
@@ -7007,6 +7068,33 @@ export declare class FixedJoint extends Joint {
     protected createJoint(self: Rigidbody, other: Rigidbody): any;
 }
 
+/**
+ * Freezes individual rotation axes (X, Y, and/or Z) of the dragged object.
+ * The locked axis values are captured once at construction time and restored every frame.
+ *
+ * Set {@link useLocalSpace} to `true` to lock axes in the object's local space;
+ * leave it `false` (default) to lock axes in world space.
+ *
+ * @example Lock Y-axis rotation in world space:
+ * ```ts
+ * const c = new FixedRotationAxesConstraint(RotationAxis.Y, false);
+ * // init is called automatically by DragControls, or call manually: c.init(ctx);
+ * ```
+ */
+export declare class FixedRotationAxesConstraint implements IDragConstraint {
+    frozenAxes: RotationAxis;
+    useLocalSpace: boolean;
+    private readonly _startEuler;
+    private readonly _eulerCache;
+    /**
+     * @param frozenAxes       Bitfield of {@link RotationAxis} values indicating which axes to lock.
+     * @param useLocalSpace    When `true`, axes are locked in the object's local space; otherwise world space.
+     */
+    constructor(frozenAxes: RotationAxis, useLocalSpace?: boolean);
+    init(ctx: IDragConstraintContext): void;
+    apply(followObject: GameObject): void;
+}
+
 declare type FocusRect = DOMRect | Element | {
     x: number;
     y: number;
@@ -7917,6 +8005,22 @@ export declare class GltfExportBox extends BoxHelperComponent {
     sceneRoot?: Object3D;
 }
 
+/** Projects the grabbed attachment point back onto a plane after position is resolved,
+ *  with optional grid snapping on that plane.
+ *  Owned by the strategy that requires plane-clamping (e.g. {@link XZPlaneDragStrategy}). */
+export declare class GrabPointPlaneConstraint implements IDragConstraint {
+    /** Plane to project the grabbed point onto. Typically the strategy's fixed drag plane. */
+    readonly plane: Plane;
+    /** Attachment point in dragged-object local space. Set once at drag start; the handler
+     *  mutates this Vector3 in-place so updates are reflected automatically. */
+    hitPointInLocalSpace: Vector3 | null;
+    /** Grid snap resolution on the plane. 0 = projection only, no snapping. */
+    snapResolution: number;
+    constructor(plane: Plane);
+    init(ctx: IDragConstraintContext): void;
+    apply(followObject: GameObject): void;
+}
+
 export declare class Gradient {
     alphaKeys: Array<AlphaKey>;
     colorKeys: Array<ColorKey>;
@@ -8078,6 +8182,15 @@ export declare class GridLayoutGroup extends LayoutGroup {
     protected onCalculateLayout(): void;
 }
 
+/** Snaps the follow object's world position to a uniform grid. Resolution ≤ 0 is a no-op.
+ *  For XZ-plane mode, use {@link GrabPointPlaneConstraint} instead (it handles both
+ *  plane-clamping and optional grid-snapping on the plane). */
+export declare class GridSnapConstraint implements IDragConstraint {
+    snapGridResolution: number;
+    constructor(snapGridResolution: number);
+    apply(followObject: GameObject): void;
+}
+
 /**
  * The [GroundProjectedEnv](https://engine.needle.tools/docs/api/GroundProjectedEnv) projects the environment map onto a virtual ground plane.
  * Creates a realistic floor from 360° panoramas/HDRIs by deforming the skybox
@@ -8632,6 +8745,47 @@ export declare interface IDisposable {
     dispose(): void;
 }
 
+/**
+ * Contract for drag constraints applied after a follow object's position is resolved each frame.
+ * Implement this interface to add custom position/rotation/scale restrictions.
+ */
+declare interface IDragConstraint {
+    /**
+     * Called once at drag start and again whenever the drag context resets
+     * (e.g. multi-touch → single-pointer transition). Capture any object snapshot
+     * (position, rotation, scale) you need to hold fixed during the drag.
+     * Constraints that need no dynamic initialization may omit this method.
+     */
+    init?(context: IDragConstraintContext): void;
+    /** Modifies followObject in-place. Invoked after position is resolved each frame. */
+    apply(followObject: GameObject): void;
+}
+
+/**
+ * Context passed to {@link IDragConstraint.init} at drag start and whenever the drag context
+ * resets (e.g. transitioning from multi-touch back to single-pointer).
+ * Provides a snapshot of the dragged object and attachment data a constraint needs
+ * to initialize or re-initialize its locked reference values.
+ */
+declare interface IDragConstraintContext {
+    /** The object being dragged. Cast to IGameObject for world-space properties. */
+    readonly gameObject: Object3D;
+    /** Drag attachment point in the dragged object's local space. */
+    readonly hitPointInLocalSpace: Vector3;
+    /** Surface normal at drag attachment in the dragged object's local space. */
+    readonly hitNormalInLocalSpace: Vector3;
+    /**
+     * Local-space bounding box at scale=1. Non-null only for multi-touch drags
+     * where scale-aware constraints (e.g. keeping the bounds bottom grounded) are needed.
+     */
+    readonly boundsAtScaleOne: Box3 | null;
+    /**
+     * World scale of the object captured at the start of the current drag phase.
+     * Non-null alongside boundsAtScaleOne for multi-touch; null for single-pointer.
+     */
+    readonly initialWorldScale: Vector3 | null;
+}
+
 /** Implement to receive callbacks from {@type @needle-tools/editor-sync} package */
 declare interface IEditorModification {
     /**
@@ -10365,6 +10519,20 @@ declare abstract class Joint extends Component {
     protected abstract createJoint(self: Rigidbody, other: Rigidbody): any;
 }
 
+/** Locks the follow object's world rotation to the quaternion captured at drag-start. */
+export declare class KeepRotationConstraint implements IDragConstraint {
+    private readonly _savedQuat;
+    init(ctx: IDragConstraintContext): void;
+    apply(followObject: GameObject): void;
+}
+
+/** Locks the follow object's world scale to the value captured at drag-start. */
+export declare class KeepScaleConstraint implements IDragConstraint {
+    private readonly _savedScale;
+    init(ctx: IDragConstraintContext): void;
+    apply(followObject: GameObject): void;
+}
+
 declare const enum KeyboardEnumType {
     KeyDown = "keydown",
     KeyUp = "keyup",
@@ -11006,7 +11174,7 @@ declare class LowPassFilter {
     setAlpha(alpha: number): void;
     filter(value: number, alpha: number): number;
     lastValue(): number | null;
-    reset(value: number): void;
+    reset(value?: number): void;
 }
 
 declare type MagicSkyboxName = "studio" | "blurred-skybox" | "quicklook-ar" | "quicklook";
@@ -15337,6 +15505,24 @@ export declare class OrbitControls extends Component implements ICameraControlle
          bounds: Box3;
      };
 
+     /** Locks the follow object's signed distance from a plane to a value set at drag start.
+      *  Owned by {@link XZPlaneDragStrategy} to prevent slow Y drift in the side-view fallback path.
+      *  Immune to grab-point projection errors, stale matrixWorld, and epsilon guards.
+      *
+      *  When {@link boundsBottomSignedDistFromPivot} is non-zero (set by {@link MultiTouchDragHandler}
+      *  for XZPlane scaling), the effective locked height is shifted each frame so the **bottom of the
+      *  object's bounds** stays at the height captured at drag start instead of the pivot. */
+     export declare class PlaneHeightLockConstraint implements IDragConstraint {
+         private readonly plane;
+         private _lockedHeight;
+         private _boundsBottomSignedDistFromPivot;
+         /** Current pinch-scale ratio, updated each frame by {@link MultiTouchDragHandler}. */
+         currentScaleRatio: number;
+         constructor(plane: Plane);
+         init(ctx: IDragConstraintContext): void;
+         apply(followObject: GameObject): void;
+     }
+
      /**
       * PlayableDirector is the main component for controlling timelines in Needle Engine.
       * It orchestrates playback of TimelineAssets containing animation, audio, signal,
@@ -16422,11 +16608,14 @@ export declare class OrbitControls extends Component implements ICameraControlle
           * Progress.end("export-usdz");
           *
           * // Auto step with weights:
+          * // A numeric weight applies to the NEXT step — it sets how many steps the
+          * // following auto-step advances. The call it is passed on advances by the
+          * // previously-set weight (1 by default).
           * Progress.start("export-usdz", undefined, (progress) => console.log("Progress: " + progress));
-          * Progress.report("export-usdz", { message: "Exporting objects", autoStep: true, totalSteps: 10 });
-          * Progress.report("export-usdz", { message: "Exporting object 1", autoStep: 8 }); // will advance to 80% progress
-          * Progress.report("export-usdz", "Exporting object 2"); // 90%
-          * Progress.report("export-usdz", "Exporting object 3"); // 100%
+          * Progress.report("export-usdz", { message: "Exporting objects", autoStep: true, totalSteps: 10 }); // step 1/10 (10%)
+          * Progress.report("export-usdz", { message: "Heavy step", autoStep: 8 });                           // step 2/10 (20%); weight 8 applies to the next step
+          * Progress.report("export-usdz", "Exporting object 2");                                              // advances by 8 -> step 10/10 (100%)
+          * Progress.report("export-usdz", "Exporting object 3");                                              // stays at 100%
           *
           * // Child scopes:
           * Progress.start("export-usdz", undefined, (progress) => console.log("Progress: " + progress));
@@ -16458,8 +16647,9 @@ export declare class OrbitControls extends Component implements ICameraControlle
           * Progress.report("export-usdz", { totalSteps: 20, autoStep: true });
           * // show the progress as 50%
           * Progress.report("export-usdz", { progress: 0.5 });
-          * // give this step a weight of 20, which changes how progress is calculated. Useful for steps that take longer and/or have child scopes.
-          * Progress.report("export-usdz", { message. "Long process", autoStep: 20 });
+          * // give a weight of 20 to the NEXT step (useful for steps that take longer
+          * // and/or have child scopes); the following auto-step will advance by 20.
+          * Progress.report("export-usdz", { message: "Long process", autoStep: 20 });
           * // show the current step and total steps and implicitly calculate progress as 10%
           * Progress.report("export-usdz", { currentStep: 1, totalSteps: 10 });
           */
@@ -17043,7 +17233,7 @@ export declare class OrbitControls extends Component implements ICameraControlle
          unapply(obj: Object3D): void;
      }
 
-     declare enum ReflectionProbeUsage {
+     export declare enum ReflectionProbeUsage {
          Off = 0,
          BlendProbes = 1,
          BlendProbesAndSkybox = 2,
@@ -17815,6 +18005,17 @@ export declare class OrbitControls extends Component implements ICameraControlle
          RoomStateSent = "room-state-sent"
      }
 
+     /**
+      * Flags controlling which rotation axes are frozen by {@link FixedRotationAxesConstraint}.
+      * Values can be combined with the bitwise OR operator (`|`).
+      * @example Freeze X and Z: `RotationAxis.X | RotationAxis.Z`
+      */
+     declare enum RotationAxis {
+         X = 1,
+         Y = 2,
+         Z = 4
+     }
+
      export declare class RotationBySpeedModule {
          enabled: boolean;
          range: Vec2;
@@ -17872,6 +18073,22 @@ export declare class OrbitControls extends Component implements ICameraControlle
       */
      declare type ScaleClipType = "linear" | "spring";
 
+     export declare class ScaleLimitConstraint implements IDragConstraint {
+         min: number;
+         max: number;
+         relativeToInitialScale: boolean;
+         /**
+          * @param min                    Lower bound. Relative mode: fraction of initial scale. Raw mode: absolute world-scale per axis.
+          * @param max                    Upper bound. Relative mode: fraction of initial scale. Raw mode: absolute world-scale per axis.
+          * @param relativeToInitialScale When `true`, clamp is relative to `initialWorldScale`. When `false`, each axis is clamped independently.
+          * @param initialWorldScale      Reference to the object's world scale captured at drag start. Required for relative mode.
+          */
+         private readonly _initialWorldScale;
+         constructor(min: number, max: number, relativeToInitialScale?: boolean);
+         init(ctx: IDragConstraintContext): void;
+         apply(followObject: GameObject): void;
+     }
+
      export { SceneData }
 
      export declare class SceneLightSettings extends Component {
@@ -18103,6 +18320,8 @@ export declare class OrbitControls extends Component implements ICameraControlle
          switchScene(scene: AssetReference): Promise<boolean>;
          private __unloadCurrentScene;
          private _currentlyLoadingScene?;
+         private _loadingRequestId;
+         private _activeLoadingRequestId;
          /* Excluded from this release type: __internalSwitchScene */
          preload(index: number): Promise<boolean> | Promise<ArrayBufferLike | null>;
          private tryLoadFromQueryParam;
@@ -18758,6 +18977,22 @@ export declare class OrbitControls extends Component implements ICameraControlle
           */
          htmlSelector: string | null;
          mode: "window";
+         /**
+          * Read the scroll position from the **top-level window** instead of the window Needle Engine
+          * runs in. This matters when the canvas is embedded in an iframe:
+          * - When the page is **not** embedded this has no effect — the top window *is* the current window.
+          * - When embedded in a **same-origin** iframe, the component follows the *host page's* scroll,
+          *   which is almost always the intent (an embedded iframe usually isn't scrollable itself).
+          *
+          * Set this to `false` to always follow the engine's own window scroll, e.g. when the iframe
+          * itself is scrollable and you want to follow its own scroll rather than the host's.
+          *
+          * If the top window is **cross-origin** (and therefore inaccessible), the component
+          * transparently falls back to the local window and logs a warning in development —
+          * cross-origin embeds would require a `postMessage` scroll bridge from the host page.
+          * @default true
+          */
+         useTopWindowScroll: boolean;
          /**
           * Event fired when the scroll position changes
           */
@@ -18771,9 +19006,25 @@ export declare class OrbitControls extends Component implements ICameraControlle
          private _appliedValue;
          private _needsUpdate;
          private _firstUpdate;
+         /** The window whose scroll position currently drives this component (resolved from {@link useTopWindowScroll}). */
+         private _scrollWindow;
+         /** The window the `wheel` listener is attached to — kept so we remove it from the same window. */
+         private _wheelTarget;
+         private _crossOriginWarned;
+         private _viewTimelineWarned;
          awake(): void;
          /* Excluded from this release type: onEnable */
          /* Excluded from this release type: onDisable */
+         /* Excluded from this release type: onValidate */
+         /**
+          * Resolves which browsing context's scroll position should drive this component.
+          * Honors {@link useTopWindowScroll}. When the top window is requested but is cross-origin
+          * (and therefore inaccessible) it falls back to the local window and warns once —
+          * cross-origin embeds would need a `postMessage` scroll bridge from the host page.
+          */
+         private resolveScrollWindow;
+         /** (Re)resolves the scroll window and moves the `wheel` listener onto it. */
+         private rebindScrollListener;
          /* Excluded from this release type: lateUpdate */
          private _lastSelectorValue;
          private _lastSelectorElement;
@@ -18923,13 +19174,42 @@ export declare class OrbitControls extends Component implements ICameraControlle
           *
           */
          autoUpdate: boolean;
+         /**
+          * The alpha (opacity) the object is currently faded to, in the `[0, 1]` range.
+          * `1` means fully visible, `0` means fully hidden. This is the live, animated value
+          * (it lerps toward the target over {@link fadeDuration}), updated every frame the fade runs.
+          *
+          * External components can read this to react to the see-through state — e.g. toggling a
+          * collider, muting audio, or driving a UI prompt as the object fades in or out.
+          *
+          * @example React to the object becoming (almost) hidden
+          * ```ts
+          * if (seeThrough.currentAlpha < 0.1) {
+          *   // object is essentially see-through now
+          * }
+          * ```
+          * @default 1
+          */
+         get currentAlpha(): number;
+         /**
+          * Below this alpha the object stops casting a shadow. The shadow map only stores depth, so a
+          * faded object would otherwise keep casting a fully solid shadow (three.js does not fade shadows
+          * by opacity). Toggling shadow casting off near-invisible is the cleanest fix; we drive it via
+          * the {@link Renderer.shadowCastingMode} so it cooperates with the per-frame shadow settings the
+          * Renderer re-applies. Note this is a hard on/off, not a fade.
+          */
+         static readonly shadowHideThreshold = 0.05;
          private readonly _referencePointVector;
          private readonly _referencePointDir;
          private _distance;
          private _renderer;
          private _needsUpdate;
          private _id;
+         private _currentAlpha;
+         /** Renderers whose shadow casting we turned off while hidden, mapped to their original mode for restore. */
+         private readonly _suppressedShadowCasting;
          /* Excluded from this release type: onEnable */
+         /* Excluded from this release type: onDestroy */
          /* Excluded from this release type: update */
          private updateDirection;
          /**
@@ -18938,6 +19218,15 @@ export declare class OrbitControls extends Component implements ICameraControlle
           * @param duration Duration in seconds to reach the target alpha. 0 means immediate. Default is the component's fadeDuration.
           */
          updateAlpha(targetAlpha: number, duration?: number): void;
+         /**
+          * Suppress or restore a renderer's shadow casting based on its current alpha.
+          * Driving {@link Renderer.shadowCastingMode} (rather than the raw `mesh.castShadow`) is required
+          * because the Renderer re-applies that setting every frame; we remember the original mode so it
+          * is restored exactly when the object fades back in.
+          */
+         private updateShadowCasting;
+         /** Restore every renderer we suppressed shadow casting on, then clear the bookkeeping. */
+         private restoreSuppressedShadowCasting;
      }
 
      export declare function sendDestroyed(guid: string, con: INetworkConnection, opts?: SyncDestroyOptions): void;
@@ -19156,7 +19445,7 @@ export declare class OrbitControls extends Component implements ICameraControlle
 
      export declare function setWorldScale(obj: Object3D, vec: Vector3): void;
 
-     declare enum ShadowCastingMode {
+     export declare enum ShadowCastingMode {
          Off = 0,
          On = 1,
          TwoSided = 2,
@@ -19590,6 +19879,28 @@ export declare class OrbitControls extends Component implements ICameraControlle
          updateNow(hard: boolean): void;
      }
 
+     /**
+      * Used by {@link SnapToSurfacesDragStrategy} for two-pointer (multi-touch) drags.
+      * Casts a downward ray each frame from the follow object's world position and adjusts
+      * it so the dragged object's bounding-box contact face rests on the detected surface.
+      *
+      * Only injected into the constraint pipeline for multi-touch; the single-pointer path
+      * continues to use {@link SnapToSurfacesDragStrategy.update} (pointer ray + drag plane
+      * intersection) unchanged.
+      */
+     export declare class SnapToSurfaceConstraint implements IDragConstraint {
+         private readonly _context;
+         private _gameObject;
+         private _boundsAtScaleOne;
+         private readonly _t1;
+         private readonly _t2;
+         private readonly _t3;
+         private readonly _t4;
+         constructor(_context: Context);
+         init(ctx: IDragConstraintContext): void;
+         apply(followObject: GameObject): void;
+     }
+
      /** used to find data registered via gltf files e.g. find lightmaps for a Renderer component that were shipped inside a gltf */
      export declare type SourceIdentifier = string;
 
@@ -24841,9 +25152,40 @@ export declare class OrbitControls extends Component implements ICameraControlle
          All = 4294967295
      }
 
+     /* Excluded from this release type: _XtEQ */
+
      export { }
 
 
+declare module 'three' {
+    interface SkinnedMesh {
+        staticGenerator?: StaticGeometryGenerator;
+        staticGeometry?: BufferGeometry;
+        staticGeometryLastUpdate?: number;
+    }
+    interface Mesh {
+        acceleratedRaycast?: any;
+    }
+    interface SkinnedMesh {
+        /** @deprecated use autoUpdateMeshBvhInterval */
+        autoUpdateMeshBVH?: boolean;
+        /**
+         * Interval in milliseconds to automatically update the mesh BVH. When set to >= 0 the BVH will be updated every x milliseconds.
+         * @default undefined (disabled)
+         */
+        autoUpdateMeshBvhInterval?: number;
+        bvhNeedsUpdate?: boolean;
+    }
+}
+
+
+declare module 'three' {
+    interface Vector3 {
+        slerp(end: Vector3, t: number): Vector3;
+    }
+}
+
+
 declare module 'three' {
     interface Object3D {
         get guid(): string | undefined;
@@ -24982,32 +25324,3 @@ declare module 'three' {
         contains(object: Object3D | null | undefined): boolean;
     }
 }
-
-
-declare module 'three' {
-    interface Vector3 {
-        slerp(end: Vector3, t: number): Vector3;
-    }
-}
-
-
-declare module 'three' {
-    interface SkinnedMesh {
-        staticGenerator?: StaticGeometryGenerator;
-        staticGeometry?: BufferGeometry;
-        staticGeometryLastUpdate?: number;
-    }
-    interface Mesh {
-        acceleratedRaycast?: any;
-    }
-    interface SkinnedMesh {
-        /** @deprecated use autoUpdateMeshBvhInterval */
-        autoUpdateMeshBVH?: boolean;
-        /**
-         * Interval in milliseconds to automatically update the mesh BVH. When set to >= 0 the BVH will be updated every x milliseconds.
-         * @default undefined (disabled)
-         */
-        autoUpdateMeshBvhInterval?: number;
-        bvhNeedsUpdate?: boolean;
-    }
-}