vim-web 0.3.44-dev.6 → 0.3.44-dev.60

package/dist/types/core-viewers/ultra/index.d.ts

@@ -1,9 +1,29 @@
 import "./style.css";
-export * from './viewer/viewer';
-export * as utils from './utils/promise';
-export * from './viewer/vim';
-export * from './utils/math3d';
-export * from './viewer/color';
-export type { ILoadRequest, VimRequestErrorType } from './viewer/loadRequest';
-export type { ClientState, ConnectionSettings } from './viewer/socketClient';
-export type { VimSource } from './viewer/rpcSafeClient';
+export * from './viewer';
+export { RGB, RGBA, RGBA32, Segment, type SectionBoxState, type HitCheckResult, type VimStatus } from './rpcTypes';
+export { materialHandles, MaterialHandles, type MaterialHandle, } from './rpcClient';
+export type * from './camera';
+export type * from './colorManager';
+export type * from './decoder';
+export type * from './nodeState';
+export { NodeState } from './nodeState';
+export type * from './element3d';
+export type * from './inputAdapter';
+export type * from './loadRequest';
+export type * from './logger';
+export type * from './protocol';
+export type * from './raycaster';
+export type * from './remoteColor';
+export type * from './renderer';
+export type * from './rpcClient';
+export type * from './rpcMarshal';
+export type * from './rpcSafeClient';
+export { InputMode, VimLoadingStatus } from './rpcSafeClient';
+export type * from './sectionBox';
+export type * from './selection';
+export type * from './socketClient';
+export type * from './streamLogger';
+export type * from './streamRenderer';
+export type * from './viewport';
+export type * from './vim';
+export type * from './vimCollection';

package/dist/types/core-viewers/ultra/inputAdapter.d.ts

@@ -0,0 +1,5 @@
+import * as Shared from "../shared";
+import { Viewer } from "./viewer";
+declare const CODE_TO_KEYCODE: Record<string, number>;
+export default CODE_TO_KEYCODE;
+export declare function ultraInputAdapter(viewer: Viewer): Shared.InputHandler;

package/dist/types/core-viewers/ultra/nodeState.d.ts

@@ -0,0 +1,113 @@
+import { RpcSafeClient } from './rpcSafeClient';
+/**
+ * Represents the possible states a node can have in the UltraVim system.
+ */
+export declare enum NodeState {
+    VISIBLE = "visible",
+    HIDDEN = "hidden",
+    GHOSTED = "ghosted",
+    HIGHLIGHTED = "highlighted"
+}
+/**
+ * A class that wraps a StateTracker and is responsible for synchronizing its state updates with the remote RPCs.
+ * It batches updates to optimize performance and handles the communication with the remote system.
+ */
+export declare class StateSynchronizer {
+    private _tracker;
+    private _rpc;
+    private _getHandle;
+    private _onUpdate;
+    private _isConnected;
+    private _animationFrame;
+    /**
+     * Creates a new StateSynchronizer instance.
+     *
+     * @param rpc - The RPC client used to communicate with the remote system
+     * @param getHandle - Function that returns the current handle identifier
+     * @param isConnected - Function that returns whether the connection to the remote system is active
+     * @param onUpdate - Callback function invoked when updates are sent to the remote system
+     * @param defaultState - The default state for nodes when not explicitly set (defaults to VISIBLE)
+     */
+    constructor(rpc: RpcSafeClient, getHandle: () => number, isConnected: () => boolean, onUpdate: () => void, defaultState?: NodeState);
+    /**
+     * Checks if all nodes are in the specified state(s).
+     *
+     * @param state - A single state or array of states to check against
+     * @returns True if all nodes are in the specified state(s), false otherwise
+     */
+    areAllInState(state: NodeState | NodeState[]): boolean;
+    /**
+     * Gets the current state of a specific node.
+     *
+     * @param node - The node identifier
+     * @returns The current state of the node
+     */
+    getNodeState(node: number): NodeState;
+    /**
+     * Gets all nodes that are currently in the specified state.
+     *
+     * @param state - The state to query
+     * @returns Either 'all' if all nodes are in this state, or an array of node IDs
+     */
+    getNodesInState(state: NodeState): number[] | 'all';
+    /**
+     * Gets the default state used for nodes without explicit state settings.
+     *
+     * @returns The current default state
+     */
+    getDefaultState(): NodeState;
+    /**
+     * Sets the state of a specific node.
+     *
+     * @param nodeId - The identifier of the node
+     * @param state - The new state to apply
+     */
+    setNodeState(nodeId: number, state: NodeState): void;
+    /**
+     * Sets the state of all nodes to the specified value.
+     *
+     * @param state - The state to apply to all nodes
+     * @param clear - If true, clears all node-specific overrides
+     */
+    setAllNodesState(state: NodeState, clear: boolean): void;
+    /**
+     * Replaces all nodes in one state (or states) with another state.
+     *
+     * @param fromState - The state(s) to replace
+     * @param toState - The new state to apply
+     */
+    replaceState(fromState: NodeState | NodeState[], toState: NodeState): void;
+    /**
+     * Reapplies all current state settings, useful after changes to the node structure.
+     * This will remove redundant overrides and ensure consistency.
+     */
+    reapplyStates(): void;
+    /**
+     * Schedules a synchronization on the next animation frame.
+     * This batches multiple rapid state changes to avoid excessive RPC calls.
+     *
+     * @private
+     */
+    private scheduleUpdate;
+    /**
+     * Processes all pending updates and sends them to the remote system.
+     *
+     * @private
+     */
+    private remoteUpdate;
+    /**
+     * Calls the appropriate RPC method to update the state of all nodes.
+     *
+     * @param state - The state to apply to all nodes
+     * @private
+     */
+    private callRPCForStateAll;
+    /**
+     * Calls the appropriate RPC method to update the state of specific nodes.
+     *
+     * @param state - The state to apply
+     * @param nodes - Array of node IDs to update
+     * @private
+     */
+    private callRPCForStateNodes;
+}

