@relu-interactives/spatial-ecs 0.3.4 → 0.3.6

package/dist/{chunk-ID266ZUA.js → chunk-WRJ2K3LZ.js}

@@ -1,5 +1,5 @@
-import { resolveDracoDecoderPath, applyTransform, SHARED_MODEL_RESOURCE_FLAG } from './chunk-2LVFGVWI.js';
-import { AnimationComponent, ModelComponent, CameraComponent, Object3DRef, Environment, Postprocessing, TransformComponent, PhysicsComponent, setPhysicsLiveRef, LightComponent, MaterialComponent, DEFAULT_MESH_GEOMETRY_PARAMETERS, MeshGeometryComponent, InstancedMeshComponent, ParentId, ScriptComponent, ScriptObjectComponent, XRRigComponent, VRTeleportAreaComponent, XRInteractableComponent, InstanceSlotComponent, Name, ImageComponent, SpriteComponent, VideoComponent, AudioComponent, ImageTarget, Selectable, PrefabNode, PrefabInstance } from './chunk-6QC2PJLD.js';
+import { resolveDracoDecoderPath, applyTransform, SHARED_MODEL_RESOURCE_FLAG } from './chunk-JRJ3CL5H.js';
+import { AnimationComponent, ModelComponent, CameraComponent, Object3DRef, Environment, Postprocessing, TransformComponent, PhysicsComponent, setPhysicsLiveRef, LightComponent, MaterialComponent, DEFAULT_MESH_GEOMETRY_PARAMETERS, MeshGeometryComponent, InstancedMeshComponent, ParentId, ScriptComponent, ScriptObjectComponent, XRRigComponent, VRTeleportAreaComponent, XRInteractableComponent, XRInteractorComponent, XRInteractorSideComponent, InstanceSlotComponent, Name, ImageComponent, SpriteComponent, VideoComponent, AudioComponent, ImageTarget, Selectable, PrefabNode, PrefabInstance } from './chunk-N4GKZ7IV.js';
 import { __name } from './chunk-OY7ZODZP.js';
 import * as THREE7 from 'three';
 import { DRACOLoader } from 'three/examples/jsm/loaders/DRACOLoader.js';
@@ -2791,6 +2791,14 @@ function buildComponentValueMaps(snapshot) {
       snapshot.components,
       "XRInteractableComponent"
     ),
+    xrInteractorValues: readByComponent(
+      snapshot.components,
+      "XRInteractorComponent"
+    ),
+    xrInteractorSideValues: readByComponent(
+      snapshot.components,
+      "XRInteractorSideComponent"
+    ),
     instancedMeshValues: readByComponent(snapshot.components, "InstancedMeshComponent"),
     instanceSlotValues: readByComponent(snapshot.components, "InstanceSlotComponent"),
     prefabNodeValues: readByComponent(snapshot.components, "PrefabNode"),
@@ -2977,6 +2985,60 @@ function restorePostCreateComponents(world, objectManagementSystem, targetEntity
       }
     }
   }
