@relu-interactives/spatial-ecs 0.2.25 → 0.3.1

package/dist/index-YYypJaVw.d.cts

@@ -0,0 +1,488 @@
+import { k as EcsSystem, l as World } from './System-vrU46Vuw.cjs';
+import * as THREE from 'three';
+
+declare class AnimationSystem implements EcsSystem {
+    private readonly runtimeByEntity;
+    private readonly gltfLoader;
+    private readonly fbxLoader;
+    private loadClipsFromSource;
+    private refreshExternalClipSources;
+    private release;
+    update(world: World, deltaTime: number): void;
+    dispose(): void;
+}
+
+declare class CameraSyncSystem implements EcsSystem {
+    private readonly signatures;
+    update(world: World): void;
+}
+
+declare class ObjectVisibilitySystem implements EcsSystem {
+    update(world: World): void;
+}
+
+declare class EnvironmentSyncSystem implements EcsSystem {
+    private readonly scene;
+    private readonly textureLoader;
+    private signature;
+    private activeTexture;
+    private pendingImageUrl;
+    constructor(scene: THREE.Scene);
+    private disposeActiveTexture;
+    private applySkybox;
+    private applyFog;
+    update(world: World): void;
+    dispose(): void;
+}
+
+declare class PostprocessingSyncSystem implements EcsSystem {
+    private readonly renderer;
+    private readonly scene;
+    private readonly camera;
+    private signature;
+    private composer;
+    private composerEnabled;
+    constructor(renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.PerspectiveCamera);
+    private setComposerEnabled;
+    private disposeComposer;
+    private buildComposer;
+    update(world: World): void;
+    dispose(): void;
+}
+
+declare class PhysicsSyncSystem implements EcsSystem {
+    private readonly rigidBodyHandles;
+    private readonly colliderHandles;
+    private readonly rigidBodySignatures;
+    private readonly colliderSignatures;
+    private readonly isEditorMode;
+    private rapier;
+    private isBootstrappingWorld;
+    private accumulator;
+    constructor(options?: {
+        isEditor?: boolean;
+    });
+    private ensurePhysicsWorld;
+    private removeEntityPhysics;
+    update(world: World, deltaTime: number): void;
+    dispose(world: World): void;
+}
+
+declare class LightSyncSystem implements EcsSystem {
+    private readonly signatures;
+    update(world: World): void;
+}
+
+declare class MaterialSyncSystem implements EcsSystem {
+    private readonly signatures;
+    private readonly textureCache;
+    update(world: World): void;
+    dispose(): void;
+}
+
+declare class MeshGeometrySystem implements EcsSystem {
+    private readonly geometrySignatures;
+    private readonly shadowSignatures;
+    update(world: World): void;
+}
+
+/**
+ * Maintains the runtime geometry for entities with an {@link InstancedMeshComponent}.
+ *
+ * - **Primitive kinds** (`cube`, `sphere`, `plane`, `cylinder`, `capsule`): creates a single
+ *   `THREE.InstancedMesh` on the anchor and writes per-instance matrices every frame.
+ * - **Model kind** (`model`): asynchronously loads the GLTF/GLB at `comp.modelPath`, traverses
+ *   the scene to collect all `THREE.Mesh` nodes, and creates one `THREE.InstancedMesh` per mesh
+ *   (preserving the mesh's local transform and original materials). All sub-meshes are grouped
+ *   under a `THREE.Group` stored in `comp.instancedMesh`. Per-instance matrices are composed as
+ *   `instanceTransform × meshLocalMatrix` every frame.
+ *
+ * Geometry is rebuilt whenever the signature (`meshKind:parameters:instanceCount` for primitives,
+ * `model:path:instanceCount` for model kind) changes.
+ */
+declare class InstancedMeshSystem implements EcsSystem {
+    /** Signature tracking for geometry + instance count changes. */
+    private readonly geometrySignatures;
+    /** Signature being loaded per entity. Maps entityId → geometrySignature in-flight.
+     * Prevents re-dispatching a load every frame while comp.instancedMesh is still null. */
+    private readonly loadingSignatures;
+    /** Per-mesh data for model kind, populated after GLTF load. */
+    private readonly modelMeshEntries;
+    /**
+     * System-internal ref to the Three.js mesh/group most recently placed on
+     * the anchor by this system. Used for cleanup on rebuild instead of
+     * `comp.instancedMesh`, which can be stale (pointing to a disposed mesh)
+     * after an undo/redo restores a history snapshot captured at an earlier
+     * geometry configuration. Relying on the stale comp ref would skip removal
+     * of the current live mesh → ghost mesh in the scene.
+     */
+    private readonly trackedMeshes;
+    update(world: World): void;
+}
+
+/**
+ * Shared infrastructure for the script-hosting systems (`ScriptBehaviourSystem`
+ * and `ScriptObjectSystem`): module loading, class resolution, data-envelope
+ * merge/resolve/serialize. Extracted verbatim from `ScriptBehaviourSystem` so
+ * both systems stay behaviourally identical for the parts they share.
+ */
+/** Resolves a script URL to its ES module namespace. */
+type ModuleLoader = (scriptUrl: string) => Promise<Record<string, unknown>>;
+
+/**
+ * Optional context that enables raycast-based onSelect / onDeselect dispatch.
+ * When provided, pointer/touch taps on the canvas fire a raycast against the
+ * scene. If the hit object (or any ancestor) carries userData.entityId, every
+ * Behaviour instance for that entity receives onSelect(); the previously
+ * selected entity's instances receive onDeselect().
+ */
+type SelectionContext = {
+    camera: THREE.Camera;
+    scene: THREE.Scene;
+    domElement: HTMLElement;
+};
+declare class ScriptBehaviourSystem implements EcsSystem {
+    private instances;
+    private loading;
+    private readonly moduleLoader;
+    private readonly selectionCtx;
+    private readonly raycaster;
+    private readonly ndcPointer;
+    private selectedEntityId;
+    private pendingEntityId;
+    private pointerDownPos;
+    private static readonly CLICK_THRESHOLD;
+    constructor(moduleLoader?: ModuleLoader, selectionContext?: SelectionContext);
+    /** Walk up the object hierarchy to find the nearest userData.entityId. */
+    private resolveEntityId;
+    /** Convert client (screen) coordinates to normalised device coordinates. */
+    private toNdc;
+    /** Fire raycast and queue the result to be dispatched in the next update(). */
+    private queueRaycast;
+    private onPointerDown;
+    private onPointerUp;
+    /**
+     * Apply a queued selection change.
+     * Calls onDeselect() on all behaviours of the previous entity and
+     * onSelect() on all behaviours of the newly selected entity.
+     */
+    private applySelection;
+    update(world: World, deltaTime: number): void;
+    dispose(world: World): void;
+    private loadBehaviour;
+}
+
+/** Tags the Object3D a script's `build()` returned, so reloads can find/remove it. */
+declare const SCRIPT_OBJECT_ROOT_FLAG = "__scriptObjectRoot";
+/**
+ * Builds, ticks, and disposes {@link ScriptObject} scripts. Unlike
+ * `ScriptBehaviourSystem`, this runs in the editor AND at runtime — there is NO
+ * `isEditorMode` gating anywhere here. A script's `build()` output is attached
+ * under the entity's `Object3DRef.object` (so it inherits transform, selection
+ * and visibility). `runtimeState` is written on transitions only (never every
+ * frame).
+ *
+ * Construct it and pass it to `World.setup({ systems })`.
+ *
+ * @category Systems
+ */
+declare class ScriptObjectSystem implements EcsSystem {
+    private readonly moduleLoader;
+    private instances;
+    private loading;
+    /** Bumped by invalidate*() so in-flight loads that predate it are discarded. */
+    private epoch;
+    constructor(moduleLoader?: ModuleLoader);
+    update(world: World, deltaTime: number): void;
+    private loadScriptObject;
+    /** Dispose a record's instance + built subtree. `keepTombstone` leaves an error marker. */
+    private teardownRecord;
+    private markError;
+    /** Dispose all live instances so the next update() reloads with fresh modules. */
+    invalidateAll(): void;
+    /** Invalidate only the entities whose script matches `scriptUrl`. */
+    invalidate(scriptUrl: string): void;
+    dispose(world: World): void;
+}
+
+/**
+ * Reconciles `AudioComponent` state with the underlying THREE.js audio objects
+ * each frame.
+ *
+ * **Playback** — drives `play()`, `pause()`, and `stop()` on the THREE.js
+ * audio node based on the `isPlaying` / `isPaused` flags set by
+ * `AudioComponent.play()`, `.pause()`, and `.stop()`.
+ *
+ * **Option sync** — detects changes to `loop`, `pitch`, `volume`,
+ * `refDistance`, `distanceModel`, and `rolloffFactor` and applies them live.
+ * Changes take effect on the next frame, so scripts and inspector edits during
+ * runtime are reflected without reloading the scene.
+ *
+ * Only active in **preview** mode (`isEditor: true` makes every update a
+ * no-op so the editor is unaffected).
+ *
+ * @category Systems
+ */
+declare class AudioSystem implements EcsSystem {
+    private readonly isEditor;
+    /** THREE.js `isPlaying` state captured at the end of the previous frame. */
+    private readonly prevPlayingState;
+    /** Snapshot of options applied in the previous frame, for change detection. */
+    private readonly prevOptions;
+    /** Tracks entities that were stopped due to invisibility. */
+    private readonly stoppedDueToInvisibility;
+    constructor({ isEditor }?: {
+        isEditor?: boolean;
+    });
+    update(world: World, _deltaTime: number): void;
+    /** Apply any changed options from the component to the THREE.js audio node. */
+    private _syncOptions;
+    dispose(_world: World): void;
+}
+
+/**
+ * Reconciles `VideoComponent` state with the underlying HTML video element
+ * and THREE.js mesh/material each frame.
+ *
+ * **Playback** — drives `play()`, `pause()`, and stop (pause + seek to 0) on
+ * the HTML `<video>` element based on the `isPlaying` / `isPaused` flags set
+ * by `VideoComponent.play()`, `.pause()`, and `.stop()`.
+ *
+ * **Option sync** — detects changes to `loop`, `volume`, `width`, `height`,
+ * and green-screen shader uniforms (`backgroundColor`, `similarity`,
+ * `smoothness`, `spill`) and applies them live without a scene reload.
+ *
+ * Only active in **preview** mode (`isEditor: true` makes every update a
+ * no-op so the editor is unaffected).
+ *
+ * @category Systems
+ */
+declare class VideoSystem implements EcsSystem {
+    private readonly isEditor;
+    /** Playback intent captured at the end of the previous frame. */
+    private readonly prevIntent;
+    /** Snapshot of options applied in the previous frame, for change detection. */
+    private readonly prevOptions;
+    /** Tracks entities that were manually paused due to invisibility. */
+    private readonly pausedDueToInvisibility;
+    constructor({ isEditor }?: {
+        isEditor?: boolean;
+    });
+    update(world: World, _deltaTime: number): void;
+    /** Apply any changed options from the component to the video element and mesh. */
+    private _syncOptions;
+    dispose(_world: World): void;
+}
+
+/**
+ * Shared vocabulary for the WebXR layer.
+ *
+ * The single most important design constraint here: **the three target
+ * platforms expose fundamentally different input models**, and a runtime that
+ * hard-codes one of them silently excludes the others.
+ *
+ * - Meta Quest / Pico  → motion controllers (trigger, grip, thumbstick) and,
+ *   optionally, tracked hands.
+ * - Android XR         → tracked hands are the PRIMARY input.
+ * - Apple Vision Pro   → no controllers at all. Input arrives as
+ *   `transient-pointer` sources that exist ONLY for the duration of a
+ *   gaze-and-pinch, appearing on pinch-start and disappearing on release.
+ *
+ * {@link XrInputState} normalizes all three into one shape so gameplay code and
+ * Behaviours are written once. Anything platform-specific is expressed as a
+ * capability (`kind`, `hasAxes`) rather than a branch on device name — we never
+ * sniff the user agent, per the WebXR guidance from every vendor.
+ */
+/** Which hand an input source belongs to (`none` for gaze / single-source devices). */
+type XrHandedness = "left" | "right" | "none";
+/**
+ * How an input source is physically driven.
+ *
+ * `transient-pointer` is the Vision Pro case: the source is EPHEMERAL — it is
+ * created when the user pinches and destroyed when they release, so it must
+ * never be cached across frames by identity.
+ */
+type XrInputKind = "controller" | "hand" | "transient-pointer" | "gaze";
+/**
+ * One frame of normalized input for a single source.
+ *
+ * Boolean actions follow the same pending→latched contract as the desktop
+ * `InputSystem`: `select` is the held state, while `selectStart` / `selectEnd`
+ * are true for exactly one frame. This lets Behaviours poll (`if (select)`) or
+ * edge-detect (`if (selectStart)`) without subscribing to events.
+ */
+type XrInputState = {
+    handedness: XrHandedness;
+    kind: XrInputKind;
+    /** False once the source disconnects (a released pinch on Vision Pro). */
+    connected: boolean;
+    /** Pointing ray in WORLD space, from the source's `targetRaySpace`. */
+    rayOrigin: THREE.Vector3;
+    rayDirection: THREE.Vector3;
+    /** Physical grip pose. Null for gaze and transient-pointer, which have no grip. */
+    gripPosition: THREE.Vector3 | null;
+    gripQuaternion: THREE.Quaternion | null;
+    /** Primary action: controller trigger, hand pinch, or Vision Pro gaze-pinch. */
+    select: boolean;
+    selectStart: boolean;
+    selectEnd: boolean;
+    /** Secondary action: controller grip squeeze. Never fires for hands/gaze. */
+    squeeze: boolean;
+    squeezeStart: boolean;
+    squeezeEnd: boolean;
+    /** Thumbstick / trackpad axes in [-1, 1]. Empty when {@link hasAxes} is false. */
+    axes: number[];
+    /** True only for sources with a physical stick — gates stick-driven locomotion. */
+    hasAxes: boolean;
+    /** Raw gamepad button pressed-states, when the source exposes a gamepad. */
+    buttons: boolean[];
+};
+/**
+ * What the ACTIVE session actually granted us.
+ *
+ * Always derived from `XRSession.enabledFeatures` — never from the device name.
+ * A feature being requested is not a promise it was granted, and support varies
+ * sharply per platform (e.g. Vision Pro grants no `immersive-ar` at all today).
+ */
+type XrCapabilities = {
+    /** The session's mode. `immersive-ar` implies passthrough / mixed reality. */
+    mode: "immersive-vr" | "immersive-ar" | "inline";
+    /** Tracked-hand joint data is available. */
+    handTracking: boolean;
+    /** Real-world plane detection (incubating; effectively Quest-only today). */
+    planeDetection: boolean;
+    /** Real-world mesh detection (draft spec; Quest-only today). */
+    meshDetection: boolean;
+    /** Per-frame depth buffer (Android XR stereo, Quest experimental). */
+    depthSensing: boolean;
+    /** Spatial anchors. */
+    anchors: boolean;
+    /** Ray-against-real-world hit testing. */
+    hitTest: boolean;
+    /** Everything the UA reported, verbatim, for diagnostics. */
+    enabledFeatures: string[];
+};
+/** Capabilities for "no session running" — every feature off. */
+declare const NO_XR_CAPABILITIES: XrCapabilities;
+/**
+ * Read granted features off a live session.
+ *
+ * `enabledFeatures` is optional in the spec and missing on some UAs; when it is
+ * absent we report nothing as granted rather than optimistically assuming
+ * support, so callers degrade instead of calling an API that will throw.
+ */
+declare function readXrCapabilities(session: XRSession | null, mode?: XrCapabilities["mode"]): XrCapabilities;
+
+declare class XRInputSystem implements EcsSystem {
+    private readonly records;
+    private session;
+    private readonly onSelectStart;
+    private readonly onSelectEnd;
+    private readonly onSqueezeStart;
+    private readonly onSqueezeEnd;
+    private mark;
+    private ensureRecord;
+    /** Bind to a session. Called by {@link XRSessionSystem} on session start. */
+    attachSession(session: XRSession): void;
+    /** Unbind and drop all per-source state. */
+    detachSession(): void;
+    update(world: World): void;
+    /** Every input source active this frame. */
+    getInputs(): XrInputState[];
+    /** The first source for a hand, or null. Prefer this for hand-specific logic. */
+    getInput(handedness: XrHandedness): XrInputState | null;
+    /** True while ANY source is selecting — the portable "is the user acting" check. */
+    isSelecting(): boolean;
+    dispose(): void;
+}
+
+declare class XRInteractionSystem implements EcsSystem {
+    private readonly inputSystem;
+    private readonly raycaster;
+    /** Which entity each source is holding. Keyed by source state identity. */
+    private readonly grabs;
+    private hoveredEntityId;
+    constructor(inputSystem: XRInputSystem);
+    update(world: World): void;
+    private collectInteractables;
+    /** Entity id of the nearest pointable hit along this source's ray, or null. */
+    private raycast;
+    private grab;
+    private moveHeld;
+    private release;
+    private releaseAll;
+    /**
+     * Where the "hand" is for this source. Controllers and tracked hands report a
+     * grip pose; gaze and transient-pointer sources have none, so we hold the
+     * object a fixed distance along the ray instead.
+     */
+    private handPosition;
+    private dispatch;
+    /** Entity currently under a pointer this frame, or null. */
+    getHoveredEntityId(): number | null;
+    /** True when any source is holding something. */
+    isGrabbing(): boolean;
+}
+
+declare class XRLocomotionSystem implements EcsSystem {
+    private readonly inputSystem;
+    private readonly raycaster;
+    /** Per-source latch so one stick push yields exactly one snap turn. */
+    private readonly turnLatched;
+    /** Where the pointer currently lands, for the consumer to draw a marker. */
+    private teleportPoint;
+    constructor(inputSystem: XRInputSystem);
+    update(world: World, deltaTime: number): void;
+    /**
+     * Snap turning, not smooth turning — rotating the view continuously is the
+     * single biggest cause of VR nausea, so the comfort-safe option is the one
+     * wired to the stick.
+     */
+    private applySnapTurn;
+    private applySmoothMove;
+    private applyTeleport;
+    private collectTeleportTargets;
+    /**
+     * Where the teleport pointer currently lands this frame, or null.
+     * Consumers use this to render an aim marker.
+     */
+    getTeleportPoint(): THREE.Vector3 | null;
+}
+
+/**
+ * Owns the immersive-session lifecycle and fans XR events out to Behaviours.
+ *
+ * Detects session start/end by polling `renderer.xr.isPresenting` rather than
+ * binding to `sessionstart`/`sessionend`: the session may already be running
+ * before this system is registered (the consumer owns the entry button), and
+ * polling a boolean makes the system correct regardless of construction order.
+ *
+ * Hook dispatch mirrors `ImageTargetAnchorSystem`'s AR precedent — walk live
+ * `ScriptComponent.scriptInstances` and call the public no-op hook — so XR and
+ * AR extend `Behaviour` the same way.
+ */
+declare class XRSessionSystem implements EcsSystem {
+    private presenting;
+    private capabilities;
+    private readonly inputSystem;
+    constructor(inputSystem?: XRInputSystem);
+    update(world: World): void;
+    private handleSessionStart;
+    private handleSessionEnd;
+    /**
+     * Relay this frame's one-frame select edges. Polling the latched state (rather
+     * than dispatching from the DOM event) keeps hook delivery on the ECS tick, so
+     * a Behaviour's `onSelectStart` always observes the same world state its
+     * `onUpdate` would.
+     */
+    private dispatchInputEdges;
+    private forEachBehaviour;
+    /** What the active session granted. `NO_XR_CAPABILITIES` when not presenting. */
+    getCapabilities(): XrCapabilities;
+    /** True while an immersive session is presenting. */
+    isPresenting(): boolean;
+    /** Convenience passthrough so consumers need only hold this system. */
+    getInputs(): XrInputState[];
+}
+
+export { AnimationSystem as A, CameraSyncSystem as C, EnvironmentSyncSystem as E, InstancedMeshSystem as I, LightSyncSystem as L, MaterialSyncSystem as M, NO_XR_CAPABILITIES as N, ObjectVisibilitySystem as O, PhysicsSyncSystem as P, SCRIPT_OBJECT_ROOT_FLAG as S, VideoSystem as V, type XrCapabilities as X, type XrInputState as a, AudioSystem as b, MeshGeometrySystem as c, type ModuleLoader as d, PostprocessingSyncSystem as e, ScriptBehaviourSystem as f, ScriptObjectSystem as g, type SelectionContext as h, XRInputSystem as i, XRInteractionSystem as j, XRLocomotionSystem as k, XRSessionSystem as l, type XrHandedness as m, type XrInputKind as n, readXrCapabilities as r };