package/dist/types/core-viewers/ultra/raycaster.d.ts

@@ -0,0 +1,52 @@
+import * as THREE from "three";
+import type { IRaycastResult, IRaycaster } from "../shared/raycaster";
+import { Element3D } from "./element3d";
+import { RpcSafeClient } from "./rpcSafeClient";
+import { IReadonlyVimCollection } from "./vimCollection";
+export type IUltraRaycastResult = IRaycastResult<Element3D>;
+export type IUltraRaycaster = IRaycaster<Element3D>;
+/**
+ * Represents the result of a hit test operation.
+ */
+export declare class UltraRaycastResult implements IRaycastResult<Element3D> {
+    /** The model Object hit */
+    object: Element3D;
+    /** The 3D world position of the hit point */
+    worldPosition: THREE.Vector3;
+    /** The surface normal at the hit point */
+    worldNormal: THREE.Vector3;
+    constructor(object: Element3D, worldPosition: THREE.Vector3, worldNormal: THREE.Vector3);
+}
+/**
+ * @module ultra-webgl-viewer
+ */
+/**
+ * Handles raycasting operations in the Ultra system, enabling picking and
+ * interaction with 3D objects in the scene.
+ */
+export declare class Raycaster implements IRaycaster<Element3D> {
+    private _rpc;
+    private _vims;
+    /**
+     * Creates a new UltraCoreRaycaster instance.
+     *
+     * @param {RpcSafeClient} rpc - RPC client for communication with the viewer.
+     * @param {IReadonlyVimCollection} vims - Collection of VIM instances to manage.
+     */
+    constructor(rpc: RpcSafeClient, vims: IReadonlyVimCollection);
+    /**
+     * Performs a raycast from the camera using normalized screen coordinates.
+     * Coordinates must be within [0, 1] for both x and y.
+     *
+     * @param {Vector2} position - The normalized screen position for raycasting.
+     * @returns {Promise<UltraRaycastResult | undefined>} Promise resolving to hit test result or undefined if no hit.
+     */
+    raycastFromScreen(position: THREE.Vector2): Promise<UltraRaycastResult>;
+    /**
+     * Performs a raycast from a specific world position towards a target.
+     *
+     * @param {Vector3} position - The target world position for raycasting.
+     * @returns {Promise<UltraRaycastResult | undefined>} Promise resolving to hit test result or undefined if no hit.
+     */
+    raycastFromWorld(position: THREE.Vector3): Promise<UltraRaycastResult | undefined>;
+}

package/dist/types/core-viewers/ultra/{viewer/color.d.ts → remoteColor.d.ts}