+  {
+    const sourceInteractor = asRecord(
+      values.xrInteractorValues.get(sourceEntityId)
+    );
+    const interactor = world.getComponent(targetEntityId, XRInteractorComponent);
+    if (sourceInteractor && interactor) {
+      if (typeof sourceInteractor.interactorType === "string") {
+        interactor.interactorType = sourceInteractor.interactorType;
+      }
+      if (typeof sourceInteractor.handPreset === "string") {
+        interactor.handPreset = sourceInteractor.handPreset;
+      }
+      if (typeof sourceInteractor.handColor === "string") {
+        interactor.handColor = sourceInteractor.handColor;
+      }
+      if (typeof sourceInteractor.handOpacity === "number") {
+        interactor.handOpacity = sourceInteractor.handOpacity;
+      }
+      if (typeof sourceInteractor.handEmissiveIntensity === "number") {
+        interactor.handEmissiveIntensity = sourceInteractor.handEmissiveIntensity;
+      }
+      if (typeof sourceInteractor.showRay === "boolean") {
+        interactor.showRay = sourceInteractor.showRay;
+      }
+    }
+  }
+  {
+    const sourceSide = asRecord(
+      values.xrInteractorSideValues.get(sourceEntityId)
+    );
+    if (sourceSide && typeof sourceSide.side === "string") {
+      const existing = world.getComponent(
+        targetEntityId,
+        XRInteractorSideComponent
+      );
+      if (existing) {
+        existing.side = sourceSide.side;
+      } else {
+        world.addComponent(
+          targetEntityId,
+          new XRInteractorSideComponent({
+            side: sourceSide.side
+          })
+        );
+      }
+    }
+  }
+  {
+    const sourceRigOrigin = asRecord(values.xrRigValues.get(sourceEntityId));
+    const rigForOrigin = world.getComponent(targetEntityId, XRRigComponent);
+    if (sourceRigOrigin && rigForOrigin && typeof sourceRigOrigin.trackingOrigin === "string") {
+      rigForOrigin.trackingOrigin = sourceRigOrigin.trackingOrigin;
+    }
+  }
   {
     const imComponent = world.getComponent(targetEntityId, InstancedMeshComponent);
     if (imComponent && imComponent.instanceEntityIds.length > 0) {
@@ -3566,6 +3628,7 @@ var HYDRATABLE_ENTITY_KINDS = /* @__PURE__ */ new Set([
   "instanceSlot",
   "scriptObject",
   "xrRig",
+  "xrInteractor",
   "teleportArea"
 ]);
 
@@ -6119,6 +6182,9 @@ var _XRInputSystem = class _XRInputSystem {
         state.hasAxes = false;
         state.buttons = [];
       }
+    }
+    for (const record of this.records.values()) {
+      const state = record.state;
       if (record.pendingSelectStart) {
         state.select = true;
         state.selectStart = true;
@@ -6316,6 +6382,45 @@ var _XRInteractionSystem = class _XRInteractionSystem {
 };
 __name(_XRInteractionSystem, "XRInteractionSystem");
 var XRInteractionSystem = _XRInteractionSystem;
+var ARC_GRAVITY = 9.8;
+var ARC_SPEED = 7;
+var ARC_STEPS = 24;
+var ARC_MAX_TIME = 2;
+function sampleTeleportArc(origin, direction, out = [], options) {
+  const speed = options?.speed ?? ARC_SPEED;
+  const gravity = options?.gravity ?? ARC_GRAVITY;
+  const steps = Math.max(2, options?.steps ?? ARC_STEPS);
+  const maxTime = options?.maxTime ?? ARC_MAX_TIME;
+  out.length = 0;
+  const velocity = direction.clone().normalize().multiplyScalar(speed);
+  for (let i = 0; i < steps; i += 1) {
+    const t = i / (steps - 1) * maxTime;
+    out.push(
+      new THREE7.Vector3(
+        origin.x + velocity.x * t,
+        origin.y + velocity.y * t - 0.5 * gravity * t * t,
+        origin.z + velocity.z * t
+      )
+    );
+  }
+  return out;
+}
+__name(sampleTeleportArc, "sampleTeleportArc");
+function arcGroundCrossing(points, groundY) {
+  for (let i = 1; i < points.length; i += 1) {
+    const previous = points[i - 1];
+    const current = points[i];
+    if (previous.y >= groundY && current.y <= groundY) {
+      const span = previous.y - current.y;
+      const alpha = span > 1e-6 ? (previous.y - groundY) / span : 0;
+      return new THREE7.Vector3().lerpVectors(previous, current, alpha);
+    }
+  }
+  return null;
+}
+__name(arcGroundCrossing, "arcGroundCrossing");
+
+// core/systems/XRLocomotionSystem.ts
 var UP = new THREE7.Vector3(0, 1, 0);
 var AXIS_DEADZONE = 0.5;
 var _XRLocomotionSystem = class _XRLocomotionSystem {
@@ -6323,13 +6428,26 @@ var _XRLocomotionSystem = class _XRLocomotionSystem {
     this.raycaster = new THREE7.Raycaster();
     /** Per-source latch so one stick push yields exactly one snap turn. */
     this.turnLatched = /* @__PURE__ */ new WeakSet();
-    /** Where the pointer currently lands, for the consumer to draw a marker. */
-    this.teleportPoint = null;
+    /** Reused arc buffer — aiming runs every frame. */
+    this.arcPoints = [];
+    /** Curve up to the landing point, for the visual system. Empty when not aiming. */
+    this.aimCurve = [];
+    this.landingPoint = null;
+    /** True once we've tried to self-heal camera parenting for this session. */
+    this.parentingChecked = false;
     this.inputSystem = inputSystem;
   }
   update(world, deltaTime) {
-    this.teleportPoint = null;
-    if (!world.isXrPresenting()) return;
+    this.aimCurve = [];
+    this.landingPoint = null;
+    if (!world.isXrPresenting()) {
+      this.parentingChecked = false;
+      return;
+    }
+    if (!this.parentingChecked) {
+      this.parentingChecked = true;
+      this.ensureCameraUnderRig(world);
+    }
     const rigEntityId = world.query(XRRigComponent, TransformComponent)[0];
     if (typeof rigEntityId !== "number") return;
     const rig = world.getComponent(rigEntityId, XRRigComponent);
@@ -6346,9 +6464,37 @@ var _XRLocomotionSystem = class _XRLocomotionSystem {
       this.applySmoothMove(world, rig, rigTransform, inputs, deltaTime);
     }
   }
+  /**
+   * Guarantee the render camera is a CHILD of the rig.
+   *
+   * Locomotion moves the rig, and three composes the head pose against
+   * `camera.parent` — so if the camera sits at the scene root instead, moving
+   * the rig does nothing at all and the player is frozen in place. Scenes
+   * authored before the rig existed (or with the camera re-parented by hand)
+   * would otherwise silently fail to move, which is exactly the symptom that is
+   * hardest to diagnose from inside a headset. Repairing it via `ParentId` lets
+   * `ObjectManagementSystem` reconcile the scene graph normally.
+   */
+  ensureCameraUnderRig(world) {
+    const rigEntityId = world.query(XRRigComponent)[0];
+    if (typeof rigEntityId !== "number") return;
+    const activeCamera = world.getCamera();
+    for (const entityId of world.query(CameraComponent, Object3DRef)) {
+      if (world.getComponent(entityId, Object3DRef)?.object !== activeCamera) {
+        continue;
+      }
+      const parent = world.getComponent(entityId, ParentId);
+      if (parent) {
+        if (parent.value !== rigEntityId) parent.value = rigEntityId;
+      } else {
+        world.addComponent(entityId, new ParentId(rigEntityId));
+      }
+      return;
+    }
+  }
   /**
    * 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
+   * single biggest cause of VR nausea, so the comfort-safe option is what's
    * wired to the stick.
    */
   applySnapTurn(rig, transform, inputs) {
@@ -6362,8 +6508,7 @@ var _XRLocomotionSystem = class _XRLocomotionSystem {
       }
       if (this.turnLatched.has(source)) continue;
       this.turnLatched.add(source);
-      const step = THREE7.MathUtils.degToRad(rig.snapTurnDegrees);
-      transform.rotation.y -= Math.sign(x) * step;
+      transform.rotation.y -= Math.sign(x) * THREE7.MathUtils.degToRad(rig.snapTurnDegrees);
     }
   }
   applySmoothMove(world, rig, transform, inputs, deltaTime) {
@@ -6388,17 +6533,42 @@ var _XRLocomotionSystem = class _XRLocomotionSystem {
     const targets = this.collectTeleportTargets(world);
     if (targets.length === 0) return;
     for (const input of inputs) {
-      this.raycaster.set(input.rayOrigin, input.rayDirection);
-      const hit = this.raycaster.intersectObjects(targets, true)[0];
+      if (!input.select && !input.selectEnd) continue;
+      const points = sampleTeleportArc(
+        input.rayOrigin,
+        input.rayDirection,
+        this.arcPoints
+      );
+      const hit = this.raycastArc(points, targets);
       if (!hit) continue;
-      this.teleportPoint = hit.point.clone();
+      this.landingPoint = hit.point;
+      this.aimCurve = points.slice(0, hit.segmentIndex + 1).concat(hit.point);
       if (input.selectEnd) {
         transform.position.x = hit.point.x;
         transform.position.y = hit.point.y;
         transform.position.z = hit.point.z;
+        this.aimCurve = [];
+        this.landingPoint = null;
       }
     }
   }
+  /** Walk the arc segment-by-segment, returning the first surface hit. */
+  raycastArc(points, targets) {
+    for (let i = 1; i < points.length; i += 1) {
+      const from = points[i - 1];
+      const to = points[i];
+      const delta = new THREE7.Vector3().subVectors(to, from);
+      const distance = delta.length();
+      if (distance < 1e-6) continue;
+      this.raycaster.set(from, delta.divideScalar(distance));
+      this.raycaster.far = distance;
+      const hit = this.raycaster.intersectObjects(targets, true)[0];
+      if (hit) {
+        return { point: hit.point.clone(), segmentIndex: i - 1 };
+      }
+    }
+    return null;
+  }
   collectTeleportTargets(world) {
     const objects = [];
     for (const entityId of world.query(VRTeleportAreaComponent, Object3DRef)) {
@@ -6410,12 +6580,13 @@ var _XRLocomotionSystem = class _XRLocomotionSystem {
     }
     return objects;
   }
-  /**
-   * Where the teleport pointer currently lands this frame, or null.
-   * Consumers use this to render an aim marker.
-   */
-  getTeleportPoint() {
-    return this.teleportPoint;
+  /** Arc points up to the landing spot this frame; empty when not aiming. */
+  getAimCurve() {
+    return this.aimCurve;
+  }
+  /** Where the arc currently lands, or null when not aiming at a valid area. */
+  getLandingPoint() {
+    return this.landingPoint;
   }
 };
 __name(_XRLocomotionSystem, "XRLocomotionSystem");
@@ -6455,6 +6626,8 @@ var _XRSessionSystem = class _XRSessionSystem {
   constructor(inputSystem) {
     this.presenting = false;
     this.capabilities = NO_XR_CAPABILITIES;
+    /** Y compensation applied when a floor-relative space was requested but not granted. */
+    this.appliedOriginOffset = 0;
     this.inputSystem = inputSystem ?? null;
   }
   update(world) {
@@ -6478,11 +6651,59 @@ var _XRSessionSystem = class _XRSessionSystem {
     if (session && this.inputSystem) {
       this.inputSystem.attachSession(session);
     }
+    this.applyTrackingOrigin(world, session ?? null);
     this.forEachBehaviour(world, (behaviour) => {
       behaviour.onXRSessionStart(this.capabilities);
     });
   }
+  /**
+   * Apply the rig's authored tracking origin, and compensate when the device
+   * cannot honour it.
+   *
+   * `floor` (`local-floor`) puts Y=0 on the user's real floor, which is what a
+   * scene authored standing on the ground expects. `eye` (`local`) puts Y=0 at
+   * the headset, for seated experiences.
+   *
+   * The compensation matters: `local-floor` is only ever REQUESTED as an
+   * optional feature (requiring it would make `requestSession` reject outright
+   * on devices that lack it). When it isn't granted, the runtime silently falls
+   * back to `local` — the origin jumps to head height and a floor-authored
+   * scene swallows the user, which is exactly the "I'm standing under the
+   * building" symptom. Offsetting the rig down by the eye height restores the
+   * intended floor relationship instead of leaving it broken.
+   */
+  applyTrackingOrigin(world, session) {
+    const rigEntityId = world.query(XRRigComponent, TransformComponent)[0];
+    if (typeof rigEntityId !== "number") return;
+    const rig = world.getComponent(rigEntityId, XRRigComponent);
+    const transform = world.getComponent(rigEntityId, TransformComponent);
+    if (!rig || !transform) return;
+    const renderer = world.getRenderer();
+    const wantsFloor = rig.trackingOrigin === "floor";
+    try {
+      renderer.xr.setReferenceSpaceType(wantsFloor ? "local-floor" : "local");
+    } catch {
+    }
+    const granted = session?.enabledFeatures;
+    const floorGranted = Array.isArray(granted) ? granted.includes("local-floor") : (
+      // No report at all: trust the request, since a wrong offset is worse
+      // than none on devices that did honour it.
+      true
+    );
+    this.appliedOriginOffset = wantsFloor && !floorGranted ? rig.fallbackEyeHeight : 0;
+    if (this.appliedOriginOffset !== 0) {
+      transform.position.y -= this.appliedOriginOffset;
+    }
+  }
   handleSessionEnd(world) {
+    if (this.appliedOriginOffset !== 0) {
+      const rigEntityId = world.query(XRRigComponent, TransformComponent)[0];
+      if (typeof rigEntityId === "number") {
+        const transform = world.getComponent(rigEntityId, TransformComponent);
+        if (transform) transform.position.y += this.appliedOriginOffset;
+      }
+      this.appliedOriginOffset = 0;
+    }
     this.capabilities = NO_XR_CAPABILITIES;
     this.inputSystem?.detachSession();
     this.forEachBehaviour(world, (behaviour) => {
@@ -6576,16 +6797,75 @@ var _VRTeleportAreaSystem = class _VRTeleportAreaSystem {
 };
 __name(_VRTeleportAreaSystem, "VRTeleportAreaSystem");
 var VRTeleportAreaSystem = _VRTeleportAreaSystem;
+function createHandMaterial(preset, options) {
+  const color = new THREE7.Color(options.color);
+  switch (preset) {
+    case "ghost":
+      return new THREE7.MeshBasicMaterial({
+        color,
+        transparent: true,
+        opacity: Math.min(1, Math.max(0.05, options.opacity * 0.45)),
+        depthWrite: false,
+        side: THREE7.DoubleSide
+      });
+    case "neon":
+      return new THREE7.MeshStandardMaterial({
+        color,
+        emissive: color,
+        emissiveIntensity: Math.max(0.5, options.emissiveIntensity || 2),
+        roughness: 0.35,
+        metalness: 0,
+        transparent: options.opacity < 1,
+        opacity: options.opacity
+      });
+    case "skeleton":
+      return new THREE7.MeshBasicMaterial({
+        color,
+        wireframe: true,
+        transparent: true,
+        opacity: options.opacity
+      });
+    case "custom":
+    case "default":
+      return new THREE7.MeshStandardMaterial({
+        color,
+        roughness: 0.85,
+        metalness: 0,
+        emissive: color,
+        emissiveIntensity: Math.max(0, options.emissiveIntensity),
+        transparent: options.opacity < 1,
+        opacity: options.opacity,
+        side: THREE7.DoubleSide
+      });
+    default: {
+      return new THREE7.MeshStandardMaterial({ color });
+    }
+  }
+}
+__name(createHandMaterial, "createHandMaterial");
+function applyHandMaterial(root, material) {
+  root.traverse((child) => {
+    const mesh = child;
+    if (!mesh.isMesh) return;
+    mesh.material = material;
+  });
+}
+__name(applyHandMaterial, "applyHandMaterial");
+var SLOTS = [
+  { index: 0, side: "left" },
+  { index: 1, side: "right" }
+];
 var _XRControllerVisualSystem = class _XRControllerVisualSystem {
-  constructor(slots = 2) {
+  constructor(options) {
     this.controllerModelFactory = new XRControllerModelFactory();
     this.handModelFactory = new XRHandModelFactory();
     this.group = new THREE7.Group();
-    this.built = false;
+    this.slots = /* @__PURE__ */ new Map();
     this.attachedTo = null;
-    /** Index → whether we've already attached visuals for that slot. */
-    this.ready = /* @__PURE__ */ new Set();
-    this.slots = slots;
+    /** Last applied preset signature, so materials rebuild only on real change. */
+    this.handStyleSignature = "";
+    this.handMaterial = null;
+    this.interactionSystem = options?.interactionSystem ?? null;
     this.group.name = "XRControllerVisuals";
     this.group.userData.ecsPreviewHidden = true;
   }
@@ -6593,23 +6873,109 @@ var _XRControllerVisualSystem = class _XRControllerVisualSystem {
     const renderer = world.getRenderer();
     if (!renderer.xr?.enabled) return;
     this.ensureAttached(world);
-    if (this.built) return;
-    for (let index = 0; index < this.slots; index += 1) {
-      if (this.ready.has(index)) continue;
+    this.ensureSlots(world);
+    const interactor = this.resolveInteractor(world);
+    const type = interactor?.interactorType ?? "both";
+    const showControllers = type === "controllers" || type === "both";
+    const showHands = type === "hands" || type === "both";
+    this.syncHandMaterial(interactor);
+    for (const { index, side } of SLOTS) {
+      const visuals = this.slots.get(index);
+      if (!visuals) continue;
+      visuals.controllerModel.visible = showControllers;
+      visuals.handModel.visible = showHands;
+      visuals.ray.visible = this.shouldShowRay(interactor);
+      if (showHands && this.handMaterial) {
+        applyHandMaterial(visuals.handModel, this.handMaterial);
+      }
+      this.syncCustomContent(world, visuals, side);
+    }
+  }
+  /** The scene's interactor config, if one was authored. */
+  resolveInteractor(world) {
+    const entityId = world.query(XRInteractorComponent)[0];
+    if (typeof entityId !== "number") return null;
+    return world.getComponent(entityId, XRInteractorComponent) ?? null;
+  }
+  /**
+   * Re-parent the author's left/right interactor content onto the tracked grip
+   * space so it follows the hand.
+   *
+   * `ObjectManagementSystem` reconciles ECS objects back under their ParentId
+   * every frame, so this re-attach has to be re-asserted — the same coexistence
+   * dance the AR anchor system performs.
+   */
+  syncCustomContent(world, visuals, side) {
+    let content = null;
+    for (const entityId of world.query(
+      XRInteractorSideComponent,
+      Object3DRef
+    )) {
+      const slot = world.getComponent(entityId, XRInteractorSideComponent);
+      if (slot?.side !== side) continue;
+      content = world.getComponent(entityId, Object3DRef)?.object ?? null;
+      break;
+    }
+    if (!content) {
+      visuals.attachedCustom = null;
+      return;
+    }
+    if (content.parent !== visuals.grip) {
+      visuals.grip.add(content);
+    }
+    visuals.attachedCustom = content;
+  }
+  /** Rebuild the hand material only when the authored style actually changes. */
+  syncHandMaterial(interactor) {
+    const preset = interactor?.handPreset ?? "default";
+    const color = interactor?.handColor ?? "#e8b48a";
+    const opacity = interactor?.handOpacity ?? 1;
+    const emissive = interactor?.handEmissiveIntensity ?? 0;
+    const signature = `${preset}:${color}:${opacity}:${emissive}`;
+    if (signature === this.handStyleSignature && this.handMaterial) return;
+    this.handStyleSignature = signature;
+    this.handMaterial?.dispose();
+    this.handMaterial = createHandMaterial(preset, {
+      color,
+      opacity,
+      emissiveIntensity: emissive
+    });
+  }
+  /**
+   * The ray is meaningful only when it points at something. Authors can turn it
+   * off entirely; otherwise it appears on hover/grab so it isn't permanent
+   * clutter implying the whole scene is clickable.
+   */
+  shouldShowRay(interactor) {
+    if (interactor && !interactor.showRay) return false;
+    if (!this.interactionSystem) return true;
+    return this.interactionSystem.getHoveredEntityId() !== null || this.interactionSystem.isGrabbing();
+  }
+  /** Lazily build per-slot visuals; the device reports profiles late. */
+  ensureSlots(world) {
+    const renderer = world.getRenderer();
+    for (const { index } of SLOTS) {
+      if (this.slots.has(index)) continue;
       const controller = renderer.xr.getController(index);
       const grip = renderer.xr.getControllerGrip(index);
       const hand = renderer.xr.getHand(index);
       if (!controller || !grip || !hand) continue;
-      controller.add(this.createRay());
-      this.group.add(controller);
-      grip.add(this.controllerModelFactory.createControllerModel(grip));
-      this.group.add(grip);
-      hand.add(this.handModelFactory.createHandModel(hand, "mesh"));
-      this.group.add(hand);
-      this.ready.add(index);
-    }
-    if (this.ready.size >= this.slots) {
-      this.built = true;
+      const ray = this.createRay();
+      controller.add(ray);
+      const controllerModel = this.controllerModelFactory.createControllerModel(grip);
+      grip.add(controllerModel);
+      const handModel = this.handModelFactory.createHandModel(hand, "mesh");
+      hand.add(handModel);
+      this.group.add(controller, grip, hand);
+      this.slots.set(index, {
+        controller,
+        grip,
+        hand,
+        ray,
+        controllerModel,
+        handModel,
+        attachedCustom: null
+      });
     }
   }
   /**
@@ -6637,6 +7003,7 @@ var _XRControllerVisualSystem = class _XRControllerVisualSystem {
     const line = new THREE7.Line(geometry, material);
     line.name = "XRPointerRay";
     line.renderOrder = 999;
+    line.visible = false;
     return line;
   }
   dispose() {
@@ -6652,14 +7019,131 @@ var _XRControllerVisualSystem = class _XRControllerVisualSystem {
       }
     });
     this.group.clear();
-    this.ready.clear();
-    this.built = false;
+    this.slots.clear();
+    this.handMaterial?.dispose();
+    this.handMaterial = null;
+    this.handStyleSignature = "";
     this.attachedTo = null;
   }
 };
 __name(_XRControllerVisualSystem, "XRControllerVisualSystem");
 var XRControllerVisualSystem = _XRControllerVisualSystem;
+var MARKER_RADIUS = 0.28;
+var ACCENT = new THREE7.Color("#4da3ff");
+var _XRTeleportVisualSystem = class _XRTeleportVisualSystem {
+  constructor(locomotionSystem) {
+    this.group = new THREE7.Group();
+    this.arcGeometry = new THREE7.BufferGeometry();
+    this.marker = new THREE7.Group();
+    this.attached = false;
+    this.locomotionSystem = locomotionSystem;
+    this.group.name = "XRTeleportVisuals";
+    this.group.userData.ecsPreviewHidden = true;
+    const arcMaterial = new THREE7.LineBasicMaterial({
+      vertexColors: true,
+      transparent: true,
+      depthTest: false
+    });
+    this.arc = new THREE7.Line(this.arcGeometry, arcMaterial);
+    this.arc.frustumCulled = false;
+    this.arc.renderOrder = 998;
+    this.group.add(this.arc);
+    this.marker.add(this.createRing(), this.createDot());
+    this.marker.renderOrder = 999;
+    this.group.add(this.marker);
+    this.setVisible(false);
+  }
+  update(world) {
+    if (!this.attached) {
+      world.getScene().add(this.group);
+      this.attached = true;
+    }
+    const curve = this.locomotionSystem.getAimCurve();
+    const landing = this.locomotionSystem.getLandingPoint();
+    if (!landing || curve.length < 2) {
+      this.setVisible(false);
+      return;
+    }
+    this.updateArcGeometry(curve);
+    this.marker.position.copy(landing);
+    this.marker.position.y += 0.01;
+    this.setVisible(true);
+  }
+  updateArcGeometry(curve) {
+    const count = curve.length;
+    const positions = new Float32Array(count * 3);
+    const colors = new Float32Array(count * 3);
+    for (let i = 0; i < count; i += 1) {
+      const point = curve[i];
+      positions[i * 3] = point.x;
+      positions[i * 3 + 1] = point.y;
+      positions[i * 3 + 2] = point.z;
+      const t = count > 1 ? i / (count - 1) : 0;
+      const fade = 1 - t * 0.75;
+      colors[i * 3] = ACCENT.r * fade;
+      colors[i * 3 + 1] = ACCENT.g * fade;
+      colors[i * 3 + 2] = ACCENT.b * fade;
+    }
+    this.arcGeometry.setAttribute(
+      "position",
+      new THREE7.BufferAttribute(positions, 3)
+    );
+    this.arcGeometry.setAttribute("color", new THREE7.BufferAttribute(colors, 3));
+    this.arcGeometry.computeBoundingSphere();
+  }
+  createRing() {
+    const geometry = new THREE7.RingGeometry(
+      MARKER_RADIUS * 0.72,
+      MARKER_RADIUS,
+      48
+    );
+    geometry.rotateX(-Math.PI / 2);
+    return new THREE7.Mesh(
+      geometry,
+      new THREE7.MeshBasicMaterial({
+        color: ACCENT,
+        transparent: true,
+        opacity: 0.9,
+        side: THREE7.DoubleSide,
+        depthTest: false
+      })
+    );
+  }
+  createDot() {
+    const geometry = new THREE7.CircleGeometry(MARKER_RADIUS * 0.16, 24);
+    geometry.rotateX(-Math.PI / 2);
+    return new THREE7.Mesh(
+      geometry,
+      new THREE7.MeshBasicMaterial({
+        color: ACCENT,
+        transparent: true,
+        opacity: 0.55,
+        side: THREE7.DoubleSide,
+        depthTest: false
+      })
+    );
+  }
+  setVisible(visible) {
+    this.group.visible = visible;
+  }
+  dispose() {
+    this.group.removeFromParent();
+    this.group.traverse((child) => {
+      const mesh = child;
+      mesh.geometry?.dispose?.();
+      const material = mesh.material;
+      if (Array.isArray(material)) {
+        for (const entry of material) entry.dispose?.();
+      } else {
+        material?.dispose?.();
+      }
+    });
+    this.attached = false;
+  }
+};
+__name(_XRTeleportVisualSystem, "XRTeleportVisualSystem");
+var XRTeleportVisualSystem = _XRTeleportVisualSystem;
 
-export { ADDED_NODE_MARKER_COMPONENT, AnimationSystem, AudioSystem, Behaviour, CameraSyncSystem, EnvironmentSyncSystem, HYDRATABLE_ENTITY_KINDS, InputSystem, InstancedMeshSystem, KeyboardKeys, LightSyncSystem, MaterialSyncSystem, MeshGeometrySystem, NODE_KEY_SEPARATOR, NO_XR_CAPABILITIES, OVERRIDE_DIFF_EXCLUDED_COMPONENTS, OVERRIDE_ROOT_EXCLUDED_COMPONENTS, ObjectVisibilitySystem, PREFAB_FILE_VERSION, PREFAB_FILE_VERSION_NESTED, PhysicsSyncSystem, PostprocessingSyncSystem, RenderSystem, SCRIPT_OBJECT_ROOT_FLAG, ScriptBehaviourSystem, ScriptObject, ScriptObjectSystem, TransformSyncSystem, VRTeleportAreaSystem, VideoSystem, XRControllerVisualSystem, XRInputSystem, XRInteractionSystem, XRLocomotionSystem, XRSessionSystem, buildComponentValueMaps, buildNodeKeyMapsFromSnapshot, buildNodeMapsFromSnapshot, canonicalizeComponentValue, clearPrefabCache, collectDiffPaths, collectEntitySubtree, collectSnapshotSubtreeIds, computeInstanceOverrides, decanonicalizeComponentValue, despawnPrefab, encodeOverride, findSnapshotRootEntityIds, findTopLevelNestedRegions, groupOverridePaths, hydrateWorldFromSnapshot, hydrateWorldFromSnapshotDetailed, indexSnapshotByEntity, instantiateSubtree, loadPrefab, mergeComponentValue, parseOverride, parsePrefabAsset, prefabFileVersionFor, readXrCapabilities, restoreComponentState, restorePostCreateComponents, setPrefabAssetUrlResolver, spawnPrefab };
-//# sourceMappingURL=chunk-ID266ZUA.js.map
-//# sourceMappingURL=chunk-ID266ZUA.js.map
+export { ADDED_NODE_MARKER_COMPONENT, ARC_GRAVITY, ARC_MAX_TIME, ARC_SPEED, ARC_STEPS, AnimationSystem, AudioSystem, Behaviour, CameraSyncSystem, EnvironmentSyncSystem, HYDRATABLE_ENTITY_KINDS, InputSystem, InstancedMeshSystem, KeyboardKeys, LightSyncSystem, MaterialSyncSystem, MeshGeometrySystem, NODE_KEY_SEPARATOR, NO_XR_CAPABILITIES, OVERRIDE_DIFF_EXCLUDED_COMPONENTS, OVERRIDE_ROOT_EXCLUDED_COMPONENTS, ObjectVisibilitySystem, PREFAB_FILE_VERSION, PREFAB_FILE_VERSION_NESTED, PhysicsSyncSystem, PostprocessingSyncSystem, RenderSystem, SCRIPT_OBJECT_ROOT_FLAG, ScriptBehaviourSystem, ScriptObject, ScriptObjectSystem, TransformSyncSystem, VRTeleportAreaSystem, VideoSystem, XRControllerVisualSystem, XRInputSystem, XRInteractionSystem, XRLocomotionSystem, XRSessionSystem, XRTeleportVisualSystem, applyHandMaterial, arcGroundCrossing, buildComponentValueMaps, buildNodeKeyMapsFromSnapshot, buildNodeMapsFromSnapshot, canonicalizeComponentValue, clearPrefabCache, collectDiffPaths, collectEntitySubtree, collectSnapshotSubtreeIds, computeInstanceOverrides, createHandMaterial, decanonicalizeComponentValue, despawnPrefab, encodeOverride, findSnapshotRootEntityIds, findTopLevelNestedRegions, groupOverridePaths, hydrateWorldFromSnapshot, hydrateWorldFromSnapshotDetailed, indexSnapshotByEntity, instantiateSubtree, loadPrefab, mergeComponentValue, parseOverride, parsePrefabAsset, prefabFileVersionFor, readXrCapabilities, restoreComponentState, restorePostCreateComponents, sampleTeleportArc, setPrefabAssetUrlResolver, spawnPrefab };
+//# sourceMappingURL=chunk-WRJ2K3LZ.js.map
+//# sourceMappingURL=chunk-WRJ2K3LZ.js.map