@driftengine/xr 3.61.0

package/src/support.ts

@@ -0,0 +1,148 @@
+/**
+ * What this browser can actually do, asked by doing it.
+ *
+ * **`isSessionSupported` is a promise about a mode and not an answer about this machine**, and the
+ * difference is not academic. Measured on 2026-09-05, Chrome 151 on Linux with no headset:
+ * `isSessionSupported('inline')` answers **true**, `requestSession('inline')` **succeeds**,
+ * `requestReferenceSpace('viewer')` **succeeds**, and then `gl.makeXRCompatible()` throws
+ * `InvalidStateError` because there is no XR device. Without that call there is no base layer, and
+ * without a base layer a session delivers **no frame at all**. Every promise along the way was
+ * kept, and nothing could be drawn.
+ *
+ * So this asks the question `probeDevice` asks about a GPU, and for the reason `probeDevice`'s own
+ * header gives: *a device that reports support and then draws nothing is a device that lied.* It
+ * tries the step that fails.
+ *
+ * **`reason` is a whole sentence and never empty when something is missing.** A consumer whose
+ * button does nothing is owed the difference between a browser with no WebXR, a machine with no
+ * headset, and a context that refused to become XR compatible, because those are three different
+ * things to do next. The island pool's `parallelism.reason` and `createSplatSortWorker`'s single
+ * warning are the same discipline; a silent false is the one outcome none of them allows.
+ */
+
+import type { XrMode, XrSystem } from './types.ts';
+
+export interface XrSupport {
+  /** Whether `navigator.xr` exists at all. Everything else is false without it. */
+  readonly present: boolean;
+  readonly immersiveVr: boolean;
+  readonly immersiveAr: boolean;
+  readonly inline: boolean;
+  /**
+   * Whether a rendering context could be made XR compatible.
+   *
+   * The step that actually fails without a device, and the one no `isSessionSupported` reports on.
+   */
+  readonly compatible: boolean;
+  /** Empty when a session could be entered. A whole sentence otherwise. */
+  readonly reason: string;
+}
+
+const NOTHING: XrSupport = {
+  present: false,
+  immersiveVr: false,
+  immersiveAr: false,
+  inline: false,
+  compatible: false,
+  reason: 'this browser has no WebXR: navigator.xr is not defined.',
+};
+
+/** A context that can be asked to become XR compatible. Both backends' contexts satisfy it. */
+export interface XrCompatibleContext {
+  makeXRCompatible?(): Promise<void>;
+}
+
+function systemOf(): XrSystem | null {
+  const nav = globalThis.navigator as { xr?: XrSystem } | undefined;
+  return nav?.xr ?? null;
+}
+
+async function supports(system: XrSystem, mode: XrMode): Promise<boolean> {
+  try {
+    return await system.isSessionSupported(mode);
+  } catch {
+    /*
+     * A rejection is an answer and not an error. `isSessionSupported` rejects rather than resolving
+     * false where a permissions policy forbids the mode, which is a `false` a consumer can do
+     * nothing about and must not be a thrown exception on a page that merely asked.
+     */
+    return false;
+  }
+}
+
+/**
+ * Ask, and try the step that lies.
+ *
+ * `context` is optional because a consumer may want the modes before they have built a renderer.
+ * Without one, `compatible` is false and `reason` says the question was not asked, which is a
+ * different thing from asked and refused.
+ */
+export async function probeXrSupport(
+  context?: XrCompatibleContext | null,
+  /*
+   * The system, overridable for the same reason `enterXr` takes one: a test cannot assign
+   * `globalThis.navigator`, which is getter-only, and stubbing a global to ask a question about a
+   * pure function would be surgery on the environment to avoid a parameter.
+   */
+  override?: XrSystem | null,
+): Promise<XrSupport> {
+  const system = override === undefined ? systemOf() : override;
+  if (system === null) return NOTHING;
+
+  const [immersiveVr, immersiveAr, inline] = await Promise.all([
+    supports(system, 'immersive-vr'),
+    supports(system, 'immersive-ar'),
+    supports(system, 'inline'),
+  ]);
+
+  let compatible = false;
+  let compatibleReason = '';
+  if (context?.makeXRCompatible === undefined) {
+    compatibleReason =
+      'no rendering context was offered, so whether one can be made XR compatible is unasked.';
+  } else {
+    try {
+      await context.makeXRCompatible();
+      compatible = true;
+    } catch (error) {
+      const name = (error as Error)?.name ?? 'Error';
+      compatibleReason =
+        `the rendering context refused to become XR compatible (${name}), which is what happens ` +
+        'when the browser has WebXR but this machine has no XR device attached.';
+    }
+  }
+
+  /*
+   * **The deepest failure wins, and the first draft had this backwards.** It reported the mode
+   * message before the compatibility one, so a machine whose context had actually been offered and
+   * refused was told "only an inline session is available here" — true, and not the thing that had
+   * just gone wrong. `xr-check.mjs` caught it: `compatible` was false while `reason` said nothing
+   * about it.
+   *
+   * A refusal that was *tried* outranks a report about what a mode list says, because it is the
+   * concrete step that failed and the one a consumer can do something about.
+   */
+  const anyMode = immersiveVr || immersiveAr || inline;
+  let reason = '';
+  if (context?.makeXRCompatible !== undefined && !compatible) {
+    reason = compatibleReason;
+  } else if (!anyMode) {
+    reason =
+      'this browser has WebXR but reports no session mode as supported, which is what a machine ' +
+      'with no headset answers.';
+  } else if (!immersiveVr && !immersiveAr) {
+    reason =
+      'only an inline session is available here. An inline session has one view and no headset ' +
+      'pose, so it draws a window into the scene and does not present to a device.';
+  }
+
+  return { present: true, immersiveVr, immersiveAr, inline, compatible, reason };
+}
+
+/** The best mode this support answer allows, or null when none is worth asking for. */
+export function bestMode(support: XrSupport): XrMode | null {
+  if (support.immersiveVr) return 'immersive-vr';
+  if (support.immersiveAr) return 'immersive-ar';
+  if (support.inline) return 'inline';
+  return null;
+}

