@aura3d/input 4.7.18 → 5.0.1

package/dist/WebXRSessionController.js

@@ -1,3 +1,8 @@
+// A cancelled native request cannot itself be cancelled. Keep its owner busy
+// until it rejects or its eventual session has finished closing. Weak keys keep
+// this coordination scoped to the app without retaining disposed owners.
+const sessionLeases = new WeakMap();
+/** Owns one pending or active session. A cancelled start closes any session that arrives late. */
 export class WebXRSessionController {
     mode;
     requiredFeatures;
@@ -6,274 +11,496 @@ export class WebXRSessionController {
     explicitReferenceSpace;
     activeReferenceSpaceType;
     xr;
+    leaseOwner;
+    lease = null;
+    depthSensing;
     session = null;
     referenceSpace = null;
+    hitTestSource = null;
+    lightProbe = null;
+    pendingSession = null;
+    endedSessions = new WeakSet();
+    sessionClosePromises = new WeakMap();
+    sourceIds = new WeakMap();
+    nextSourceId = 1;
+    planeIds = new WeakMap();
+    nextPlaneId = 1;
+    generation = 0;
+    starting = false;
+    disposed = false;
+    endPromise = null;
+    endListener = null;
+    hapticCleanups = new Set();
+    warnings = [];
     constructor(options = {}) {
         this.xr = options.xr ?? readNavigatorXR();
+        this.leaseOwner = options.leaseOwner ?? this;
         this.mode = options.mode ?? "immersive-vr";
         this.requiredFeatures = options.requiredFeatures ?? [];
         this.optionalFeatures = options.optionalFeatures ?? [];
+        this.depthSensing = options.depthSensing;
         this.referenceSpaceType = options.referenceSpace ?? (this.mode === "immersive-ar" ? "viewer" : "local-floor");
         this.explicitReferenceSpace = options.referenceSpace !== undefined;
         this.activeReferenceSpaceType = this.referenceSpaceType;
     }
-    get active() {
-        return this.session !== null;
-    }
-    /** SC-04: the live session, for render-state and frame-loop wiring. Null when inactive. */
-    get xrSession() {
-        return this.session;
-    }
-    /** SC-04: the reference space requested at `start()`. Null when inactive. */
-    get xrReferenceSpace() {
-        return this.referenceSpace;
-    }
+    get active() { return this.session !== null && this.referenceSpace !== null; }
+    get xrSession() { return this.session; }
+    get xrReferenceSpace() { return this.referenceSpace; }
+    get xrHitTestSource() { return this.hitTestSource; }
+    get hasLightProbe() { return this.lightProbe !== null; }
     async isSupported() {
-        if (!this.xr)
+        if (this.disposed || !this.xr)
             return false;
-        if (!this.xr.isSessionSupported)
-            return true;
-        return this.xr.isSessionSupported(this.mode);
+        return this.xr.isSessionSupported ? this.xr.isSessionSupported(this.mode) : true;
+    }
+    result(supported, started, busy = false) {
+        return { mode: this.mode, referenceSpace: this.activeReferenceSpaceType, supported, started, ...(busy ? { busy: true } : {}) };
+    }
+    releaseLease(lease) {
+        if (sessionLeases.get(this.leaseOwner) === lease)
+            sessionLeases.delete(this.leaseOwner);
+        if (this.lease === lease)
+            this.lease = null;
     }
     async start() {
-        if (!this.xr) {
-            return {
-                mode: this.mode,
-                referenceSpace: this.referenceSpaceType,
-                supported: false,
-                started: false
-            };
-        }
-        const supported = await this.isSupported();
-        if (!supported) {
-            return {
-                mode: this.mode,
-                referenceSpace: this.referenceSpaceType,
-                supported: false,
-                started: false
-            };
-        }
-        // WebXR: `viewer` is always available and `local` is implied for immersive sessions; every other
-        // reference-space type (`local-floor`, `bounded-floor`, `unbounded`) must be requested as a session feature
-        // or `requestReferenceSpace` rejects with NotSupportedError.
-        const requestedType = this.referenceSpaceType;
-        const implied = requestedType === "viewer" || requestedType === "local";
-        const listed = this.requiredFeatures.includes(requestedType) || this.optionalFeatures.includes(requestedType);
-        const optionalFeatures = implied || listed ? this.optionalFeatures : [...this.optionalFeatures, requestedType];
-        const session = await this.xr.requestSession(this.mode, {
-            requiredFeatures: this.requiredFeatures,
-            optionalFeatures
-        });
-        this.session = session;
-        this.activeReferenceSpaceType = requestedType;
+        if (this.disposed || !this.xr)
+            return this.result(false, false);
+        if (this.starting || this.session || this.endPromise || sessionLeases.has(this.leaseOwner))
+            return this.result(true, false, true);
+        const generation = ++this.generation;
+        this.starting = true;
+        this.warnings.length = 0;
+        let candidate = null;
+        let lease = null;
+        let source = null;
+        let pendingEndListener = null;
         try {
-            this.referenceSpace = await session.requestReferenceSpace?.(requestedType) ?? { type: requestedType };
-        }
-        catch (error) {
-            // Like three's VRButton, the default `local-floor` degrades to `local` on devices without a floor.
-            if (this.explicitReferenceSpace || requestedType !== "local-floor") {
-                await this.abandonSession(session);
-                throw error;
+            const supported = await this.isSupported();
+            if (generation !== this.generation)
+                return this.result(supported, false);
+            if (!supported)
+                return this.result(false, false);
+            // Check again after support detection, which can run concurrently for
+            // different controllers with the same owner.
+            if (sessionLeases.has(this.leaseOwner))
+                return this.result(true, false, true);
+            lease = {};
+            sessionLeases.set(this.leaseOwner, lease);
+            this.lease = lease;
+            const requestedType = this.referenceSpaceType;
+            const implied = requestedType === "viewer" || requestedType === "local";
+            const listed = this.requiredFeatures.includes(requestedType) || this.optionalFeatures.includes(requestedType);
+            const optionalFeatures = implied || listed ? this.optionalFeatures : [...this.optionalFeatures, requestedType];
+            candidate = await this.xr.requestSession(this.mode, { requiredFeatures: this.requiredFeatures, optionalFeatures, ...(this.depthSensing ? { depthSensing: this.depthSensing } : {}) });
+            if (generation !== this.generation)
+                return this.result(true, false);
+            this.pendingSession = candidate;
+            const openingSession = candidate;
+            pendingEndListener = () => {
+                if (this.pendingSession === openingSession) {
+                    this.pendingSession = null;
+                    this.endedSessions.add(openingSession);
+                    ++this.generation;
+                    this.starting = false;
+                    if (lease)
+                        this.releaseLease(lease);
+                }
+            };
+            candidate.addEventListener?.("end", pendingEndListener);
+            if (generation !== this.generation)
+                return this.result(true, false);
+            if (typeof candidate.requestReferenceSpace !== "function") {
+                throw new Error("XR_REFERENCE_SPACE_UNAVAILABLE: the session does not expose requestReferenceSpace.");
             }
+            let space;
+            let actualType = requestedType;
             try {
-                this.referenceSpace = await session.requestReferenceSpace?.("local") ?? { type: "local" };
-                this.activeReferenceSpaceType = "local";
+                space = await candidate.requestReferenceSpace(requestedType);
+            }
+            catch (error) {
+                if (generation !== this.generation)
+                    return this.result(true, false);
+                if (this.explicitReferenceSpace || requestedType !== "local-floor")
+                    throw error;
+                actualType = "local";
+                try {
+                    space = await candidate.requestReferenceSpace("local");
+                }
+                catch (fallbackError) {
+                    if (generation !== this.generation)
+                        return this.result(true, false);
+                    throw fallbackError;
+                }
             }
-            catch (fallbackError) {
-                await this.abandonSession(session);
-                throw fallbackError;
+            if (generation !== this.generation)
+                return this.result(true, false);
+            if (!space || typeof space !== "object") {
+                throw new Error(`XR_REFERENCE_SPACE_UNAVAILABLE: the session did not supply a usable ${actualType} reference space.`);
             }
+            const features = [...this.requiredFeatures, ...this.optionalFeatures];
+            if (features.includes("hit-test")) {
+                if (candidate.requestHitTestSource) {
+                    try {
+                        const viewer = actualType === "viewer" ? space : await candidate.requestReferenceSpace?.("viewer");
+                        if (generation !== this.generation)
+                            return this.result(true, false);
+                        if (viewer) {
+                            source = await candidate.requestHitTestSource({ space: viewer }) ?? null;
+                            if (!source && generation === this.generation)
+                                this.warnings.push("Hit testing unavailable: no hit-test source was supplied.");
+                        }
+                        else
+                            this.warnings.push("Hit testing unavailable: viewer reference space was not supplied.");
+                    }
+                    catch (error) {
+                        if (generation !== this.generation)
+                            return this.result(true, false);
+                        this.warnings.push(`Hit testing unavailable: ${message(error)}`);
+                    }
+                }
+                else
+                    this.warnings.push("Hit testing unavailable: session does not expose requestHitTestSource.");
+            }
+            if (generation !== this.generation)
+                return this.result(true, false);
+            let lightProbe = null;
+            if (features.includes("light-estimation")) {
+                if (candidate.requestLightProbe) {
+                    try {
+                        lightProbe = await candidate.requestLightProbe();
+                    }
+                    catch (error) {
+                        if (generation === this.generation)
+                            this.warnings.push(`Light estimation unavailable: ${message(error)}`);
+                    }
+                }
+                else
+                    this.warnings.push("Light estimation unavailable: session does not expose requestLightProbe.");
+            }
+            if (generation !== this.generation)
+                return this.result(true, false);
+            this.session = candidate;
+            this.referenceSpace = space;
+            this.activeReferenceSpaceType = actualType;
+            this.hitTestSource = source;
+            this.lightProbe = lightProbe;
+            const owned = candidate;
+            const ownedLease = lease;
+            this.endListener = () => {
+                if (this.session === owned) {
+                    this.endedSessions.add(owned);
+                    this.clearOwned();
+                    if (ownedLease)
+                        this.releaseLease(ownedLease);
+                }
+            };
+            candidate.addEventListener?.("end", this.endListener);
+            if (pendingEndListener)
+                candidate.removeEventListener?.("end", pendingEndListener);
+            pendingEndListener = null;
+            if (this.pendingSession === candidate)
+                this.pendingSession = null;
+            candidate = null;
+            source = null;
+            lease = null; // The active session now owns the lease.
+            return this.result(true, true);
+        }
+        finally {
+            if (generation === this.generation)
+                this.starting = false;
+            cancelSource(source);
+            if (candidate) {
+                if (pendingEndListener)
+                    candidate.removeEventListener?.("end", pendingEndListener);
+                if (this.pendingSession === candidate)
+                    this.pendingSession = null;
+                await this.closeSession(candidate);
+            }
+            if (lease)
+                this.releaseLease(lease);
         }
-        return {
-            mode: this.mode,
-            referenceSpace: this.referenceSpace?.type ?? this.activeReferenceSpaceType,
-            supported: true,
-            started: true
-        };
     }
-    /** A session whose reference space could not be created is never left open. */
-    async abandonSession(session) {
+    clearOwned() {
+        const session = this.session;
+        if (this.endListener)
+            session?.removeEventListener?.("end", this.endListener);
+        this.endListener = null;
+        for (const cleanup of this.hapticCleanups)
+            cleanup();
+        cancelSource(this.hitTestSource);
+        this.hitTestSource = null;
+        this.lightProbe = null;
         this.session = null;
         this.referenceSpace = null;
         this.activeReferenceSpaceType = this.referenceSpaceType;
-        try {
-            await session.end?.();
-        }
-        catch {
-            // The session is already unusable; ending it is best effort.
-        }
     }
-    sampleFrame(frame, hitTestSource) {
+    sampleFrame(frame, hitTestSource, gpuDepth) {
         const referenceSpace = this.referenceSpace ?? { type: this.activeReferenceSpaceType };
         const sources = Array.from(this.session?.inputSources ?? []);
-        const controllers = sources.map((source) => sampleInputSource(source, frame, referenceSpace));
-        const hands = sources
-            .filter((source) => source.hand !== undefined)
-            .map((source) => sampleHand(source.handedness ?? "none", source.hand));
-        const hitTests = frame?.getHitTestResults && hitTestSource
-            ? frame.getHitTestResults(hitTestSource).map(sampleHitTest)
-            : [];
-        const camera = sampleViewerPose(frame, referenceSpace);
-        const hitTestCapable = Boolean(frame?.getHitTestResults && hitTestSource);
+        const id = (source) => {
+            let value = this.sourceIds.get(source);
+            if (value === undefined) {
+                value = this.nextSourceId++;
+                this.sourceIds.set(source, value);
+            }
+            return value;
+        };
+        const controllers = sources.map((source) => sampleInputSource(id(source), source, frame, referenceSpace));
+        const hands = sources.filter((source) => source.hand != null).map((source) => sampleHand(id(source), source.handedness ?? "none", source.hand, frame, referenceSpace));
+        const source = hitTestSource ?? this.hitTestSource;
+        const hitTests = source && frame?.getHitTestResults ? safe(() => frame.getHitTestResults(source), []).flatMap((hit) => {
+            const sampled = sampleHitTest(hit, referenceSpace);
+            return sampled ? [sampled] : [];
+        }) : [];
+        const pose = safe(() => frame?.getViewerPose?.(referenceSpace), undefined);
+        const camera = sampleViewerPose(pose);
+        const planes = Array.from(frame?.detectedPlanes ?? [], (plane) => {
+            let planeId = this.planeIds.get(plane);
+            if (planeId === undefined) {
+                planeId = this.nextPlaneId++;
+                this.planeIds.set(plane, planeId);
+            }
+            return samplePlane(planeId, plane, frame, referenceSpace);
+        });
+        const depth = (pose?.views ?? []).flatMap((view) => {
+            const value = safe(() => frame?.getDepthInformation?.(view), undefined) ?? safe(() => gpuDepth?.(view), undefined);
+            return value ? [sampleDepth(view, value)] : [];
+        });
+        const lightEstimate = this.lightProbe ? safe(() => frame?.getLightEstimate?.(this.lightProbe), undefined) : undefined;
+        const light = lightEstimate ? sampleLight(lightEstimate) : null;
         const enabledFeatures = Array.from(this.session?.enabledFeatures ?? []);
         return {
-            mode: this.mode,
-            referenceSpace: this.referenceSpace?.type ?? this.referenceSpaceType,
-            active: this.active,
-            controllerCount: controllers.length,
-            controllers,
-            hitTestCount: hitTests.length,
-            hitTests,
-            hands,
-            camera,
+            mode: this.mode, referenceSpace: this.activeReferenceSpaceType, active: this.active,
+            controllerCount: controllers.length, controllers, hitTestCount: hitTests.length, hitTests, hands, camera, planes, depth, light,
             capabilities: {
-                handTracking: hands.some((hand) => hand.tracked),
-                viewerPose: camera.tracked,
-                hitTest: hitTestCapable,
-                haptics: controllers.some((controller) => controller.hapticActuatorCount > 0),
-                referenceSpace: this.referenceSpace?.type ?? this.referenceSpaceType,
-                enabledFeatures
+                handTracking: hands.some((hand) => hand.tracked), viewerPose: camera.tracked,
+                hitTest: Boolean(frame?.getHitTestResults && source), haptics: controllers.some((controller) => controller.hapticActuatorCount > 0),
+                referenceSpace: this.activeReferenceSpaceType, enabledFeatures,
+                planeDetection: frame?.detectedPlanes !== undefined, depthSensing: depth.length > 0, lightEstimation: light !== null
             }
         };
     }
-    async end() {
+    end() {
+        ++this.generation;
+        this.starting = false;
         const session = this.session;
-        this.session = null;
-        this.referenceSpace = null;
-        await session?.end?.();
+        const pending = this.pendingSession;
+        const lease = pending || session ? this.lease : null;
+        this.pendingSession = null;
+        this.clearOwned();
+        const previous = this.endPromise;
+        // Publish the closing promise before invoking the native end method: an
+        // end listener can synchronously re-enter this controller or its runtime.
+        const closing = Promise.resolve().then(async () => {
+            if (previous)
+                await previous;
+            if (pending)
+                await this.closeSession(pending);
+            if (session)
+                await this.closeSession(session);
+        });
+        this.endPromise = closing;
+        return closing.finally(() => {
+            if (lease)
+                this.releaseLease(lease);
+            if (this.endPromise === closing)
+                this.endPromise = null;
+        });
+    }
+    async dispose() {
+        if (this.disposed) {
+            await this.endPromise;
+            return;
+        }
+        this.disposed = true;
+        await this.end();
+    }
+    closeSession(session) {
+        const previous = this.sessionClosePromises.get(session);
+        if (previous)
+            return previous;
+        if (this.endedSessions.has(session))
+            return Promise.resolve();
+        this.endedSessions.add(session);
+        const closing = Promise.resolve().then(async () => {
+            try {
+                await session.end?.();
+            }
+            catch { /* A native session can already be ended. */ }
+        });
+        this.sessionClosePromises.set(session, closing);
+        return closing;
     }
     async pulseHaptics(intensity = 0.5, duration = 35) {
         if (!Number.isFinite(intensity) || intensity < 0 || intensity > 1)
             throw new RangeError("WebXR haptic intensity must be in [0, 1].");
         if (!Number.isFinite(duration) || duration < 0)
             throw new RangeError("WebXR haptic duration must be finite and non-negative.");
-        let pulses = 0;
-        for (const source of this.session?.inputSources ?? []) {
-            for (const actuator of source.gamepad?.hapticActuators ?? []) {
-                const accepted = await actuator.pulse?.(intensity, duration);
-                if (accepted !== false)
-                    pulses += 1;
+        const session = this.session;
+        if (!session || !this.referenceSpace || this.disposed)
+            return 0;
+        const generation = this.generation;
+        const isCurrent = () => !this.disposed && this.session === session && this.generation === generation;
+        const removed = new Set();
+        const onSourcesChanged = (event) => {
+            for (const source of event.removed ?? [])
+                removed.add(source);
+        };
+        const cleanup = () => {
+            session.removeEventListener?.("inputsourceschange", onSourcesChanged);
+            this.hapticCleanups.delete(cleanup);
+        };
+        if (session.addEventListener && session.removeEventListener) {
+            session.addEventListener("inputsourceschange", onSourcesChanged);
+            this.hapticCleanups.add(cleanup);
+        }
+        // Native lists are repeatable, while injected session sources may be a
+        // one-shot iterator. Preserve the latter's initial snapshot and use source
+        // removal events to invalidate it when available.
+        const oneShotSources = new Map();
+        const currentSources = () => {
+            const collection = session.inputSources;
+            if (!collection)
+                return [];
+            const previous = oneShotSources.get(collection);
+            if (previous)
+                return previous;
+            const iterator = collection[Symbol.iterator]();
+            const snapshot = Array.from({ [Symbol.iterator]: () => iterator });
+            if (iterator === collection)
+                oneShotSources.set(collection, snapshot);
+            return snapshot;
+        };
+        const sourceIsLive = (source) => !removed.has(source) && currentSources().includes(source);
+        try {
+            const sources = currentSources();
+            let pulses = 0;
+            for (const source of sources) {
+                if (!isCurrent())
+                    break;
+                if (!sourceIsLive(source))
+                    continue;
+                const actuators = Array.from(source.gamepad?.hapticActuators ?? []);
+                for (const actuator of actuators) {
+                    if (!isCurrent())
+                        return pulses;
+                    if (!sourceIsLive(source))
+                        break;
+                    if (!source.gamepad?.hapticActuators?.includes(actuator))
+                        continue;
+                    if (!isCurrent())
+                        return pulses;
+                    if (actuator.pulse && await actuator.pulse(intensity, duration) !== false)
+                        pulses += 1;
+                }
             }
+            return pulses;
+        }
+        finally {
+            cleanup();
         }
-        return pulses;
     }
 }
-function sampleInputSource(source, frame, referenceSpace) {
-    const buttons = source.gamepad?.buttons ?? [];
-    const axes = source.gamepad?.axes ?? [];
-    const trigger = buttons[0];
-    const squeeze = buttons[1];
+function sampleInputSource(id, source, frame, space) {
+    const trigger = source.gamepad?.buttons?.[0];
     return {
-        handedness: source.handedness ?? "none",
-        targetRayMode: source.targetRayMode ?? "tracked-pointer",
-        profiles: source.profiles ?? [],
-        triggerPressed: Boolean(trigger?.pressed),
-        squeezePressed: Boolean(squeeze?.pressed),
-        primaryValue: finiteOrZero(trigger?.value),
-        axes: axes.map(finiteOrZero),
-        targetRayMatrix: samplePoseMatrix(frame, source.targetRaySpace, referenceSpace),
-        gripMatrix: samplePoseMatrix(frame, source.gripSpace, referenceSpace),
-        hapticActuatorCount: source.gamepad?.hapticActuators?.length ?? 0
+        id, handedness: source.handedness ?? "none", targetRayMode: source.targetRayMode ?? "tracked-pointer", profiles: source.profiles ?? [],
+        triggerPressed: Boolean(trigger?.pressed), squeezePressed: Boolean(source.gamepad?.buttons?.[1]?.pressed), primaryValue: finiteOrZero(trigger?.value),
+        axes: (source.gamepad?.axes ?? []).map(finiteOrZero), targetRayMatrix: samplePoseMatrix(frame, source.targetRaySpace, space),
+        gripMatrix: samplePoseMatrix(frame, source.gripSpace, space), hapticActuatorCount: source.gamepad?.hapticActuators?.length ?? 0
     };
 }
-function samplePoseMatrix(frame, space, referenceSpace) {
-    if (!frame?.getPose || !space)
-        return null;
-    return sanitizeMatrix4(frame.getPose(space, referenceSpace)?.transform?.matrix);
+function samplePoseMatrix(frame, target, base) {
+    return target && frame?.getPose ? matrix(safe(() => frame.getPose(target, base)?.transform?.matrix, undefined)) : null;
 }
-function sampleHand(handedness, hand) {
+function sampleHand(id, handedness, hand, frame, base) {
     const joints = {};
-    const entries = hand?.joints ? Object.entries(hand.joints).slice(0, 64) : [];
-    for (const [name, joint] of entries) {
-        joints[name] = {
-            position: sanitizeVec3OrNull(joint?.position),
-            radius: typeof joint?.radius === "number" && Number.isFinite(joint.radius) ? Math.max(0, joint.radius) : 0
-        };
+    if (hand?.entries && frame?.getJointPose) {
+        for (const [name, jointSpace] of hand.entries()) {
+            const pose = safe(() => frame.getJointPose(jointSpace, base), undefined);
+            if (!pose)
+                continue;
+            joints[name] = { position: vector3(pose.transform?.position), orientation: quaternion(pose.transform?.orientation), radius: Math.max(0, finiteOrZero(pose.radius)) };
+        }
     }
+    else
+        for (const [name, joint] of Object.entries(hand?.joints ?? {}).slice(0, 64)) {
+            joints[name] = { position: vector3(joint.position), orientation: quaternion(joint.orientation), radius: Math.max(0, finiteOrZero(joint.radius)) };
+        }
     const jointCount = Object.keys(joints).length;
-    return {
-        handedness,
-        tracked: hand?.trackingState === "tracked" && jointCount > 0,
-        jointCount,
-        joints
-    };
+    return { id, handedness, tracked: jointCount > 0 && (hand?.entries ? true : hand?.trackingState === "tracked"), jointCount, joints };
 }
-function sampleViewerPose(frame, referenceSpace) {
-    const untracked = {
-        tracked: false,
-        position: null,
-        orientation: null,
-        viewMatrix: null,
-        projectionMatrix: null
-    };
-    const pose = frame?.getViewerPose?.(referenceSpace);
-    if (!pose)
-        return untracked;
-    const position = sanitizeVec3OrNull(pose.position);
-    const orientation = sanitizeQuatOrNull(pose.orientation);
-    // Strict: a single non-finite entry invalidates the whole matrix. Zeroing
-    // it (the legacy controller-pose behavior) would silently warp the XR
-    // camera, so the sample degrades to untracked instead.
-    const viewMatrix = sanitizeMatrix4Strict(pose.viewMatrix);
-    const projectionMatrix = sanitizeMatrix4Strict(pose.projectionMatrix);
-    if (!position && !orientation && !viewMatrix && !projectionMatrix)
-        return untracked;
-    return { tracked: true, position, orientation, viewMatrix, projectionMatrix };
+function sampleViewerPose(pose) {
+    const position = vector3(pose?.transform?.position ?? pose?.position);
+    const orientation = quaternion(pose?.transform?.orientation ?? pose?.orientation);
+    const viewMatrix = matrix(pose?.viewMatrix ?? pose?.views?.[0]?.transform?.inverse?.matrix);
+    const projectionMatrix = matrix(pose?.projectionMatrix ?? pose?.views?.[0]?.projectionMatrix);
+    return { tracked: Boolean(position || orientation || viewMatrix || projectionMatrix), position, orientation, viewMatrix, projectionMatrix };
 }
-function sampleHitTest(result) {
+function sampleHitTest(hit, referenceSpace) {
+    const pose = safe(() => hit.getPose?.(referenceSpace), undefined);
+    const position = vector3(pose?.transform?.position ?? hit.position);
+    if (!position)
+        return null;
+    const rotation = quaternion(pose?.transform?.orientation);
+    const m = matrix(pose?.transform?.matrix);
+    const normal = vector3(hit.normal) ?? (m ? [m[4], m[5], m[6]] : rotation ? rotateUp(rotation) : [0, 1, 0]);
+    return { position, normal };
+}
+function samplePlane(id, plane, frame, base) {
     return {
-        position: sanitizeVec3(result.position, [0, 0, 0]),
-        normal: sanitizeVec3(result.normal, [0, 1, 0])
+        id, matrix: samplePoseMatrix(frame, plane.planeSpace, base),
+        polygon: Array.from(plane.polygon ?? []).flatMap((point) => { const v = vector3(point); return v ? [v] : []; }),
+        orientation: plane.orientation ?? null, semanticLabel: plane.semanticLabel ?? null,
+        lastChangedTime: Number.isFinite(plane.lastChangedTime) ? plane.lastChangedTime : null
     };
 }
-function sanitizeVec3(value, fallback) {
-    if (!value || value.length < 3)
-        return fallback;
-    const x = finiteOrZero(value[0]);
-    const y = finiteOrZero(value[1]);
-    const z = finiteOrZero(value[2]);
-    return [x, y, z];
+function sampleDepth(view, depth) {
+    return { eye: view.eye ?? "none", width: depth.width, height: depth.height, rawValueToMeters: depth.rawValueToMeters,
+        transform: matrix(depth.normDepthBufferFromNormView?.matrix), data: depth.data ?? null, texture: depth.texture ?? null,
+        textureType: depth.textureType ?? null, imageIndex: depth.imageIndex ?? null };
 }
-function sanitizeVec3OrNull(value) {
-    if (!value || value.length < 3)
-        return null;
-    const x = value[0];
-    const y = value[1];
-    const z = value[2];
-    if (typeof x !== "number" || typeof y !== "number" || typeof z !== "number")
-        return null;
-    if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z))
-        return null;
-    return [x, y, z];
+function sampleLight(value) {
+    return { direction: vector3(value.primaryLightDirection), intensity: vector3(value.primaryLightIntensity),
+        sphericalHarmonics: Array.from(value.sphericalHarmonicsCoefficients ?? [], finiteOrZero) };
 }
-function sanitizeQuatOrNull(value) {
-    if (!value || value.length < 4)
-        return null;
-    const [x, y, z, w] = [value[0], value[1], value[2], value[3]];
-    if (typeof x !== "number" || typeof y !== "number" || typeof z !== "number" || typeof w !== "number")
-        return null;
-    if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z) || !Number.isFinite(w))
-        return null;
-    return [x, y, z, w];
+function rotateUp(q) {
+    const [x, y, z, w] = q;
+    return [2 * (x * y - z * w), 1 - 2 * (x * x + z * z), 2 * (y * z + x * w)];
 }
-function sanitizeMatrix4Strict(value) {
-    if (!value || value.length < 16)
-        return null;
-    const matrix = value.slice(0, 16);
-    if (matrix.some((entry) => typeof entry !== "number" || !Number.isFinite(entry)))
+function components(value) {
+    if (!value)
         return null;
-    return Array.from(matrix);
+    if (Array.isArray(value))
+        return value;
+    const point = value;
+    return [point.x, point.y, point.z, point.w ?? NaN];
 }
-function finiteOrZero(value) {
-    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+function vector3(value) {
+    const c = components(value);
+    return c && c.length >= 3 && c.slice(0, 3).every(Number.isFinite) ? [c[0], c[1], c[2]] : null;
 }
-function sanitizeMatrix4(value) {
+function quaternion(value) {
+    const c = components(value);
+    return c && c.length >= 4 && c.slice(0, 4).every(Number.isFinite) ? [c[0], c[1], c[2], c[3]] : null;
+}
+function matrix(value) {
     if (!value || value.length < 16)
         return null;
-    const matrix = Array.from(value.slice(0, 16), finiteOrZero);
-    return matrix;
+    const entries = Array.from({ length: 16 }, (_, i) => value[i]);
+    return entries.every(Number.isFinite) ? entries : null;
+}
+function safe(fn, fallback) { try {
+    return fn();
 }
-function readNavigatorXR() {
-    return globalThis.navigator?.xr;
+catch {
+    return fallback;
+} }
+function cancelSource(source) { try {
+    source?.cancel?.();
 }
+catch { /* A closed native session may already have invalidated the source. */ } }
+function finiteOrZero(value) { return typeof value === "number" && Number.isFinite(value) ? value : 0; }
+function message(error) { return error instanceof Error ? error.message : String(error); }
+function readNavigatorXR() { return globalThis.navigator?.xr; }
 //# sourceMappingURL=WebXRSessionController.js.map