xrblocks 0.1.0 → 0.3.0

package/build/depth/DepthTextures.d.ts

@@ -4,10 +4,12 @@ export declare class DepthTextures {
     private options;
     private uint16Arrays;
     private uint8Arrays;
-    private textures;
+    private dataTextures;
+    private nativeTextures;
     depthData: XRCPUDepthInformation[];
     constructor(options: DepthOptions);
-    private createDepthTextures;
-    update(depthData: XRCPUDepthInformation, view_id: number): void;
-    get(view_id: number): THREE.DataTexture;
+    private createDataDepthTextures;
+    updateData(depthData: XRCPUDepthInformation, view_id: number): void;
+    updateNativeTexture(depthData: XRWebGLDepthInformation, renderer: THREE.WebGLRenderer, view_id: number): void;
+    get(view_id: number): THREE.DataTexture | THREE.ExternalTexture;
 }

package/build/depth/occlusion/OcclusionPass.d.ts

@@ -26,19 +26,20 @@ export declare class OcclusionPass extends Pass {
     private kawaseBlurTargets;
     private occlusionUniforms;
     private occlusionQuad;
+    private depthNear;
     constructor(scene: THREE.Scene, camera: THREE.PerspectiveCamera, useFloatDepth?: boolean, renderToScreen?: boolean, occludableItemsLayer?: number);
     private setupKawaseBlur;
-    setDepthTexture(depthTexture: THREE.Texture, rawValueToMeters: number, view_id: number): void;
+    setDepthTexture(depthTexture: THREE.Texture, rawValueToMeters: number, viewId: number, depthNear?: number): void;
     /**
      * Render the occlusion map.
      * @param renderer - The three.js renderer.
      * @param writeBuffer - The buffer to write the final result.
      * @param readBuffer - The buffer for the current of virtual depth.
-     * @param view_id - The view to render.
+     * @param viewId - The view to render.
      */
-    render(renderer: THREE.WebGLRenderer, writeBuffer?: THREE.WebGLRenderTarget, readBuffer?: THREE.WebGLRenderTarget, view_id?: number): void;
-    renderOcclusionMapFromScene(renderer: THREE.WebGLRenderer, dimensions: THREE.Vector2, view_id: number): void;
-    renderOcclusionMapFromReadBuffer(renderer: THREE.WebGLRenderer, readBuffer: THREE.RenderTarget, dimensions: THREE.Vector2, view_id: number): void;
+    render(renderer: THREE.WebGLRenderer, writeBuffer?: THREE.WebGLRenderTarget, readBuffer?: THREE.WebGLRenderTarget, viewId?: number): void;
+    renderOcclusionMapFromScene(renderer: THREE.WebGLRenderer, dimensions: THREE.Vector2, viewId: number): void;
+    renderOcclusionMapFromReadBuffer(renderer: THREE.WebGLRenderer, readBuffer: THREE.RenderTarget, dimensions: THREE.Vector2, viewId: number): void;
     blurOcclusionMap(renderer: THREE.WebGLRenderer, dimensions: THREE.Vector2): void;
     applyOcclusionMapToRenderedImage(renderer: THREE.WebGLRenderer, readBuffer?: THREE.WebGLRenderTarget, writeBuffer?: THREE.WebGLRenderTarget): void;
     dispose(): void;

package/build/input/Hands.d.ts

@@ -1,6 +1,6 @@
 import * as THREE from 'three';
 import { HAND_JOINT_NAMES } from './components/HandJointNames.js';
-type JointName = typeof HAND_JOINT_NAMES[number];
+type JointName = (typeof HAND_JOINT_NAMES)[number];
 /**
  * Utility class for managing WebXR hand tracking data based on
  * reported Handedness.

package/build/input/Input.d.ts

@@ -36,7 +36,7 @@ export declare class Input {
      * Initializes an instance with XR controllers, grips, hands, raycaster, and
      * default options. Only called by Core.
      */
-    init({ scene, options, renderer }: {
+    init({ scene, options, renderer, }: {
         scene: THREE.Scene;
         options: Options;
         renderer: THREE.WebGLRenderer;

package/build/input/gestures/GestureEvents.d.ts

@@ -0,0 +1,23 @@
+import type { BuiltInGestureName } from './GestureRecognitionOptions';
+export type GestureEventType = 'gesturestart' | 'gestureupdate' | 'gestureend';
+export type GestureHandedness = 'left' | 'right';
+export interface GestureEventDetail {
+    /**
+     * The canonical gesture identifier. Built-in gestures map to
+     * `BuiltInGestureName` while custom providers may surface arbitrary strings.
+     */
+    name: BuiltInGestureName | string;
+    /** Which hand triggered the gesture. */
+    hand: GestureHandedness;
+    /** Provider specific confidence score, normalized to [0, 1]. */
+    confidence: number;
+    /**
+     * Optional payload for provider specific values (e.g. pinch distance,
+     * velocity vectors).
+     */
+    data?: Record<string, unknown>;
+}
+export interface GestureEvent {
+    type: GestureEventType;
+    detail: GestureEventDetail;
+}

package/build/input/gestures/GestureRecognition.d.ts

@@ -0,0 +1,43 @@
+import * as THREE from 'three';
+import { Input } from '../Input';
+import { User } from '../../core/User';
+import { Script } from '../../core/Script';
+import { GestureEventDetail, GestureEventType } from './GestureEvents';
+import { GestureRecognitionOptions } from './GestureRecognitionOptions';
+type GestureScriptEvent = THREE.Event & {
+    type: GestureEventType;
+    target: GestureRecognition;
+    detail: GestureEventDetail;
+};
+interface GestureRecognitionEventMap extends THREE.Object3DEventMap {
+    gesturestart: GestureScriptEvent;
+    gestureupdate: GestureScriptEvent;
+    gestureend: GestureScriptEvent;
+}
+export declare class GestureRecognition extends Script<GestureRecognitionEventMap> {
+    static dependencies: {
+        input: typeof Input;
+        user: typeof User;
+        options: typeof GestureRecognitionOptions;
+    };
+    private options;
+    private user;
+    private input;
+    private activeGestures;
+    private lastEvaluation;
+    private detectors;
+    private activeProvider;
+    private providerWarned;
+    init({ options, user, input, }: {
+        options: GestureRecognitionOptions;
+        user: User;
+        input: Input;
+    }): Promise<void>;
+    update(): void;
+    private configureProvider;
+    private assignDetectors;
+    private evaluateHand;
+    private buildHandContext;
+    private emitGesture;
+}
+export {};

package/build/input/gestures/GestureRecognitionOptions.d.ts

@@ -0,0 +1,43 @@
+import { DeepPartial, DeepReadonly } from '../../utils/Types';
+export type GestureProvider = 'heuristics' | 'mediapipe' | 'tfjs';
+export type BuiltInGestureName = 'pinch' | 'open-palm' | 'fist' | 'thumbs-up' | 'point' | 'spread';
+export type GestureConfiguration = {
+    enabled: boolean;
+    /**
+     * Optional override for gesture-specific score thresholds. For distance based
+     * gestures this is treated as a maximum distance; for confidence based
+     * gestures it is treated as a minimum score.
+     */
+    threshold?: number;
+};
+export type GestureConfigurations = Partial<Record<BuiltInGestureName, Partial<GestureConfiguration>>>;
+export declare class GestureRecognitionOptions {
+    /** Master switch for the gesture recognition block. */
+    enabled: boolean;
+    /**
+     * Backing provider that extracts gesture information.
+     *  - 'heuristics': WebXR joint heuristics only (no external ML dependency).
+     *  - 'mediapipe': MediaPipe Hands running via Web APIs / wasm.
+     *  - 'tfjs': TensorFlow.js hand-pose-detection models.
+     */
+    provider: GestureProvider;
+    /**
+     * Minimum confidence score to emit gesture events. Different providers map to
+     * different score domains so this value is normalised to [0-1].
+     */
+    minimumConfidence: number;
+    /**
+     * Optional throttle window for expensive providers.
+     */
+    updateIntervalMs: number;
+    /**
+     * Default gesture catalogue.
+     */
+    gestures: Record<BuiltInGestureName, GestureConfiguration>;
+    constructor(options?: DeepReadonly<DeepPartial<GestureRecognitionOptions>>);
+    enable(): this;
+    /**
+     * Convenience helper to toggle specific gestures.
+     */
+    setGestureEnabled(name: BuiltInGestureName, enabled: boolean): this;
+}

package/build/input/gestures/GestureTypes.d.ts

@@ -0,0 +1,16 @@
+import * as THREE from 'three';
+import { Handedness } from '../Hands';
+import { BuiltInGestureName, GestureConfiguration } from './GestureRecognitionOptions';
+export type HandLabel = 'left' | 'right';
+export type JointPositions = Map<string, THREE.Vector3>;
+export type HandContext = {
+    handedness: Handedness;
+    handLabel: HandLabel;
+    joints: JointPositions;
+};
+export type GestureDetectionResult = {
+    confidence: number;
+    data?: Record<string, unknown>;
+};
+export type GestureDetector = (context: HandContext, config: GestureConfiguration) => GestureDetectionResult | undefined;
+export type GestureDetectorMap = Partial<Record<BuiltInGestureName, GestureDetector>>;

package/build/input/gestures/providers/HeuristicGestureDetectors.d.ts

@@ -0,0 +1,2 @@
+import { GestureDetectorMap } from '../GestureTypes';
+export declare const heuristicDetectors: GestureDetectorMap;

package/build/simulator/Simulator.d.ts

@@ -49,6 +49,8 @@ export declare class Simulator extends Script {
     mainScene: THREE.Scene;
     private initialized;
     private renderSimulatorSceneToCanvasBound;
+    private sparkRenderer?;
+    private registry?;
     constructor(renderMainScene: (cameraOverride?: THREE.Camera) => void);
     init({ simulatorOptions, input, timer, camera, renderer, scene, registry, options, depth, }: {
         simulatorOptions: SimulatorOptions;

package/build/simulator/SimulatorControls.d.ts

@@ -38,7 +38,7 @@ export declare class SimulatorControls {
     /**
      * Initialize the simulator controls.
      */
-    init({ camera, input, timer, renderer, simulatorOptions }: {
+    init({ camera, input, timer, renderer, simulatorOptions, }: {
         camera: THREE.Camera;
         input: Input;
         timer: THREE.Timer;

package/build/simulator/SimulatorOptions.d.ts

@@ -48,5 +48,6 @@ export declare class SimulatorOptions {
         enabled: boolean;
     };
     renderToRenderTexture: boolean;
+    blendingMode: 'normal' | 'screen';
     constructor(options?: DeepReadonly<DeepPartial<SimulatorOptions>>);
 }

package/build/simulator/controlModes/SimulatorControlMode.d.ts

@@ -20,7 +20,7 @@ export declare class SimulatorControlMode {
     /**
      * Initialize the simulator control mode.
      */
-    init({ camera, input, timer }: {
+    init({ camera, input, timer, }: {
         camera: THREE.Camera;
         input: Input;
         timer: THREE.Timer;

package/build/simulator/handPoses/HandPoseJoints.d.ts

@@ -1,5 +1,5 @@
-export type SimulatorHandPoseJoints = ({
+export type SimulatorHandPoseJoints = {
     t: number[];
     r: number[];
     s?: number[];
-})[];
+}[];

package/build/simulator/userActions/PinchOnButtonAction.d.ts

@@ -18,7 +18,7 @@ export declare class PinchOnButtonAction extends SimulatorUserAction {
     private timer;
     private input;
     constructor(target: THREE.Object3D);
-    init({ simulator, camera, timer, input }: {
+    init({ simulator, camera, timer, input, }: {
         simulator: Simulator;
         camera: THREE.Camera;
         timer: THREE.Timer;
@@ -27,7 +27,7 @@ export declare class PinchOnButtonAction extends SimulatorUserAction {
     controllerIsPointingAtButton(controls: SimulatorControls, camera: THREE.Camera): boolean;
     rotateControllerTowardsButton(controls: SimulatorControls, camera: THREE.Camera, deltaTime: number): void;
     pinchController(): void;
-    play({ simulatorUser, journeyId, waitFrame }: {
+    play({ simulatorUser, journeyId, waitFrame, }: {
         simulatorUser: SimulatorUser;
         journeyId: number;
         waitFrame: WaitFrame;

package/build/simulator/userActions/WalkTowardsPanelAction.d.ts

@@ -23,7 +23,7 @@ export declare class WalkTowardsPanelAction extends SimulatorUserAction {
     lookAtTarget(): void;
     lookTowardsTarget(): void;
     moveTowardsTarget(): void;
-    play({ simulatorUser, journeyId, waitFrame }: {
+    play({ simulatorUser, journeyId, waitFrame, }: {
         simulatorUser: SimulatorUser;
         journeyId: number;
         waitFrame: WaitFrame;

package/build/singletons.d.ts

@@ -16,7 +16,7 @@ export declare const core: Core;
  * scene.add(myObject);
  * ```
  */
-export declare const scene: THREE.Scene;
+export declare const scene: THREE.Scene<THREE.Object3DEventMap>;
 /**
  * A direct alias to the `User` instance, which represents the user in the XR
  * scene and manages inputs like controllers and hands.
@@ -43,7 +43,7 @@ export declare const ai: import("./xrblocks").AI;
  * @param object - The object(s) to add.
  * @see {@link three#Object3D.add}
  */
-export declare function add(...object: THREE.Object3D[]): THREE.Scene;
+export declare function add(...object: THREE.Object3D[]): THREE.Scene<THREE.Object3DEventMap>;
 /**
  * A shortcut for `core.init()`. Initializes the XR Blocks system and starts
  * the render loop. This is the main entry point for any application.

package/build/sound/AudioListener.d.ts

@@ -14,11 +14,13 @@ export declare class AudioListener extends Script {
     };
     private options;
     private audioStream?;
-    private audioContext?;
+    audioContext?: AudioContext;
     private sourceNode?;
     private processorNode?;
     private isCapturing;
     private latestAudioBuffer;
+    private accumulatedChunks;
+    private isAccumulating;
     private registry;
     aiService?: AI;
     private onAudioData?;
@@ -33,6 +35,7 @@ export declare class AudioListener extends Script {
     startCapture(callbacks?: {
         onAudioData?: (audioBuffer: ArrayBuffer) => void;
         onError?: (error: Error) => void;
+        accumulate?: boolean;
     }): Promise<void>;
     stopCapture(): void;
     setupAudioCapture(): Promise<void>;
@@ -44,5 +47,17 @@ export declare class AudioListener extends Script {
     getIsCapturing(): boolean;
     getLatestAudioBuffer(): ArrayBuffer | null;
     clearLatestAudioBuffer(): void;
+    /**
+     * Gets all accumulated audio chunks as a single combined buffer
+     */
+    getAccumulatedBuffer(): ArrayBuffer | null;
+    /**
+     * Clears accumulated chunks
+     */
+    clearAccumulatedBuffer(): void;
+    /**
+     * Gets the number of accumulated chunks
+     */
+    getAccumulatedChunkCount(): number;
     dispose(): void;
 }

package/build/sound/AudioPlayer.d.ts

@@ -1,18 +1,37 @@
 import { Script } from '../core/Script.js';
+import { CategoryVolumes } from './CategoryVolumes';
 export interface AudioPlayerOptions {
     sampleRate?: number;
     channelCount?: number;
+    category?: string;
 }
 export declare class AudioPlayer extends Script {
     private options;
     private audioContext?;
     private audioQueue;
-    private isPlaying;
     private nextStartTime;
+    private gainNode?;
+    private categoryVolumes?;
+    private volume;
+    private category;
     constructor(options?: AudioPlayerOptions);
+    /**
+     * Sets the CategoryVolumes instance for this player to respect
+     * master/category volumes
+     */
+    setCategoryVolumes(categoryVolumes: CategoryVolumes): void;
+    /**
+     * Sets the specific volume for this player (0.0 to 1.0)
+     */
+    setVolume(level: number): void;
+    /**
+     * Updates the gain node volume based on category volumes
+     * Public so CoreSound can update it when master volume changes
+     */
+    updateGainNodeVolume(): void;
     initializeAudioContext(): Promise<void>;
     playAudioChunk(base64AudioData: string): Promise<void>;
-    playNextAudioBuffer(): void;
+    private scheduleAudioBuffers;
     clearQueue(): void;
     getIsPlaying(): boolean;
     getQueueLength(): number;

package/build/sound/CoreSound.d.ts

@@ -24,7 +24,7 @@ export declare class CoreSound extends Script {
     audioListener: AudioListener;
     audioPlayer: AudioPlayer;
     options: SoundOptions;
-    init({ camera, soundOptions }: {
+    init({ camera, soundOptions, }: {
         camera: THREE.Camera;
         soundOptions: SoundOptions;
     }): void;
@@ -35,13 +35,38 @@ export declare class CoreSound extends Script {
     getCategoryVolume(category: VolumeCategory): number;
     enableAudio(options?: {
         streamToAI?: boolean;
+        accumulate?: boolean;
     }): Promise<void>;
     disableAudio(): void;
+    /**
+     * Starts recording audio with chunk accumulation
+     */
+    startRecording(): Promise<void>;
+    /**
+     * Stops recording and returns the accumulated audio buffer
+     */
+    stopRecording(): ArrayBuffer | null;
+    /**
+     * Gets the accumulated recording buffer without stopping
+     */
+    getRecordedBuffer(): ArrayBuffer | null;
+    /**
+     * Clears the accumulated recording buffer
+     */
+    clearRecordedBuffer(): void;
+    /**
+     * Gets the sample rate being used for recording
+     */
+    getRecordingSampleRate(): number;
     setAIStreaming(enabled: boolean): void;
     isAIStreamingEnabled(): boolean;
     playAIAudio(base64AudioData: string): Promise<void>;
     stopAIAudio(): void;
     isAIAudioPlaying(): boolean;
+    /**
+     * Plays a raw audio buffer (Int16 PCM data) with proper sample rate
+     */
+    playRecordedAudio(audioBuffer: ArrayBuffer, sampleRate?: number): Promise<void>;
     isAudioEnabled(): boolean;
     getLatestAudioBuffer(): ArrayBuffer | null;
     clearLatestAudioBuffer(): void;

package/build/stereo/utils.d.ts

@@ -20,4 +20,4 @@ export declare function showOnlyInRightEye<T extends THREE.Object3D>(obj: T): T;
  * @returns A promise that resolves to an array containing the left and right
  *     eye textures.
  */
-export declare function loadStereoImageAsTextures(url: string): Promise<THREE.Texture[]>;
+export declare function loadStereoImageAsTextures(url: string): Promise<THREE.Texture<unknown>[]>;

package/build/ui/components/IconButton.d.ts

@@ -44,14 +44,18 @@ export declare class IconButton extends TextView {
      * @param options - The options for the IconButton.
      */
     constructor(options?: IconButtonOptions);
+    /**
+     * Initializes the component and sets the render order.
+     */
+    init(_?: object): Promise<void>;
+    /**
+  
     /**
      * Handles behavior when the cursor hovers over the button.
-     * @override
      */
     onHoverOver(): void;
     /**
      * Handles behavior when the cursor moves off the button.
-     * @override
      */
     onHoverOut(): void;
     /**

package/build/ui/components/MaterialSymbolsView.d.ts

@@ -34,7 +34,7 @@ export declare class MaterialSymbolsView extends View {
      * Construct a Material Symbol view.
      * @param options - Options for the icon.
      */
-    constructor({ icon, iconWeight, iconStyle, iconScale, iconColor }: MaterialSymbolsViewOptions);
+    constructor({ icon, iconWeight, iconStyle, iconScale, iconColor, }: MaterialSymbolsViewOptions);
     init(): Promise<void>;
     /**
      * Updates the icon displayed by loading the appropriate SVG from the Material

package/build/ui/components/ScrollingTroikaTextView.d.ts

@@ -27,7 +27,7 @@ export declare class ScrollingTroikaTextView extends View {
     private textView;
     private onTextSyncCompleteBound;
     private currentText;
-    constructor({ text, textAlign, scrollerState, fontSize }?: ScrollingTroikaTextViewOptions);
+    constructor({ text, textAlign, scrollerState, fontSize, }?: ScrollingTroikaTextViewOptions);
     update(): void;
     addText(text: string): void;
     setText(text: string): void;

package/build/ui/components/TextButton.d.ts

@@ -46,7 +46,6 @@ export declare class TextButton extends TextView {
     constructor(options?: TextButtonOptions);
     /**
      * Initializes the text object after async dependencies are loaded.
-     * @override
      */
     init(): Promise<void>;
     update(): void;

package/build/ui/interaction/ModelViewer.d.ts

@@ -2,6 +2,7 @@ import * as THREE from 'three';
 import { Script } from '../../core/Script';
 import { Depth } from '../../depth/Depth';
 import { Draggable, DragMode, HasDraggingMode } from '../../ux/DragManager';
+import { Registry } from '../../core/components/Registry';
 export interface GLTFData {
     model: string;
     path: string;
@@ -38,6 +39,7 @@ export declare class ModelViewer extends Script implements Draggable {
         depth: typeof Depth;
         scene: typeof THREE.Scene;
         renderer: typeof THREE.WebGLRenderer;
+        registry: typeof Registry;
     };
     draggable: boolean;
     rotatable: boolean;
@@ -65,16 +67,18 @@ export declare class ModelViewer extends Script implements Draggable {
     private platform?;
     private controlBar?;
     private rotationRaycastMesh?;
+    private registry?;
     constructor({ castShadow, receiveShadow, raycastToChildren, }: {
         castShadow?: boolean | undefined;
         receiveShadow?: boolean | undefined;
         raycastToChildren?: boolean | undefined;
     });
-    init({ camera, depth, scene, renderer }: {
+    init({ camera, depth, scene, renderer, registry, }: {
         camera: THREE.Camera;
         depth: Depth;
         scene: THREE.Scene;
         renderer: THREE.WebGLRenderer;
+        registry: Registry;
     }): Promise<void>;
     loadSplatModel({ data, onSceneLoaded, platformMargin, setupRaycastCylinder, setupRaycastBox, setupPlatform, }: {
         data: SplatData;
@@ -84,7 +88,7 @@ export declare class ModelViewer extends Script implements Draggable {
         setupRaycastBox?: boolean;
         setupPlatform?: boolean;
     }): Promise<void | SplatAnchor>;
-    loadGLTFModel({ data, onSceneLoaded, platformMargin, setupRaycastCylinder, setupRaycastBox, setupPlatform, renderer, addOcclusionToShader }: {
+    loadGLTFModel({ data, onSceneLoaded, platformMargin, setupRaycastCylinder, setupRaycastBox, setupPlatform, renderer, addOcclusionToShader, }: {
         data: GLTFData;
         onSceneLoaded?: (scene: THREE.Object3D) => void;
         platformMargin?: THREE.Vector2;

package/build/utils/ModelLoader.d.ts

@@ -34,7 +34,7 @@ export declare class ModelLoader {
      * @returns A promise that resolves with the loaded model data (e.g., a glTF
      *     scene or a SplatMesh).
      */
-    load({ path, url, renderer, onProgress }: ModelLoaderLoadOptions): Promise<GLTF | import("@sparkjsdev/spark").SplatMesh | null>;
+    load({ path, url, renderer, onProgress, }: ModelLoaderLoadOptions): Promise<GLTF | import("@sparkjsdev/spark").SplatMesh | null>;
     /**
      * Loads a 3DGS model (.ply, .spz, .splat, .ksplat).
      * @param url - The URL of the model file.

package/build/utils/SparkRendererHolder.d.ts

@@ -0,0 +1,5 @@
+import type { SparkRenderer } from '@sparkjsdev/spark';
+export declare class SparkRendererHolder {
+    renderer: SparkRenderer;
+    constructor(renderer: SparkRenderer);
+}

package/build/utils/Types.d.ts

@@ -21,12 +21,12 @@ export interface Shader {
 /**
  * A recursive readonly type.
  */
-export type DeepReadonly<T> = T extends ((...args: any[]) => any) ? T : T extends object ? {
+export type DeepReadonly<T> = T extends (...args: any[]) => any ? T : T extends object ? {
     readonly [P in keyof T]: DeepReadonly<T[P]>;
 } : T;
 /**
  * A recursive partial type.
  */
-export type DeepPartial<T> = T extends ((...args: any[]) => any) ? T : T extends object ? {
+export type DeepPartial<T> = T extends (...args: any[]) => any ? T : T extends object ? {
     [P in keyof T]?: DeepPartial<T[P]>;
 } : T;

package/build/video/VideoStream.d.ts

@@ -75,7 +75,7 @@ export declare class VideoStream<T extends VideoStreamDetails = VideoStreamDetai
      * @param options - The options for the snapshot.
      * @returns The captured data.
      */
-    getSnapshot({ width, height, outputFormat, mimeType, quality }?: VideoStreamGetSnapshotOptions): string | THREE.Texture | ImageData | null;
+    getSnapshot({ width, height, outputFormat, mimeType, quality, }?: VideoStreamGetSnapshotOptions): string | THREE.Texture<unknown> | ImageData | null;
     /**
      * Stops the current video stream tracks.
      */

package/build/world/World.d.ts

@@ -46,7 +46,7 @@ export declare class World extends Script {
      * Initializes the world-sensing modules based on the provided configuration.
      * This method is called automatically by the XRCore.
      */
-    init({ options, camera }: {
+    init({ options, camera, }: {
         options: WorldOptions;
         camera: THREE.Camera;
     }): Promise<void>;

package/build/world/objects/ObjectDetector.d.ts

@@ -39,7 +39,7 @@ export declare class ObjectDetector extends Script {
      * Initializes the ObjectDetector.
      * @override
      */
-    init({ options, ai, aiOptions, deviceCamera, depth, camera }: {
+    init({ options, ai, aiOptions, deviceCamera, depth, camera, }: {
         options: WorldOptions;
         ai: AI;
         aiOptions: AIOptions;

package/build/world/planes/PlaneDetector.d.ts

@@ -27,7 +27,7 @@ export declare class PlaneDetector extends Script {
     /**
      * Initializes the PlaneDetector.
      */
-    init({ options, renderer }: {
+    init({ options, renderer, }: {
         options: WorldOptions;
         renderer: THREE.WebGLRenderer;
     }): void;

package/build/xrblocks.d.ts

@@ -31,6 +31,9 @@ export * from './input/components/HandJointNames';
 export * from './input/GazeController';
 export * from './input/Hands';
 export * from './input/HandsOptions';
+export * from './input/gestures/GestureRecognition';
+export * from './input/gestures/GestureRecognitionOptions';
+export * from './input/gestures/GestureEvents';
 export * from './input/Input';
 export * from './input/MouseController';
 export * from './lighting/Lighting';