package/dist/{index-BwiRJNIT.d.ts → index-w1oqWl_M.d.ts}

@@ -1,5 +1,5 @@
-import { A as AnimationComponent, a as AnimationComponentOptions, b as AudioComponent, C as CameraComponent, c as CameraComponentOptions, d as CameraProjection, e as CameraRuntimeType, f as ColliderShape, g as ColliderState, h as CubeMeshParameters, D as DEFAULT_COLLIDER_STATE, i as DEFAULT_INSTANCED_MESH_PARAMETERS, j as DEFAULT_INSTANCE_TRANSFORM, k as DEFAULT_MESH_GEOMETRY_PARAMETERS, l as DEFAULT_PHYSICS_STATE, m as DEFAULT_RIGIDBODY_STATE, E as EditableMeshObjectKind, n as EntityType, I as ImageComponent, o as ImageTarget, p as ImageTargetAnchor, q as ImageTargetAnchorOptions, r as ImageTargetReference, s as InstanceSlotComponent, t as InstanceTransform, u as InstancedMeshComponent, v as InstancedMeshKind, L as LightComponent, w as LightValueState, M as MaterialComponent, x as MaterialTypeValue, y as MaterialValueState, z as MeshComponent, B as MeshGeometryComponent, F as MeshGeometryParameters, G as MeshGeometryParametersByKind, H as ModelComponent, N as Name, O as Object3DRef, P as PhysicsComponent, J as PhysicsState, K as PlaneMeshParameters, R as RadiusHeightMeshParameters, Q as RadiusMeshParameters, S as RigidbodyState, T as RigidbodyType, U as ScriptComponent, V as ScriptEntry, W as ScriptObjectComponent, X as ScriptObjectComponentInput, Y as ScriptObjectRuntimeState, Z as Selectable, _ as SelectionTransformState, $ as SpriteComponent, a0 as TextureFilteringValue, a1 as TransformModeValue, a2 as TransformSpaceValue, a3 as VideoComponent, a4 as defaultMaterialValue, a5 as normalizePhysicsState, a6 as setPhysicsLiveRef } from './Video-DlZ4G9ig.js';
-import { C as Component, D as DEFAULT_ENVIRONMENT_STATE, a as DEFAULT_POSTPROCESSING_STATE, E as Environment, b as EnvironmentFogState, c as EnvironmentFogType, d as EnvironmentGradientEffect, e as EnvironmentSkyboxState, f as EnvironmentSkyboxType, g as EnvironmentState, P as ParentId, h as Postprocessing, i as PostprocessingState, T as TransformComponent, j as TransformData, V as Vec3 } from './System-CYWZ_Zx5.js';
+import { A as AnimationComponent, a as AnimationComponentOptions, b as AudioComponent, C as CameraComponent, c as CameraComponentOptions, d as CameraProjection, e as CameraRuntimeType, f as ColliderShape, g as ColliderState, h as CubeMeshParameters, D as DEFAULT_COLLIDER_STATE, i as DEFAULT_INSTANCED_MESH_PARAMETERS, j as DEFAULT_INSTANCE_TRANSFORM, k as DEFAULT_MESH_GEOMETRY_PARAMETERS, l as DEFAULT_PHYSICS_STATE, m as DEFAULT_RIGIDBODY_STATE, E as EditableMeshObjectKind, n as EntityType, I as ImageComponent, o as ImageTarget, p as ImageTargetAnchor, q as ImageTargetAnchorOptions, r as ImageTargetReference, s as InstanceSlotComponent, t as InstanceTransform, u as InstancedMeshComponent, v as InstancedMeshKind, L as LightComponent, w as LightValueState, M as MaterialComponent, x as MaterialTypeValue, y as MaterialValueState, z as MeshComponent, B as MeshGeometryComponent, F as MeshGeometryParameters, G as MeshGeometryParametersByKind, H as ModelComponent, N as Name, O as Object3DRef, P as PhysicsComponent, J as PhysicsState, K as PlaneMeshParameters, R as RadiusHeightMeshParameters, Q as RadiusMeshParameters, S as RigidbodyState, T as RigidbodyType, U as ScriptComponent, V as ScriptEntry, W as ScriptObjectComponent, X as ScriptObjectComponentInput, Y as ScriptObjectRuntimeState, Z as Selectable, _ as SelectionTransformState, $ as SpriteComponent, a0 as TextureFilteringValue, a1 as TransformModeValue, a2 as TransformSpaceValue, a3 as VRTeleportAreaComponent, a4 as VRTeleportAreaOptions, a5 as VideoComponent, a6 as VrTeleportShape, a7 as XRInteractableComponent, a8 as XRInteractableOptions, a9 as XRRigComponent, aa as XRRigOptions, ab as XrGrabMode, ac as XrLocomotionMode, ad as defaultMaterialValue, ae as normalizePhysicsState, af as setPhysicsLiveRef } from './XRRig-CAmf04NX.js';
+import { C as Component, D as DEFAULT_ENVIRONMENT_STATE, a as DEFAULT_POSTPROCESSING_STATE, E as Environment, b as EnvironmentFogState, c as EnvironmentFogType, d as EnvironmentGradientEffect, e as EnvironmentSkyboxState, f as EnvironmentSkyboxType, g as EnvironmentState, P as ParentId, h as Postprocessing, i as PostprocessingState, T as TransformComponent, j as TransformData, V as Vec3 } from './System-vrU46Vuw.js';
 
 /**
  * Marks the ROOT entity of a prefab instance and records its link to the
@@ -143,13 +143,22 @@ declare const index_TransformComponent: typeof TransformComponent;
 declare const index_TransformData: typeof TransformData;
 declare const index_TransformModeValue: typeof TransformModeValue;
 declare const index_TransformSpaceValue: typeof TransformSpaceValue;
+declare const index_VRTeleportAreaComponent: typeof VRTeleportAreaComponent;
+declare const index_VRTeleportAreaOptions: typeof VRTeleportAreaOptions;
 declare const index_Vec3: typeof Vec3;
 declare const index_VideoComponent: typeof VideoComponent;
+declare const index_VrTeleportShape: typeof VrTeleportShape;
+declare const index_XRInteractableComponent: typeof XRInteractableComponent;
+declare const index_XRInteractableOptions: typeof XRInteractableOptions;
+declare const index_XRRigComponent: typeof XRRigComponent;
+declare const index_XRRigOptions: typeof XRRigOptions;
+declare const index_XrGrabMode: typeof XrGrabMode;
+declare const index_XrLocomotionMode: typeof XrLocomotionMode;
 declare const index_defaultMaterialValue: typeof defaultMaterialValue;
 declare const index_normalizePhysicsState: typeof normalizePhysicsState;
 declare const index_setPhysicsLiveRef: typeof setPhysicsLiveRef;
 declare namespace index {
-  export { index_AnimationComponent as AnimationComponent, index_AnimationComponentOptions as AnimationComponentOptions, index_AudioComponent as AudioComponent, index_CameraComponent as CameraComponent, index_CameraComponentOptions as CameraComponentOptions, index_CameraProjection as CameraProjection, index_CameraRuntimeType as CameraRuntimeType, index_ColliderShape as ColliderShape, index_ColliderState as ColliderState, index_CubeMeshParameters as CubeMeshParameters, index_DEFAULT_COLLIDER_STATE as DEFAULT_COLLIDER_STATE, index_DEFAULT_ENVIRONMENT_STATE as DEFAULT_ENVIRONMENT_STATE, index_DEFAULT_INSTANCED_MESH_PARAMETERS as DEFAULT_INSTANCED_MESH_PARAMETERS, index_DEFAULT_INSTANCE_TRANSFORM as DEFAULT_INSTANCE_TRANSFORM, index_DEFAULT_MESH_GEOMETRY_PARAMETERS as DEFAULT_MESH_GEOMETRY_PARAMETERS, index_DEFAULT_PHYSICS_STATE as DEFAULT_PHYSICS_STATE, index_DEFAULT_POSTPROCESSING_STATE as DEFAULT_POSTPROCESSING_STATE, index_DEFAULT_RIGIDBODY_STATE as DEFAULT_RIGIDBODY_STATE, index_EditableMeshObjectKind as EditableMeshObjectKind, index_EntityType as EntityType, index_Environment as Environment, index_EnvironmentFogState as EnvironmentFogState, index_EnvironmentFogType as EnvironmentFogType, index_EnvironmentGradientEffect as EnvironmentGradientEffect, index_EnvironmentSkyboxState as EnvironmentSkyboxState, index_EnvironmentSkyboxType as EnvironmentSkyboxType, index_EnvironmentState as EnvironmentState, index_ImageComponent as ImageComponent, index_ImageTarget as ImageTarget, index_ImageTargetAnchor as ImageTargetAnchor, index_ImageTargetAnchorOptions as ImageTargetAnchorOptions, index_ImageTargetReference as ImageTargetReference, index_InstanceSlotComponent as InstanceSlotComponent, index_InstanceTransform as InstanceTransform, index_InstancedMeshComponent as InstancedMeshComponent, index_InstancedMeshKind as InstancedMeshKind, index_LightComponent as LightComponent, index_LightValueState as LightValueState, index_MaterialComponent as MaterialComponent, index_MaterialTypeValue as MaterialTypeValue, index_MaterialValueState as MaterialValueState, index_MeshComponent as MeshComponent, index_MeshGeometryComponent as MeshGeometryComponent, index_MeshGeometryParameters as MeshGeometryParameters, index_MeshGeometryParametersByKind as MeshGeometryParametersByKind, index_ModelComponent as ModelComponent, index_Name as Name, index_Object3DRef as Object3DRef, index_ParentId as ParentId, index_PhysicsComponent as PhysicsComponent, index_PhysicsState as PhysicsState, index_PlaneMeshParameters as PlaneMeshParameters, index_Postprocessing as Postprocessing, index_PostprocessingState as PostprocessingState, index_PrefabInstance as PrefabInstance, index_PrefabNode as PrefabNode, index_RadiusHeightMeshParameters as RadiusHeightMeshParameters, index_RadiusMeshParameters as RadiusMeshParameters, index_RigidbodyState as RigidbodyState, index_RigidbodyType as RigidbodyType, index_ScriptComponent as ScriptComponent, index_ScriptEntry as ScriptEntry, index_ScriptObjectComponent as ScriptObjectComponent, index_ScriptObjectComponentInput as ScriptObjectComponentInput, index_ScriptObjectRuntimeState as ScriptObjectRuntimeState, index_Selectable as Selectable, index_SelectionTransformState as SelectionTransformState, index_SpriteComponent as SpriteComponent, index_TextureFilteringValue as TextureFilteringValue, index_TransformComponent as TransformComponent, index_TransformData as TransformData, index_TransformModeValue as TransformModeValue, index_TransformSpaceValue as TransformSpaceValue, index_Vec3 as Vec3, index_VideoComponent as VideoComponent, index_defaultMaterialValue as defaultMaterialValue, index_normalizePhysicsState as normalizePhysicsState, index_setPhysicsLiveRef as setPhysicsLiveRef };
+  export { index_AnimationComponent as AnimationComponent, index_AnimationComponentOptions as AnimationComponentOptions, index_AudioComponent as AudioComponent, index_CameraComponent as CameraComponent, index_CameraComponentOptions as CameraComponentOptions, index_CameraProjection as CameraProjection, index_CameraRuntimeType as CameraRuntimeType, index_ColliderShape as ColliderShape, index_ColliderState as ColliderState, index_CubeMeshParameters as CubeMeshParameters, index_DEFAULT_COLLIDER_STATE as DEFAULT_COLLIDER_STATE, index_DEFAULT_ENVIRONMENT_STATE as DEFAULT_ENVIRONMENT_STATE, index_DEFAULT_INSTANCED_MESH_PARAMETERS as DEFAULT_INSTANCED_MESH_PARAMETERS, index_DEFAULT_INSTANCE_TRANSFORM as DEFAULT_INSTANCE_TRANSFORM, index_DEFAULT_MESH_GEOMETRY_PARAMETERS as DEFAULT_MESH_GEOMETRY_PARAMETERS, index_DEFAULT_PHYSICS_STATE as DEFAULT_PHYSICS_STATE, index_DEFAULT_POSTPROCESSING_STATE as DEFAULT_POSTPROCESSING_STATE, index_DEFAULT_RIGIDBODY_STATE as DEFAULT_RIGIDBODY_STATE, index_EditableMeshObjectKind as EditableMeshObjectKind, index_EntityType as EntityType, index_Environment as Environment, index_EnvironmentFogState as EnvironmentFogState, index_EnvironmentFogType as EnvironmentFogType, index_EnvironmentGradientEffect as EnvironmentGradientEffect, index_EnvironmentSkyboxState as EnvironmentSkyboxState, index_EnvironmentSkyboxType as EnvironmentSkyboxType, index_EnvironmentState as EnvironmentState, index_ImageComponent as ImageComponent, index_ImageTarget as ImageTarget, index_ImageTargetAnchor as ImageTargetAnchor, index_ImageTargetAnchorOptions as ImageTargetAnchorOptions, index_ImageTargetReference as ImageTargetReference, index_InstanceSlotComponent as InstanceSlotComponent, index_InstanceTransform as InstanceTransform, index_InstancedMeshComponent as InstancedMeshComponent, index_InstancedMeshKind as InstancedMeshKind, index_LightComponent as LightComponent, index_LightValueState as LightValueState, index_MaterialComponent as MaterialComponent, index_MaterialTypeValue as MaterialTypeValue, index_MaterialValueState as MaterialValueState, index_MeshComponent as MeshComponent, index_MeshGeometryComponent as MeshGeometryComponent, index_MeshGeometryParameters as MeshGeometryParameters, index_MeshGeometryParametersByKind as MeshGeometryParametersByKind, index_ModelComponent as ModelComponent, index_Name as Name, index_Object3DRef as Object3DRef, index_ParentId as ParentId, index_PhysicsComponent as PhysicsComponent, index_PhysicsState as PhysicsState, index_PlaneMeshParameters as PlaneMeshParameters, index_Postprocessing as Postprocessing, index_PostprocessingState as PostprocessingState, index_PrefabInstance as PrefabInstance, index_PrefabNode as PrefabNode, index_RadiusHeightMeshParameters as RadiusHeightMeshParameters, index_RadiusMeshParameters as RadiusMeshParameters, index_RigidbodyState as RigidbodyState, index_RigidbodyType as RigidbodyType, index_ScriptComponent as ScriptComponent, index_ScriptEntry as ScriptEntry, index_ScriptObjectComponent as ScriptObjectComponent, index_ScriptObjectComponentInput as ScriptObjectComponentInput, index_ScriptObjectRuntimeState as ScriptObjectRuntimeState, index_Selectable as Selectable, index_SelectionTransformState as SelectionTransformState, index_SpriteComponent as SpriteComponent, index_TextureFilteringValue as TextureFilteringValue, index_TransformComponent as TransformComponent, index_TransformData as TransformData, index_TransformModeValue as TransformModeValue, index_TransformSpaceValue as TransformSpaceValue, index_VRTeleportAreaComponent as VRTeleportAreaComponent, index_VRTeleportAreaOptions as VRTeleportAreaOptions, index_Vec3 as Vec3, index_VideoComponent as VideoComponent, index_VrTeleportShape as VrTeleportShape, index_XRInteractableComponent as XRInteractableComponent, index_XRInteractableOptions as XRInteractableOptions, index_XRRigComponent as XRRigComponent, index_XRRigOptions as XRRigOptions, index_XrGrabMode as XrGrabMode, index_XrLocomotionMode as XrLocomotionMode, index_defaultMaterialValue as defaultMaterialValue, index_normalizePhysicsState as normalizePhysicsState, index_setPhysicsLiveRef as setPhysicsLiveRef };
 }
 
 export { PrefabInstance as P, PrefabNode as a, index as i };