package/src/testing/synthetic.ts

@@ -0,0 +1,296 @@
+/**
+ * A WebXR runtime that answers, so everything past the first frame can be exercised.
+ *
+ * **This stands in for a browser API and not for an engine capability**, which is the distinction
+ * R1 drew when it withdrew the mock capability providers: a mock with no first implementation to
+ * check it against is only ever agreeing with itself. The first implementation of WebXR is a
+ * browser's, and `DeterministicProvider` already lives on the same footing, standing in for a thing
+ * that is genuinely elsewhere.
+ *
+ * **It exists because no frame can be produced on the machine this was written on.** Measured
+ * 2026-09-05, Chrome 151, no headset: an inline session starts and `makeXRCompatible` throws, so
+ * there is no base layer and therefore no `XRFrame` at all. Every path from the first frame onward
+ * would otherwise be code nobody had run.
+ *
+ * **What it cannot do is prove a real runtime accepts what the engine hands back.** It produces the
+ * shapes the specification describes; whether a compositor is happy with them is a question only
+ * hardware answers, and that is tracked as unmeasured rather than this file
+ * pretending otherwise.
+ *
+ * The numbers are deliberately asymmetric and deliberately not round. An eye projection is off-axis
+ * and the two eyes differ; a synthetic runtime handing back two identical symmetric matrices would
+ * let a stereo path that drew the same picture twice pass as correct.
+ */
+
+import { mat4 } from 'gl-matrix';
+import type {
+  XrFrame,
+  XrGamepad,
+  XrHand,
+  XrInputSource,
+  XrJointPose,
+  XrRigidTransform,
+  XrSession,
+  XrSystem,
+  XrView,
+  XrViewerPose,
+  XrViewport,
+  XrWebGlLayer,
+} from '../types.ts';
+import { HAND_JOINTS } from '../hands.ts';
+
+function transform(matrix: mat4): XrRigidTransform {
+  return {
+    matrix: matrix as unknown as Float32Array,
+    inverse: { matrix: mat4.invert(mat4.create(), matrix) as unknown as Float32Array },
+  };
+}
+
+/** Two eyes, 64 mm apart, with off-axis frusta that differ from each other. */
+function stereoViews(headHeight: number): XrView[] {
+  const half = 0.032;
+  const make = (eye: 'left' | 'right', offset: number, left: number, right: number): XrView => {
+    const world = mat4.create();
+    mat4.translate(world, world, [offset, headHeight, 0]);
+    return {
+      eye,
+      projectionMatrix: mat4.frustum(
+        mat4.create(),
+        left,
+        right,
+        -0.08,
+        0.08,
+        0.1,
+        1000,
+      ) as unknown as Float32Array,
+      /* The eye's pose in the reference space, which is what `XRView.transform` is. An earlier
+         draft inverted this twice by accident, which typechecked as `mat4 | null` and said so. */
+      transform: transform(world),
+    };
+  };
+  /* Each eye's frustum is off-centre towards its own side, which is what a headset's optics do. */
+  return [make('left', -half, -0.11, 0.09), make('right', half, -0.09, 0.11)];
+}
+
+export interface SyntheticOptions {
+  /** Modes the system reports and will grant. Everything else is refused. */
+  readonly modes?: readonly string[];
+  /** Reference spaces the session will grant, in the order it is asked. */
+  readonly spaces?: readonly string[];
+  readonly headHeight?: number;
+  /** One entry per controller. `hand` gives it twenty-five joints as well. */
+  readonly controllers?: readonly { handedness: 'left' | 'right'; hand?: boolean }[];
+  /** Views a frame carries. Two by default, which is what a headset gives. */
+  readonly views?: 'stereo' | 'mono';
+}
+
+export interface SyntheticSystem extends XrSystem {
+  /** Deliver one frame to whoever asked. Nothing happens on its own. */
+  advance(timeMs?: number): void;
+  /** Sessions this system has granted, in order. */
+  readonly sessions: SyntheticSession[];
+  /** End the newest session the way a runtime does when a headset is removed. */
+  endLatest(): void;
+}
+
+export interface SyntheticSession extends XrSession {
+  readonly renderState: { baseLayer?: XrWebGlLayer; layers?: readonly unknown[] };
+  readonly endedCount: number;
+  /** Set a button's analogue value on a controller, which also sets `pressed` past a half. */
+  setButton(handedness: 'left' | 'right', index: number, value: number): void;
+  /** Stop reporting a joint, the way an occluded finger stops being tracked. */
+  setJointTracked(handedness: 'left' | 'right', joint: string, tracked: boolean): void;
+}
+
+/**
+ * Build a runtime.
+ *
+ * Nothing is on a timer: `advance` is the only thing that produces a frame, so a test asserting
+ * about frame N is asserting about a frame it caused rather than one it waited for.
+ */
+export function syntheticXr(options: SyntheticOptions = {}): SyntheticSystem {
+  const modes = options.modes ?? ['immersive-vr', 'inline'];
+  const spaces = options.spaces ?? ['local-floor', 'local', 'viewer'];
+  const headHeight = options.headHeight ?? 1.6;
+  const wanted = options.controllers ?? [
+    { handedness: 'left', hand: true },
+    { handedness: 'right' },
+  ];
+  const sessions: SyntheticSession[] = [];
+
+  const system: SyntheticSystem = {
+    sessions,
+    async isSessionSupported(mode: string): Promise<boolean> {
+      return modes.includes(mode);
+    },
+    async requestSession(mode: string): Promise<XrSession> {
+      if (!modes.includes(mode)) {
+        const error = new Error(`no ${mode} device`);
+        error.name = 'NotSupportedError';
+        throw error;
+      }
+      const session = buildSession(mode);
+      sessions.push(session);
+      return session;
+    },
+    advance(timeMs = 16): void {
+      for (const session of sessions)
+        (session as unknown as { fire(t: number): void }).fire(timeMs);
+    },
+    endLatest(): void {
+      const session = sessions.at(-1);
+      void session?.end();
+    },
+  };
+
+  function buildSession(mode: string): SyntheticSession {
+    let pending: ((timeMs: number, frame: XrFrame) => void) | null = null;
+    let handle = 0;
+    let ended = 0;
+    let clock = 0;
+    const listeners = new Map<string, (() => void)[]>();
+    const renderState: { baseLayer?: XrWebGlLayer; layers?: readonly unknown[] } = {};
+
+    const buttons = new Map<string, number[]>();
+    const untracked = new Set<string>();
+    for (const controller of wanted) buttons.set(controller.handedness, [0, 0, 0, 0]);
+
+    const inputSources: XrInputSource[] = wanted.map((controller) => {
+      const gripSpace = { kind: 'grip', handedness: controller.handedness };
+      const targetRaySpace = { kind: 'ray', handedness: controller.handedness };
+      const gamepad: XrGamepad = {
+        get buttons() {
+          const values = buttons.get(controller.handedness) ?? [];
+          return values.map((value) => ({ pressed: value > 0.5, touched: value > 0, value }));
+        },
+        axes: [0, 0, 0.25, -0.5],
+      };
+      const hand: XrHand | undefined = controller.hand
+        ? {
+            size: HAND_JOINTS.length,
+            get: (joint: string) => ({ kind: 'joint', joint, handedness: controller.handedness }),
+            keys: () => HAND_JOINTS[Symbol.iterator]() as unknown as IterableIterator<string>,
+          }
+        : undefined;
+      return {
+        handedness: controller.handedness,
+        targetRayMode: 'tracked-pointer',
+        targetRaySpace,
+        gripSpace,
+        gamepad,
+        hand,
+      };
+    });
+
+    const viewport = (index: number): XrViewport => ({
+      x: index * 512,
+      y: 0,
+      width: 512,
+      height: 512,
+    });
+
+    const frameFor = (session: SyntheticSession): XrFrame => ({
+      session,
+      getViewerPose(): XrViewerPose | null {
+        const views =
+          options.views === 'mono'
+            ? [stereoViews(headHeight)[0] as XrView]
+            : stereoViews(headHeight);
+        const head = mat4.create();
+        mat4.translate(head, head, [0, headHeight, 0]);
+        return { views, transform: transform(head) };
+      },
+      getPose(space: unknown) {
+        const described = space as { kind?: string; handedness?: string } | null;
+        if (described?.handedness === undefined) return null;
+        const world = mat4.create();
+        mat4.translate(world, world, [described.handedness === 'left' ? -0.25 : 0.25, 1.1, -0.35]);
+        return { transform: transform(world) };
+      },
+      getJointPose(joint: unknown): XrJointPose | null {
+        const described = joint as { joint?: string; handedness?: string } | null;
+        if (described?.joint === undefined) return null;
+        if (untracked.has(`${described.handedness}:${described.joint}`)) return null;
+        const index = HAND_JOINTS.indexOf(described.joint as (typeof HAND_JOINTS)[number]);
+        const world = mat4.create();
+        mat4.translate(world, world, [
+          described.handedness === 'left' ? -0.25 : 0.25,
+          1.1 + index * 0.005,
+          -0.35,
+        ]);
+        return { transform: transform(world), radius: 0.008 };
+      },
+    });
+
+    const session: SyntheticSession = {
+      renderState,
+      get endedCount() {
+        return ended;
+      },
+      get inputSources() {
+        return inputSources;
+      },
+      async requestReferenceSpace(type: string): Promise<unknown> {
+        if (!spaces.includes(type)) {
+          const error = new Error(`no ${type}`);
+          error.name = 'NotSupportedError';
+          throw error;
+        }
+        return { kind: 'space', type };
+      },
+      updateRenderState(state) {
+        if (state.baseLayer !== undefined) renderState.baseLayer = state.baseLayer;
+        if (state.layers !== undefined) renderState.layers = state.layers;
+      },
+      requestAnimationFrame(callback) {
+        pending = callback;
+        return ++handle;
+      },
+      cancelAnimationFrame() {
+        pending = null;
+      },
+      async end(): Promise<void> {
+        ended++;
+        for (const listener of listeners.get('end') ?? []) listener();
+      },
+      addEventListener(type, listener) {
+        const list = listeners.get(type) ?? [];
+        list.push(listener);
+        listeners.set(type, list);
+      },
+      setButton(handedness, index, value) {
+        const values = buttons.get(handedness);
+        if (values !== undefined) values[index] = value;
+      },
+      setJointTracked(handedness, joint, tracked) {
+        const key = `${handedness}:${joint}`;
+        if (tracked) untracked.delete(key);
+        else untracked.add(key);
+      },
+    };
+
+    (session as unknown as { fire(t: number): void }).fire = (timeMs: number): void => {
+      const callback = pending;
+      pending = null;
+      clock += timeMs;
+      callback?.(clock, frameFor(session));
+    };
+
+    void mode;
+    return session;
+  }
+
+  return system;
+}
+
+/** A layer a synthetic session accepts, so the render-state path can be exercised too. */
+export function syntheticGlLayer(): XrWebGlLayer {
+  return {
+    framebuffer: { kind: 'framebuffer' },
+    framebufferWidth: 1024,
+    framebufferHeight: 512,
+    getViewport(view: XrView): XrViewport {
+      return { x: view.eye === 'right' ? 512 : 0, y: 0, width: 512, height: 512 };
+    },
+  };
+}