@@ -1,10 +1,10 @@
-import { RGBA32 } from "../utils/math3d";
-import { ColorManager } from "./colorManager";
+import { RGBA32 } from './rpcTypes';
+import { ColorManager } from './colorManager';
 /**
  * Represents a handle to a color in the color management system.
  * This class provides access to color components and manages the lifecycle of color instances.
  */
-export declare class ColorHandle {
+export declare class RemoteColor {
     private _manager;
     /** Unique identifier for the color instance */
     readonly id: number;

package/dist/types/core-viewers/ultra/{viewer/renderer.d.ts → renderer.d.ts}

@@ -1,6 +1,8 @@
-import { Box3, RGBA } from "../utils/math3d";
+import { ISignal } from "ste-signals";
+import * as THREE from "three";
 import { ILogger } from "./logger";
 import { RpcSafeClient, SceneSettings } from "./rpcSafeClient";
+import { RGBA } from "./rpcTypes";
 import { ClientStreamError } from "./socketClient";
 /**
  * Render settings that extend SceneSettings with additional rendering-specific properties
@@ -19,6 +21,7 @@ export declare const defaultRenderSettings: RenderSettings;
  * Interface defining the basic renderer capabilities
  */
 export interface IRenderer {
+    onSceneUpdated: ISignal;
     ghostColor: RGBA;
     lockIblRotation: boolean;
     hdrScale: number;
@@ -27,7 +30,7 @@ export interface IRenderer {
     hdrBackgroundSaturation: number;
     backgroundBlur: number;
     backgroundColor: RGBA;
-    getBoundingBox(): Promise<Box3 | undefined>;
+    getBoundingBox(): Promise<THREE.Box3 | undefined>;
 }
 /**
  * Renderer class that handles 3D scene rendering and settings management
@@ -40,6 +43,8 @@ export declare class Renderer implements IRenderer {
     private _updateLighting;
     private _updateGhostColor;
     private _updateIblRotation;
+    private readonly _onSceneUpdated;
+    get onSceneUpdated(): ISignal;
     /**
      * Creates a new Renderer instance
      * @param rpc - RPC client for communication with the rendering backend
@@ -56,6 +61,7 @@ export declare class Renderer implements IRenderer {
      * Sets up initial scene settings, ghost color, and IBL rotation
      */
     onConnect(): void;
+    notifySceneUpdated(): void;
     /**
      * Gets the ghost color used for transparent rendering
      * @returns Current ghost color as RGBA
@@ -136,7 +142,7 @@ export declare class Renderer implements IRenderer {
      * @param value - New background color as RGBA
      */
     set backgroundColor(value: RGBA);
-    getBoundingBox(): Promise<Box3 | undefined>;
+    getBoundingBox(): Promise<THREE.Box3 | undefined>;
     /**
      * Requests an update to be performed on the next animation frame.
      * Multiple setting changes will be batched into a single update.

package/dist/types/core-viewers/ultra/{viewer/rpcClient.d.ts → rpcClient.d.ts}

@@ -1,6 +1,5 @@
 import type { SocketClient } from './socketClient';
-import { HitCheckResult, VimStatus, SectionBoxState } from './marshal';
-import { Box3, RGBA, RGBA32, Segment, Vector2, Vector3, Matrix44 } from '../utils/math3d';
+import * as RpcTypes from './rpcTypes';
 export type MaterialHandle = 4294967295 | 6 | 2 | 0 | 1 | 3 | 4 | 5 | 7 | 8;
 export declare class MaterialHandles {
     static readonly Invalid: MaterialHandle;
@@ -24,24 +23,24 @@ export declare class RpcClient {
     RPCAddNodeFlags(componentHandle: number, nodes: number[], flags: number): void;
     RPCClearMaterialOverrides(componentHandle: number): void;
     RPCClearScene(): void;
-    RPCCreateMaterialInstances(materialHandle: number, smoothness: number, colors: RGBA32[]): Promise<number>;
-    RPCCreateText(position: Vector3, color: RGBA32, text: string): Promise<number>;
+    RPCCreateMaterialInstances(materialHandle: number, smoothness: number, colors: RpcTypes.RGBA32[]): Promise<number>;
+    RPCCreateText(position: RpcTypes.Vector3, color: RpcTypes.RGBA32, text: string): Promise<number>;
     RPCDestroyMaterialInstances(materialInstanceHandle: number[]): void;
     RPCDestroyText(componentHandle: number): void;
     RPCEnableSectionBox(value: boolean): void;
-    RPCFrameAll(blendTime: number): Promise<Segment>;
-    RPCFrameBox(box: Box3, blendTime: number): Promise<Segment>;
-    RPCFrameInstances(componentHandle: number, nodes: number[], blendTime: number): Promise<Segment>;
-    RPCFrameVim(componentHandle: number, blendTime: number): Promise<Segment>;
+    RPCFrameAll(blendTime: number): Promise<RpcTypes.Segment>;
+    RPCFrameBox(box: RpcTypes.Box3, blendTime: number): Promise<RpcTypes.Segment>;
+    RPCFrameInstances(componentHandle: number, nodes: number[], blendTime: number): Promise<RpcTypes.Segment>;
+    RPCFrameVim(componentHandle: number, blendTime: number): Promise<RpcTypes.Segment>;
     RPCGetAPIVersion(): Promise<string>;
-    RPCGetBoundingBox(componentHandle: number, nodes: number[]): Promise<Box3>;
-    RPCGetBoundingBoxAll(componentHandle: number): Promise<Box3>;
-    RPCGetCameraPosition(): Promise<Segment>;
-    RPCGetIblRotation(): Promise<Matrix44>;
+    RPCGetBoundingBox(componentHandle: number, nodes: number[]): Promise<RpcTypes.Box3>;
+    RPCGetBoundingBoxAll(componentHandle: number): Promise<RpcTypes.Box3>;
+    RPCGetCameraPosition(): Promise<RpcTypes.Segment>;
+    RPCGetIblRotation(): Promise<RpcTypes.Matrix44>;
     RPCGetLastError(): Promise<string>;
-    RPCGetSceneAABB(): Promise<Box3>;
-    RPCGetSectionBox(): Promise<SectionBoxState>;
-    RPCGetVimLoadingState(componentHandle: number): Promise<VimStatus>;
+    RPCGetSceneAABB(): Promise<RpcTypes.Box3>;
+    RPCGetSectionBox(): Promise<RpcTypes.SectionBoxState>;
+    RPCGetVimLoadingState(componentHandle: number): Promise<RpcTypes.VimStatus>;
     RPCGhost(componentHandle: number, nodes: number[]): void;
     RPCGhostAll(componentHandle: number): void;
     RPCHide(componentHandle: number, nodes: number[]): void;
@@ -54,28 +53,28 @@ export declare class RpcClient {
     RPCLoadVim(fileName: string): Promise<number>;
     RPCLoadVimURL(url: string, authToken: string): Promise<number>;
     RPCLockIblRotation(lock: boolean): void;
-    RPCMouseButtonEvent(mousePos: Vector2, mouseButton: number, down: boolean): void;
-    RPCMouseDoubleClickEvent(mousePos: Vector2, mouseButton: number): void;
-    RPCMouseMoveEvent(mousePos: Vector2): void;
+    RPCMouseButtonEvent(mousePos: RpcTypes.Vector2, mouseButton: number, down: boolean): void;
+    RPCMouseDoubleClickEvent(mousePos: RpcTypes.Vector2, mouseButton: number): void;
+    RPCMouseMoveEvent(mousePos: RpcTypes.Vector2): void;
     RPCMouseScrollEvent(scrollValue: number): void;
-    RPCMouseSelectEvent(mousePos: Vector2, mouseButton: number): void;
-    RPCMoveCameraTo(usePosition: boolean, useTarget: boolean, position: Vector3, target: Vector3, blendTime: number): void;
+    RPCMouseSelectEvent(mousePos: RpcTypes.Vector2, mouseButton: number): void;
+    RPCMoveCameraTo(usePosition: boolean, useTarget: boolean, position: RpcTypes.Vector3, target: RpcTypes.Vector3, blendTime: number): void;
     RPCPauseRendering(pause: boolean): void;
-    RPCPerformHitTest(pos: Vector2): Promise<HitCheckResult>;
+    RPCPerformHitTest(pos: RpcTypes.Vector2): Promise<RpcTypes.HitCheckResult>;
     RPCRemoveNodeFlags(componentHandle: number, nodes: number[], flags: number): void;
     RPCSetAspectRatio(width: number, height: number): void;
     RPCSetCameraMode(orbit: boolean): void;
-    RPCSetCameraPosition(state: Segment, blendTime: number): void;
-    RPCSetGhostColor(ghostColor: RGBA): void;
-    RPCSetIblRotation(transform: Matrix44): void;
-    RPCSetLighting(toneMappingWhitePoint: number, hdrScale: number, hdrBackgroundScale: number, hdrBackgroundSaturation: number, backgroundBlur: number, backgroundColor: RGBA): void;
+    RPCSetCameraPosition(state: RpcTypes.Segment, blendTime: number): void;
+    RPCSetGhostColor(ghostColor: RpcTypes.RGBA): void;
+    RPCSetIblRotation(transform: RpcTypes.Matrix44): void;
+    RPCSetLighting(toneMappingWhitePoint: number, hdrScale: number, hdrBackgroundScale: number, hdrBackgroundSaturation: number, backgroundBlur: number, backgroundColor: RpcTypes.RGBA): void;
     RPCSetMaterialOverrides(componentHandle: number, nodes: number[], materialInstanceHandles: number[]): void;
     RPCSetMoveSpeed(speed: number): void;
-    RPCSetSectionBox(state: SectionBoxState): void;
+    RPCSetSectionBox(state: RpcTypes.SectionBoxState): void;
     RPCShow(componentHandle: number, nodes: number[]): void;
-    RPCShowAABBs(componentHandle: number, nodes: number[], colors: RGBA32[]): void;
+    RPCShowAABBs(componentHandle: number, nodes: number[], colors: RpcTypes.RGBA32[]): void;
     RPCShowAll(componentHandle: number): void;
-    RPCStartScene(toneMappingWhitePoint: number, hdrScale: number, hdrBackgroundScale: number, hdrBackgroundSaturation: number, backgroundBlur: number, backgroundColor: RGBA): Promise<boolean>;
+    RPCStartScene(toneMappingWhitePoint: number, hdrScale: number, hdrBackgroundScale: number, hdrBackgroundSaturation: number, backgroundBlur: number, backgroundColor: RpcTypes.RGBA): Promise<boolean>;
     RPCTriggerRenderDocCapture(): void;
     RPCUnloadVim(componentHandle: number): void;
 }

package/dist/types/core-viewers/ultra/rpcMarshal.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Don't modify this file, the RPC generated code depends on its interface.
+ */
+import * as RpcTypes from "./rpcTypes";
+export declare class Marshal {
+    private buffer;
+    private _dataView;
+    private _offset;
+    constructor(initialSize?: number);
+    getBuffer(): ArrayBuffer;
+    private ensureCapacity;
+    writeData(data: ArrayBuffer): void;
+    writeMatrix44(data: RpcTypes.Matrix44): void;
+    writeBoolean(value: boolean): void;
+    writeInt(value: number): void;
+    writeUInt(value: number): void;
+    writeFloat(value: number): void;
+    writeString(value: string): void;
+    writeHitCheckResult(data: RpcTypes.HitCheckResult): void;
+    writeVimStatus(data: RpcTypes.VimStatus): void;
+    writeVector2(data: RpcTypes.Vector2): void;
+    writeVector3(data: RpcTypes.Vector3): void;
+    writeRGBA(color: RpcTypes.RGBA): void;
+    writeRGB(color: RpcTypes.RGB): void;
+    writeRGBA32(color: RpcTypes.RGBA32): void;
+    writeSegment(segment: RpcTypes.Segment): void;
+    writeBox3(data: RpcTypes.Box3): void;
+    writeSectionBoxState(data: RpcTypes.SectionBoxState): void;
+    writeArrayOfInt(values: number[]): void;
+    writeArrayOfUInt(values: number[]): void;
+    writeArrayOfFloat(values: number[]): void;
+    writeArrayOfBool(values: boolean[]): void;
+    writeArrayOfRGBA32(values: RpcTypes.RGBA32[]): void;
+    writeArray<T>(data: T[], sizeT: number, write: (data: T) => void): void;
+}
+export declare class ReadMarshal {
+    private _dataView;
+    private _offset;
+    constructor(buffer: ArrayBuffer);
+    readMatrix44(): RpcTypes.Matrix44;
+    readInt(): number;
+    readUInt(): number;
+    readFloat(): number;
+    readBoolean(): boolean;
+    readString(): string;
+    readHitCheckResult(): RpcTypes.HitCheckResult;
+    readVimStatus(): RpcTypes.VimStatus;
+    readVector2(): RpcTypes.Vector2;
+    readVector3(): RpcTypes.Vector3;
+    readRGBA(): RpcTypes.RGBA;
+    readRGB(): RpcTypes.RGB;
+    readRGBA32(): RpcTypes.RGBA32;
+    readBox3(): RpcTypes.Box3;
+    readSegment(): RpcTypes.Segment;
+    readSectionBoxState(): RpcTypes.SectionBoxState;
+    readArrayOfInt(): number[];
+    readArrayOfUInt(): number[];
+    readArrayOfFloat(): number[];
+    readArrayOfBool(): boolean[];
+    readArrayOfRGBA32(): RpcTypes.RGBA32[];
+    readArray<T>(read: () => T): T[];
+}

package/dist/types/core-viewers/ultra/{viewer/rpcSafeClient.d.ts → rpcSafeClient.d.ts}

@@ -1,5 +1,4 @@
-import { Box3, RGBA, RGBA32, Segment, Vector2, Vector3 } from "../utils/math3d";
-import { HitCheckResult, SectionBoxState } from "./marshal";
+import * as RpcTypes from "./rpcTypes";
 import { MaterialHandle, RpcClient } from "./rpcClient";
 export type VimSource = {
     url: string;
@@ -19,7 +18,7 @@ export type SceneSettings = {
     hdrBackgroundScale: number;
     hdrBackgroundSaturation: number;
     backGroundBlur: number;
-    backgroundColor: RGBA;
+    backgroundColor: RpcTypes.RGBA;
 };
 export declare const defaultSceneSettings: SceneSettings;
 export declare enum VimLoadingStatus {
@@ -57,7 +56,7 @@ export declare class RpcSafeClient {
      */
     RPCSetLighting(settings: SceneSettings): void;
     RPCLockIblRotation(lock: boolean): void;
-    RPCGetSceneAABB(): Promise<Box3 | undefined>;
+    RPCGetSceneAABB(): Promise<RpcTypes.Box3 | undefined>;
     /*******************************************************************************
      * NODE VISIBILITY METHODS
      * Methods for controlling node visibility, including show/hide, ghosting,
@@ -131,7 +130,7 @@ export declare class RpcSafeClient {
      * @returns Promise resolving to the handle of the created text component
      * @throws {Error} If the text is empty
      */
-    RPCCreateText(position: Vector3, color: RGBA32, text: string): Promise<number>;
+    RPCCreateText(position: RpcTypes.Vector3, color: RpcTypes.RGBA32, text: string): Promise<number>;
     /**
      * Destroys a text component, removing it from the scene.
      * @param componentHandle - The handle of the text component to destroy
@@ -143,8 +142,8 @@ export declare class RpcSafeClient {
      * Methods for controlling section box visibility and position.
      ******************************************************************************/
     RPCEnableSectionBox(enable: boolean): void;
-    RPCSetSectionBox(state: SectionBoxState): void;
-    RPCGetSectionBox(): Promise<SectionBoxState | undefined>;
+    RPCSetSectionBox(state: RpcTypes.SectionBoxState): void;
+    RPCGetSectionBox(): Promise<RpcTypes.SectionBoxState | undefined>;
     /*******************************************************************************
      * CAMERA AND VIEW METHODS
      * Methods for controlling camera position, movement, framing, and view settings.
@@ -153,15 +152,15 @@ export declare class RpcSafeClient {
      * Retrieves the current camera position and orientation.
      * @returns Promise resolving to a segment representing the camera's current position and target
      */
-    RPCGetCameraPosition(): Promise<Segment | undefined>;
+    RPCGetCameraPosition(): Promise<RpcTypes.Segment | undefined>;
     /**
      * Sets the camera position and orientation.
      * @param segment - The desired camera position and target
      * @param blendTime - Duration of the camera transition in seconds (non-negative)
      * @throws {Error} If segment is invalid or blendTime is negative
      */
-    RPCSetCameraPosition(segment: Segment, blendTime: number): void;
-    RPCGetBoundingBoxAll(componentHandle: number): Promise<any>;
+    RPCSetCameraPosition(segment: RpcTypes.Segment, blendTime: number): void;
+    RPCGetBoundingBoxAll(componentHandle: number): Promise<RpcTypes.Box3 | undefined>;
     /**
      * Calculates the bounding box for specified nodes in a component.
      * Large node arrays are automatically processed in batches for better performance.
@@ -170,14 +169,14 @@ export declare class RpcSafeClient {
      * @returns Promise resolving to the combined bounding box
      * @throws {Error} If the component handle is invalid or nodes array is invalid
      */
-    RPCGetBoundingBox(componentHandle: number, nodes: number[]): Promise<Box3 | undefined>;
+    RPCGetBoundingBox(componentHandle: number, nodes: number[]): Promise<RpcTypes.Box3 | undefined>;
     private getBoundingBoxBatched;
     /**
      * Frames the camera to show all components in the scene.
      * @param blendTime - Duration of the camera transition in seconds (non-negative)
      * @returns Promise resolving to camera segment representing the final position
      */
-    RPCFrameAll(blendTime: number): Promise<Segment | undefined>;
+    RPCFrameAll(blendTime: number): Promise<RpcTypes.Segment | undefined>;
     /**
      * Frames a specific VIM component in the scene.
      * @param componentHandle - The handle of the VIM component to frame
@@ -185,7 +184,7 @@ export declare class RpcSafeClient {
      * @returns Promise resolving to camera segment representing the final position
      * @throws {Error} If the component handle is invalid
      */
-    RPCFrameVim(componentHandle: number, blendTime: number): Promise<Segment | undefined>;
+    RPCFrameVim(componentHandle: number, blendTime: number): Promise<RpcTypes.Segment | undefined>;
     /**
      * Frames specific instances within a component. For large numbers of instances,
      * automatically switches to bounding box framing for better performance.
@@ -195,14 +194,14 @@ export declare class RpcSafeClient {
      * @returns Promise resolving to camera segment representing the final position
      * @throws {Error} If the component handle is invalid or nodes array is empty
      */
-    RPCFrameInstances(componentHandle: number, nodes: number[], blendTime: number): Promise<Segment | undefined>;
+    RPCFrameInstances(componentHandle: number, nodes: number[], blendTime: number): Promise<RpcTypes.Segment | undefined>;
     /**
      * Frames the camera to show a specific bounding box.
      * @param box - The bounding box to frame
      * @param blendTime - Duration of the camera transition in seconds (non-negative)
      * @throws {Error} If the box is invalid (min values must be less than max values)
      */
-    RPCFrameBox(box: Box3, blendTime: number): Promise<Segment | undefined>;
+    RPCFrameBox(box: RpcTypes.Box3, blendTime: number): Promise<RpcTypes.Segment | undefined>;
     /*******************************************************************************
      * INPUT HANDLING METHODS
      * Methods for handling user input including mouse, keyboard, and camera controls.
@@ -260,13 +259,13 @@ export declare class RpcSafeClient {
      * Sets the color used for ghosted geometry.
      * @param ghostColor - The RGBA color to use for ghosted elements
      */
-    RPCSetGhostColor(ghostColor: RGBA): void;
+    RPCSetGhostColor(ghostColor: RpcTypes.RGBA): void;
     /**
      * Performs hit testing at a specified screen position.
      * @param pos - Normalized screen coordinates (0-1, 0-1)
      * @returns Promise resolving to hit test result if something was hit, undefined otherwise
      */
-    RPCPerformHitTest(pos: Vector2): Promise<HitCheckResult | undefined>;
+    RPCPerformHitTest(pos: RpcTypes.Vector2): Promise<RpcTypes.HitCheckResult | undefined>;
     /**
      * Sends a mouse button event to the viewer.
      * @param position - The normalized screen coordinates (0-1, 0-1)
@@ -274,19 +273,19 @@ export declare class RpcSafeClient {
      * @param down - True if button is pressed down, false if released
      * @throws {Error} If mouseButton is not a valid positive integer
      */
-    RPCMouseButtonEvent(position: Vector2, mouseButton: number, down: boolean): void;
+    RPCMouseButtonEvent(position: RpcTypes.Vector2, mouseButton: number, down: boolean): void;
     /**
      * Sends a mouse double-click event to the viewer.
      * @param position - The normalized screen coordinates (0-1, 0-1)
      * @param mouseButton - The mouse button code (0=left, 1=middle, 2=right)
      * @throws {Error} If mouseButton is not a valid positive integer
      */
-    RPCMouseDoubleClickEvent(position: Vector2, mouseButton: number): void;
+    RPCMouseDoubleClickEvent(position: RpcTypes.Vector2, mouseButton: number): void;
     /**
      * Sends a mouse movement event to the viewer.
      * @param position - The normalized screen coordinates (0-1, 0-1)
      */
-    RPCMouseMoveEvent(position: Vector2): void;
+    RPCMouseMoveEvent(position: RpcTypes.Vector2): void;
     /**
      * Sends a mouse scroll wheel event to the viewer.
      * @param scrollValue - The scroll amount (-1 to 1)
@@ -298,7 +297,7 @@ export declare class RpcSafeClient {
      * @param mouseButton - The mouse button code (0=left, 1=middle, 2=right)
      * @throws {Error} If mouseButton is not a valid positive integer
      */
-    RPCMouseSelectEvent(position: Vector2, mouseButton: number): void;
+    RPCMouseSelectEvent(position: RpcTypes.Vector2, mouseButton: number): void;
     /**
      * Sends a keyboard event to the viewer.
      * @param keyCode - The key code of the event
@@ -318,7 +317,7 @@ export declare class RpcSafeClient {
      * @returns Array of handles for the created material instances
      * @throws {Error} If the material handle is invalid or smoothness is out of range
      */
-    RPCCreateMaterialInstances(materialHandle: MaterialHandle, smoothness: number, colors: RGBA32[]): Promise<number[] | undefined>;
+    RPCCreateMaterialInstances(materialHandle: MaterialHandle, smoothness: number, colors: RpcTypes.RGBA32[]): Promise<number[] | undefined>;
     private createMaterialInstancesBatched;
     /**
      * Destroys multiple material instances, freeing associated resources.
@@ -378,7 +377,7 @@ export declare class RpcSafeClient {
      * @param colors - Array of colors for each AABB (must match nodes length)
      * @throws {Error} If arrays have different lengths or component handle is invalid
      */
-    RPCShowAABBs(componentHandle: number, nodes: number[], colors: RGBA32[]): void;
+    RPCShowAABBs(componentHandle: number, nodes: number[], colors: RpcTypes.RGBA32[]): void;
     /**
      * Hides the axis-aligned bounding boxes (AABBs) for specified nodes.
      * Large node arrays are automatically processed in batches.

package/dist/types/core-viewers/ultra/{utils/math3d.d.ts → rpcTypes.d.ts}

@@ -1,18 +1,9 @@
-export { Matrix4 as Matrix44, } from 'three';
-export { Vector2, Vector3, Box3 } from 'three';
-import { Vector2, Vector3 } from 'three';
-/**
- * Checks if two Vector2 objects are approximately equal.
- * @param v1 - First Vector2.
- * @param v2 - Second Vector2.
- * @param epsilon - Tolerance for floating-point comparisons.
- * @returns True if vectors are almost equal, false otherwise.
- */
-export declare function almostEqual(v1: Vector2, v2: Vector2, epsilon?: number): boolean;
+import * as THREE from 'three';
+export { Vector2, Vector3, Box3, Matrix4 as Matrix44 } from 'three';
 export declare class Segment {
-    origin: Vector3;
-    target: Vector3;
-    constructor(origin?: Vector3, target?: Vector3);
+    origin: THREE.Vector3;
+    target: THREE.Vector3;
+    constructor(origin?: THREE.Vector3, target?: THREE.Vector3);
     static fromArray(array: number[]): Segment;
     toArray(): number[];
     isValid(): boolean;
@@ -24,6 +15,7 @@ export declare class RGBA {
     b: number;
     a: number;
     constructor(r: number, g: number, b: number, a?: number);
+    clone(): RGBA;
     isValid(): boolean;
     equals(color: RGBA): boolean;
     static fromString(str: string): RGBA;
@@ -57,11 +49,19 @@ export declare class RGBA32 {
      */
     get a(): number;
 }
-/**
- * Remaps the given value from the range [0-1] to [0-max].
- */
-export declare function remap(value: number, max: number): number;
-/**
- * Clamps the given value between the given min and max.
- */
-export declare function clamp(value: number, min: number, max: number): number;
+export type HitCheckResult = {
+    vimHandle: number;
+    nodeIndex: number;
+    worldPosition: THREE.Vector3;
+    worldNormal: THREE.Vector3;
+};
+export type VimStatus = {
+    status: number;
+    progress: number;
+};
+export type SectionBoxState = {
+    visible: boolean;
+    interactive: boolean;
+    clip: boolean;
+    box: THREE.Box3;
+};