xrblocks 0.2.0 → 0.3.0

package/build/addons/virtualkeyboard/Keyboard.js

@@ -88,12 +88,13 @@ class Keyboard extends xb.Script {
         this.onEnterPressed = null;
         this.onTextChanged = null;
         this.keyRows = [];
-        this.subspace =
-            new xb.SpatialPanel({ useDefaultPosition: false, showEdge: false });
+        this.subspace = new xb.SpatialPanel({
+            useDefaultPosition: false,
+            showEdge: false,
+        });
         this.subspace.isRoot = true;
         this.add(this.subspace);
-        this.mainPanel =
-            this.subspace.add(new xb.Panel({ backgroundColor: KEYBOARD_COLOR }));
+        this.mainPanel = this.subspace.add(new xb.Panel({ backgroundColor: KEYBOARD_COLOR }));
         this.mainGrid = new xb.Grid();
         this.mainPanel.add(this.mainGrid);
         this.mainGrid.addRow({ weight: ROW_TOP_PADDING });
@@ -135,16 +136,16 @@ class Keyboard extends xb.Script {
         if (textKeys.length === 0) {
             let currentColumnWeight = 0;
             row.addCol({ weight: 0.145 });
-            specialKeys.forEach(key => {
+            specialKeys.forEach((key) => {
                 currentColumnWeight += key.weight || COLUMN_WEIGHT;
             });
             const missingWeight = TARGET_COLUMN_WEIGHT - currentColumnWeight;
             if (missingWeight > 1) {
-                const leftKeys = specialKeys.filter(key => key.position === 'left');
-                const rightKeys = specialKeys.filter(key => key.position === 'right');
-                const weightForLeftKeys = (missingWeight / 3) / (leftKeys.length || 1);
-                const weightForRightKeys = (missingWeight * 2 / 3) / (rightKeys.length || 1);
-                specialKeys.forEach(key => {
+                const leftKeys = specialKeys.filter((key) => key.position === 'left');
+                const rightKeys = specialKeys.filter((key) => key.position === 'right');
+                const weightForLeftKeys = missingWeight / 3 / (leftKeys.length || 1);
+                const weightForRightKeys = (missingWeight * 2) / 3 / (rightKeys.length || 1);
+                specialKeys.forEach((key) => {
                     let finalWeight = key.weight || COLUMN_WEIGHT;
                     if (key.position === 'left') {
                         finalWeight += weightForLeftKeys;
@@ -156,14 +157,14 @@ class Keyboard extends xb.Script {
                 });
             }
             else {
-                specialKeys.forEach(key => this.createSpecialButtons(row, key));
+                specialKeys.forEach((key) => this.createSpecialButtons(row, key));
             }
             return;
         }
-        const leftSpecialKeys = specialKeys.filter(key => key.position === 'left');
-        const rightSpecialKeys = specialKeys.filter(key => key.position === 'right');
+        const leftSpecialKeys = specialKeys.filter((key) => key.position === 'left');
+        const rightSpecialKeys = specialKeys.filter((key) => key.position === 'right');
         let remainingWeight = TARGET_COLUMN_WEIGHT;
-        leftSpecialKeys.forEach(key => {
+        leftSpecialKeys.forEach((key) => {
             this.createSpecialButtons(row, key);
             remainingWeight -= key.weight;
         });
@@ -172,7 +173,7 @@ class Keyboard extends xb.Script {
             this.createTextButtons(row, key, shiftKey);
             remainingWeight -= COLUMN_WEIGHT;
         });
-        rightSpecialKeys.forEach(key => {
+        rightSpecialKeys.forEach((key) => {
             const finalWeight = (key.weight || COLUMN_WEIGHT) + remainingWeight;
             this.createSpecialButtons(row, { ...key, weight: finalWeight });
         });
@@ -186,7 +187,7 @@ class Keyboard extends xb.Script {
             fontSize: FONT_SIZE,
             backgroundColor: DEFAULT_KEY_COLOR,
             originalKey: key,
-            shiftKey: shiftKey
+            shiftKey: shiftKey,
         });
         keyPanel.add(textButton);
         this.textButtons.push(textButton);
@@ -248,17 +249,19 @@ class Keyboard extends xb.Script {
         }
     }
     refreshKeyboard() {
-        this.textButtons.forEach(button => {
+        this.textButtons.forEach((button) => {
             const isLetter = button.originalKey.length === 1 && button.originalKey.match(/[a-z]/i);
             let newText;
             const produceUpper = this.isShifted !== this.isCapsLockOn;
             if (isLetter) {
-                newText = produceUpper ? button.originalKey.toUpperCase() :
-                    button.originalKey.toLowerCase();
+                newText = produceUpper
+                    ? button.originalKey.toUpperCase()
+                    : button.originalKey.toLowerCase();
             }
             else {
-                newText = this.isShifted ? (button.shiftKey || button.originalKey) :
-                    button.originalKey;
+                newText = this.isShifted
+                    ? button.shiftKey || button.originalKey
+                    : button.originalKey;
             }
             button.setText(newText);
         });

package/build/addons/volumes/VolumetricCloud.glsl.js

@@ -120,7 +120,7 @@ void main(){
   if ( color.a == 0.0 ) discard;
 
 }
-`
+`,
 };
 
 export { VolumetricCloudShader };

package/build/addons/volumes/VolumetricCloud.js

@@ -43,15 +43,18 @@ class VolumetricCloud extends THREE.Object3D {
                 for (let x = 0; x < this.size; x++) {
                     // Calculates the density based on the distance from the center.
                     const d = 1.0 -
-                        vector.set(x, y, z)
+                        vector
+                            .set(x, y, z)
                             .subScalar(this.size / 2)
                             .divideScalar(this.size)
                             .length();
                     // Populates the data array with density influenced by noise.
-                    data[i] = (this.size +
-                        this.size *
-                            perlin.noise(x * this.cloudScale / 1.5, y * this.cloudScale, z * this.cloudScale / 1.5)) *
-                        d * d;
+                    data[i] =
+                        (this.size +
+                            this.size *
+                                perlin.noise((x * this.cloudScale) / 1.5, y * this.cloudScale, (z * this.cloudScale) / 1.5)) *
+                            d *
+                            d;
                     i++;
                 }
             }

package/build/agent/Tool.d.ts

@@ -1,4 +1,4 @@
-import type * as GoogleGenAITypes from '@google/genai';
+import * as GoogleGenAITypes from '@google/genai';
 export interface ToolCall {
     name: string;
     args: unknown;
@@ -30,6 +30,7 @@ export type ToolOptions = {
     parameters?: ToolSchema;
     /** A callback to execute when the tool is triggered */
     onTriggered?: (args: unknown) => unknown | Promise<unknown>;
+    behavior?: 'BLOCKING' | 'NON_BLOCKING' | GoogleGenAITypes.Behavior;
 };
 /**
  * A base class for tools that the agent can use.
@@ -39,6 +40,7 @@ export declare class Tool {
     description?: string;
     parameters?: ToolSchema;
     onTriggered?: (args: unknown) => unknown;
+    behavior?: 'BLOCKING' | 'NON_BLOCKING';
     /**
      * @param options - The options for the tool.
      */

package/build/ai/AI.d.ts

@@ -2,7 +2,7 @@ import type * as GoogleGenAITypes from '@google/genai';
 import { Script } from '../core/Script';
 import { AIOptions, GeminiOptions, OpenAIOptions } from './AIOptions';
 import { GeminiResponse } from './AITypes';
-import { Gemini, GeminiStartLiveSessionParams } from './Gemini';
+import { Gemini } from './Gemini';
 import { OpenAI } from './OpenAI';
 export type ModelClass = Gemini | OpenAI;
 export type ModelOptions = GeminiOptions | OpenAIOptions;
@@ -60,7 +60,7 @@ export declare class AI extends Script {
     query(input: {
         prompt: string;
     }, tools?: never[]): Promise<GeminiResponse | string | null>;
-    startLiveSession(config?: GeminiStartLiveSessionParams): Promise<GoogleGenAITypes.Session>;
+    startLiveSession(config?: GoogleGenAITypes.LiveConnectConfig, model?: string): Promise<GoogleGenAITypes.Session>;
     stopLiveSession(): Promise<void>;
     setLiveCallbacks(callbacks: GoogleGenAITypes.LiveCallbacks): Promise<void>;
     sendToolResponse(response: GoogleGenAITypes.LiveSendToolResponseParameters): void;

package/build/ai/Gemini.d.ts

@@ -14,10 +14,6 @@ export interface GeminiQueryInput {
     config?: GoogleGenAITypes.LiveConnectConfig;
     data?: GoogleGenAITypes.LiveSendRealtimeInputParameters;
 }
-export type GeminiStartLiveSessionParams = {
-    tools?: GoogleGenAITypes.FunctionDeclaration[];
-    systemInstruction?: GoogleGenAITypes.ContentUnion | string;
-};
 export declare class Gemini extends BaseAIModel {
     protected options: GeminiOptions;
     inited: boolean;
@@ -29,7 +25,7 @@ export declare class Gemini extends BaseAIModel {
     init(): Promise<void>;
     isAvailable(): boolean;
     isLiveAvailable(): false | typeof GoogleGenAITypes.Modality | undefined;
-    startLiveSession(params?: GeminiStartLiveSessionParams): Promise<GoogleGenAITypes.Session>;
+    startLiveSession(params?: GoogleGenAITypes.LiveConnectConfig, model?: string): Promise<GoogleGenAITypes.Session>;
     stopLiveSession(): Promise<void>;
     setLiveCallbacks(callbacks: GoogleGenAITypes.LiveCallbacks): void;
     sendToolResponse(response: GoogleGenAITypes.LiveSendToolResponseParameters): void;

package/build/camera/XRDeviceCamera.d.ts

@@ -23,7 +23,7 @@ export declare class XRDeviceCamera extends VideoStream<XRDeviceCameraDetails> {
     /**
      * @param options - The configuration options.
      */
-    constructor({ videoConstraints, willCaptureFrequently }?: Partial<DeviceCameraOptions>);
+    constructor({ videoConstraints, willCaptureFrequently, }?: Partial<DeviceCameraOptions>);
     /**
      * Retrieves the list of available video input devices.
      * @returns A promise that resolves with an

package/build/core/Core.d.ts

@@ -2,6 +2,7 @@ import * as THREE from 'three';
 import { AI } from '../ai/AI';
 import { XRDeviceCamera } from '../camera/XRDeviceCamera';
 import { Depth } from '../depth/Depth';
+import { GestureRecognition } from '../input/gestures/GestureRecognition';
 import { Input } from '../input/Input';
 import { Lighting } from '../lighting/Lighting';
 import { Physics } from '../physics/Physics';
@@ -49,7 +50,7 @@ export declare class Core {
     /** The main camera for rendering. */
     camera: THREE.PerspectiveCamera;
     /** The root scene graph for all objects. */
-    scene: THREE.Scene;
+    scene: THREE.Scene<THREE.Object3DEventMap>;
     /** Represents the user in the XR scene. */
     user: User;
     /** Manages all UI elements. */
@@ -77,6 +78,7 @@ export declare class Core {
     xrButton?: XRButton;
     effects?: XREffects;
     ai: AI;
+    gestureRecognition?: GestureRecognition;
     transition?: XRTransition;
     currentFrame?: XRFrame;
     scriptsManager: ScriptsManager;

package/build/core/Options.d.ts

@@ -2,6 +2,7 @@ import { AIOptions } from '../ai/AIOptions';
 import { DeviceCameraOptions } from '../camera/CameraOptions.js';
 import { DepthOptions } from '../depth/DepthOptions.js';
 import { HandsOptions } from '../input/HandsOptions.js';
+import { GestureRecognitionOptions } from '../input/gestures/GestureRecognitionOptions.js';
 import { LightingOptions } from '../lighting/LightingOptions.js';
 import { PhysicsOptions } from '../physics/PhysicsOptions';
 import { SimulatorOptions } from '../simulator/SimulatorOptions';
@@ -78,6 +79,7 @@ export declare class Options {
     lighting: LightingOptions;
     deviceCamera: DeviceCameraOptions;
     hands: HandsOptions;
+    gestures: GestureRecognitionOptions;
     reticles: ReticleOptions;
     sound: SoundOptions;
     ai: AIOptions;
@@ -150,6 +152,11 @@ export declare class Options {
      * @returns The instance for chaining.
      */
     enableHands(): this;
+    /**
+     * Enables the gesture recognition block and ensures hands are available.
+     * @returns The instance for chaining.
+     */
+    enableGestures(): this;
     /**
      * Enables the visualization of rays for hand tracking.
      * @returns The instance for chaining.

package/build/core/components/ScreenshotSynthesizer.d.ts

@@ -20,7 +20,7 @@ export declare class ScreenshotSynthesizer {
      * Requests a screenshot from the scene as a DataURL.
      * @param overlayOnCamera - If true, overlays the image on a camera image
      *     without any projection or aspect ratio correction.
-     * @returns Promise which returns the screenshot.
+     * @returns Promise which returns the screenshot as a data uri.
      */
-    getScreenshot(overlayOnCamera?: boolean): Promise<unknown>;
+    getScreenshot(overlayOnCamera?: boolean): Promise<string>;
 }

package/build/core/components/XRTransition.d.ts

@@ -35,7 +35,7 @@ export declare class XRTransition extends MeshScript<THREE.SphereGeometry, THREE
     private targetAlpha;
     private defaultBackgroundColor;
     constructor();
-    init({ renderer, camera, timer, scene, options }: {
+    init({ renderer, camera, timer, scene, options, }: {
         renderer: THREE.WebGLRenderer;
         camera: THREE.Camera;
         timer: THREE.Timer;

package/build/depth/DepthMesh.d.ts

@@ -43,7 +43,7 @@ export declare class DepthMesh extends MeshScript {
     /**
      * Initialize the depth mesh.
      */
-    init({ camera, renderer }: {
+    init({ camera, renderer, }: {
         camera: THREE.Camera;
         renderer: THREE.WebGLRenderer;
     }): 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/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/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;

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/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/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);
+}