package/src/types.ts

@@ -0,0 +1,118 @@
+/**
+ * The parts of WebXR this package touches, declared here.
+ *
+ * **Declared and not imported, because `tsconfig.json` sets `"types": []`.** The engine's config
+ * says why: `@types/node` is installed for the tools, and TypeScript pulls in every `@types`
+ * package it can find unless a config says otherwise, so a stray `Buffer` would compile here and
+ * fail in somebody's game. `@types/webxr` would be the same trade in the other direction, and its
+ * own note already sanctions the alternative: *`src/` and `demo/` reach the DOM through the `lib`
+ * above and declare anything else they need themselves.*
+ *
+ * So these are the shapes this package reads, written out. They are deliberately **narrower than
+ * the specification**: what is here is what the code below touches, and a field nobody reads is a
+ * field nobody has to keep in step with a moving standard.
+ */
+
+/** A pose's transform. Only the matrix is read; the decomposed parts are the runtime's convenience. */
+export interface XrRigidTransform {
+  readonly matrix: Float32Array;
+  readonly inverse?: { readonly matrix: Float32Array };
+}
+
+/** One eye, or the single view an inline session offers. */
+export interface XrView {
+  readonly eye: 'left' | 'right' | 'none';
+  readonly projectionMatrix: Float32Array;
+  readonly transform: XrRigidTransform;
+}
+
+export interface XrViewerPose {
+  readonly views: readonly XrView[];
+  readonly transform: XrRigidTransform;
+}
+
+/** Where in the layer's texture one eye draws. */
+export interface XrViewport {
+  readonly x: number;
+  readonly y: number;
+  readonly width: number;
+  readonly height: number;
+}
+
+export interface XrWebGlLayer {
+  readonly framebuffer: unknown;
+  readonly framebufferWidth: number;
+  readonly framebufferHeight: number;
+  getViewport(view: XrView): XrViewport | undefined;
+}
+
+/** A joint of a hand, keyed by the twenty-five names the specification fixes. */
+export interface XrJointPose {
+  readonly transform: XrRigidTransform;
+  readonly radius: number | null;
+}
+
+export interface XrHand {
+  readonly size: number;
+  get(joint: string): unknown;
+  keys(): IterableIterator<string>;
+}
+
+export interface XrGamepadButton {
+  readonly pressed: boolean;
+  readonly touched: boolean;
+  readonly value: number;
+}
+
+export interface XrGamepad {
+  readonly buttons: readonly XrGamepadButton[];
+  readonly axes: readonly number[];
+}
+
+export interface XrInputSource {
+  readonly handedness: 'left' | 'right' | 'none';
+  readonly targetRayMode: string;
+  readonly targetRaySpace: unknown;
+  readonly gripSpace?: unknown;
+  readonly gamepad?: XrGamepad;
+  readonly hand?: XrHand;
+}
+
+export interface XrFrame {
+  readonly session: XrSession;
+  getViewerPose(space: unknown): XrViewerPose | null | undefined;
+  getPose?(
+    space: unknown,
+    base: unknown,
+  ): { readonly transform: XrRigidTransform } | null | undefined;
+  getJointPose?(joint: unknown, base: unknown): XrJointPose | null | undefined;
+}
+
+export interface XrRenderState {
+  baseLayer?: XrWebGlLayer;
+  layers?: readonly unknown[];
+  depthNear?: number;
+  depthFar?: number;
+}
+
+export interface XrSession {
+  readonly inputSources: Iterable<XrInputSource>;
+  requestReferenceSpace(type: string): Promise<unknown>;
+  updateRenderState(state: XrRenderState): void;
+  requestAnimationFrame(callback: (timeMs: number, frame: XrFrame) => void): number;
+  cancelAnimationFrame(handle: number): void;
+  end(): Promise<void>;
+  addEventListener(type: string, listener: () => void): void;
+  removeEventListener?(type: string, listener: () => void): void;
+}
+
+export interface XrSystem {
+  isSessionSupported(mode: string): Promise<boolean>;
+  requestSession(
+    mode: string,
+    options?: { optionalFeatures?: readonly string[] },
+  ): Promise<XrSession>;
+}
+
+/** The session modes this package will ask for. */
+export type XrMode = 'immersive-vr' | 'immersive-ar' | 'inline';

package/src/views.ts

@@ -0,0 +1,95 @@
+/**
+ * An `XRView` turned into something the engine's camera can adopt.
+ *
+ * **The whole of the stereo path is here, and it is smaller than it sounds.** A frame carries one
+ * view per eye; each has a projection the runtime computed for that eye's optics and a transform
+ * giving where that eye is in the reference space. The engine draws the scene once per view, into
+ * that view's slice of one layer texture.
+ *
+ * **A view matrix is the inverse of the eye's transform**, and that is the only arithmetic in this
+ * file. WebXR hands over the transform's own `inverse` when it has one, because it usually does and
+ * inverting a matrix per eye per frame to recompute a number already sitting there would be work
+ * for nothing. When it does not, this inverts. Both paths are exercised, because a runtime is free
+ * to omit it and a path taken only on somebody else's hardware is a path nobody has run.
+ */
+
+import { mat4 } from 'gl-matrix';
+import type { Camera } from '@driftengine/core';
+import type { XrView, XrViewerPose, XrViewport, XrWebGlLayer } from './types.ts';
+
+/** One eye's matrices and where it draws. */
+export interface EyeView {
+  readonly eye: 'left' | 'right' | 'none';
+  /** The inverse of the eye's transform, which is what a camera calls its view. */
+  readonly view: mat4;
+  readonly projection: mat4;
+  /** Where in the layer's texture this eye belongs, or null when the layer offered none. */
+  readonly viewport: XrViewport | null;
+}
+
+/**
+ * Reused across frames and eyes, because this runs twice a frame forever.
+ *
+ * Two of each, so a caller holding the left eye's matrices while it draws the right one still has
+ * them. A single scratch would be the kind of reuse that works until somebody keeps a reference.
+ */
+const scratch = [
+  { view: mat4.create(), projection: mat4.create() },
+  { view: mat4.create(), projection: mat4.create() },
+];
+
+/** Grown only if a runtime ever offers more views than eyes. Nothing does today. */
+function slotFor(index: number): { view: mat4; projection: mat4 } {
+  while (scratch.length <= index) scratch.push({ view: mat4.create(), projection: mat4.create() });
+  return scratch[index] as { view: mat4; projection: mat4 };
+}
+
+/**
+ * Turn a pose's views into eye views, into reused storage.
+ *
+ * `out` is filled and returned so a caller in a frame loop allocates nothing. Its length is set to
+ * the number of views the pose carried, which is one for an inline session and two for a stereo
+ * one, and which this package never assumes.
+ */
+export function eyeViews(
+  pose: XrViewerPose,
+  layer: XrWebGlLayer | null,
+  out: EyeView[] = [],
+): EyeView[] {
+  out.length = 0;
+  for (let i = 0; i < pose.views.length; i++) {
+    const view = pose.views[i] as XrView;
+    const slot = slotFor(i);
+
+    /*
+     * The runtime's own inverse where there is one. A transform's `inverse` is a spec field and is
+     * normally present; inverting to recompute it would be a matrix inversion per eye per frame for
+     * a number already in memory.
+     */
+    const inverse = view.transform.inverse?.matrix;
+    if (inverse !== undefined) mat4.copy(slot.view, inverse as unknown as mat4);
+    else mat4.invert(slot.view, view.transform.matrix as unknown as mat4);
+
+    mat4.copy(slot.projection, view.projectionMatrix as unknown as mat4);
+
+    out.push({
+      eye: view.eye,
+      view: slot.view,
+      projection: slot.projection,
+      viewport: layer?.getViewport(view) ?? null,
+    });
+  }
+  return out;
+}
+
+/**
+ * Point a camera at one eye.
+ *
+ * A one-line function on purpose: the interesting half is `Camera.adoptView`, which lives in core
+ * because the camera is core's and the reason it cannot derive these matrices is written there.
+ * What this adds is the direction of the dependency. `@driftengine/xr` supplies views to a camera;
+ * nothing in core reaches back for a session.
+ */
+export function aimCameraAtEye(camera: Camera, eye: EyeView): void {
+  camera.adoptView(eye.view, eye.projection);
+}