@opsydyn/effect-three-foldkit 0.0.0-stage → 0.1.0

package/dist/dom/viewport.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Element size, visibility and motion preference.
+ *
+ * @module
+ */
+import type { Viewport } from '@opsydyn/effect-three';
+/**
+ * The drawing buffer's pixel ratio: a fixed number, or `[min, max]` to follow the device
+ * within bounds. React Three Fiber's `dpr`, with its `[1, 2]` default (`calculateDpr` in
+ * `core/utils.tsx` at `d74622e`): ratios above 2 cost GPU time for little visible gain.
+ */
+export type PixelRatio = number | readonly [min: number, max: number];
+export declare const defaultPixelRatio: PixelRatio;
+/** Resolves a pixel ratio setting against the device's ratio. */
+export declare const resolvePixelRatio: (devicePixelRatio: number, setting: PixelRatio) => number;
+/** The element's current viewport, with the pixel ratio resolved. */
+export declare const measureViewport: (element: Element, devicePixelRatio: number, pixelRatio?: PixelRatio) => Viewport;
+/** Calls `onResize` whenever the element's size changes. Returns a disconnect function. */
+export declare const observeSize: (element: Element, onResize: () => void) => (() => void);
+/** Calls `onVisible` with whether any part of the element is on screen. */
+export declare const observeVisibility: (element: Element, onVisible: (visible: boolean) => void) => (() => void);
+/** Calls `onChange` with the current reduced-motion preference, then on every change. */
+export declare const observeReducedMotion: (view: Pick<Window, 'matchMedia'>, onChange: (reduced: boolean) => void) => (() => void);
+/** The media query calls the pixel-ratio watch needs; `window` provides them. */
+type ChangeTarget = {
+    addEventListener(type: 'change', listener: () => void): void;
+    removeEventListener(type: 'change', listener: () => void): void;
+};
+export type PixelRatioHost = {
+    readonly devicePixelRatio: number;
+    readonly matchMedia: (query: string) => ChangeTarget;
+};
+/**
+ * Calls `onChange` whenever the device pixel ratio changes (moving to another display, or
+ * zooming), which resizes nothing. As React Three Fiber's `watchDpr`: a media query for
+ * the current resolution, re-armed for the new ratio after each change.
+ */
+export declare const observePixelRatio: (view: PixelRatioHost, onChange: () => void) => (() => void);
+export {};
+//# sourceMappingURL=viewport.d.ts.map

package/dist/dom/viewport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"viewport.d.ts","sourceRoot":"","sources":["../../src/dom/viewport.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEtD;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC;AAEtE,eAAO,MAAM,iBAAiB,EAAE,UAAmB,CAAC;AAEpD,iEAAiE;AACjE,eAAO,MAAM,iBAAiB,qBAAsB,MAAM,WAAW,UAAU,KAAG,MAGhB,CAAC;AAEnE,qEAAqE;AACrE,eAAO,MAAM,eAAe,YACjB,OAAO,oBACE,MAAM,eACZ,UAAU,KACrB,QAOF,CAAC;AAEF,2FAA2F;AAC3F,eAAO,MAAM,WAAW,YAAa,OAAO,YAAY,MAAM,IAAI,KAAG,CAAC,MAAM,IAAI,CAI/E,CAAC;AAEF,2EAA2E;AAC3E,eAAO,MAAM,iBAAiB,YACnB,OAAO,aACL,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,KACpC,CAAC,MAAM,IAAI,CAMb,CAAC;AAEF,yFAAyF;AACzF,eAAO,MAAM,oBAAoB,SACzB,IAAI,CAAC,MAAM,EAAE,YAAY,CAAC,YACtB,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,KACnC,CAAC,MAAM,IAAI,CAMb,CAAC;AAEF,iFAAiF;AACjF,KAAK,YAAY,GAAG;IAClB,gBAAgB,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI,CAAC;IAC7D,mBAAmB,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI,CAAC;CACjE,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,YAAY,CAAC;CACtD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,SAAU,cAAc,YAAY,MAAM,IAAI,KAAG,CAAC,MAAM,IAAI,CAazF,CAAC"}

package/dist/dom/webgl.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The WebGL2 renderer behind the core's backend-neutral renderer contract.
+ *
+ * @module
+ */
+import type { RendererFactory } from '@opsydyn/effect-three';
+import { type WebGLRendererParameters } from 'three';
+/** Options passed through to three's `WebGLRenderer`. The canvas is always the scene's own. */
+export type WebGLOptions = Omit<WebGLRendererParameters, 'canvas'>;
+/** A factory for a WebGL2 renderer drawing into `canvas`. `create` throws if WebGL2 is unavailable. */
+export declare const webglRendererFactory: (canvas: HTMLCanvasElement, options?: WebGLOptions) => RendererFactory;
+//# sourceMappingURL=webgl.d.ts.map

package/dist/dom/webgl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgl.d.ts","sourceRoot":"","sources":["../../src/dom/webgl.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,eAAe,EAAgC,MAAM,uBAAuB,CAAC;AAE3F,OAAO,EASL,KAAK,uBAAuB,EAE7B,MAAM,OAAO,CAAC;AAaf,+FAA+F;AAC/F,MAAM,MAAM,YAAY,GAAG,IAAI,CAAC,uBAAuB,EAAE,QAAQ,CAAC,CAAC;AAyEnE,uGAAuG;AACvG,eAAO,MAAM,oBAAoB,WACvB,iBAAiB,YAChB,YAAY,KACpB,eA0GD,CAAC"}

package/dist/dom/webgpu.d.ts

@@ -0,0 +1,23 @@
+/**
+ * three.js's `WebGPURenderer` behind the core's renderer contract: WebGPU where the browser
+ * has it, otherwise its WebGL 2 backend (or always, with `forceWebGL`), drawing the same
+ * node materials either way. It carries the WebGPU render kit (the sky, shader grid and
+ * contact shadows in TSL), post-processes with `RenderPipeline`, and presents in WebXR.
+ * It starts asynchronously (`init()`), which the runtime waits for.
+ *
+ * Not drawn under it: labels, which troika makes from WebGL shaders; a label engine's
+ * labels are silently empty here.
+ *
+ * @module
+ */
+import type { RendererFactory } from '@opsydyn/effect-three';
+/** Options for three's `WebGPURenderer`. The canvas is always the scene's own. */
+export type WebGPUOptions = {
+    /** Use the WebGL 2 backend even where WebGPU is available. */
+    readonly forceWebGL?: boolean;
+    readonly alpha?: boolean;
+    readonly antialias?: boolean;
+};
+/** A factory for three's `WebGPURenderer` drawing into `canvas`. */
+export declare const webgpuRendererFactory: (canvas: HTMLCanvasElement, options?: WebGPUOptions) => RendererFactory;
+//# sourceMappingURL=webgpu.d.ts.map

package/dist/dom/webgpu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgpu.d.ts","sourceRoot":"","sources":["../../src/dom/webgpu.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAAE,eAAe,EAAgC,MAAM,uBAAuB,CAAC;AAwB3F,kFAAkF;AAClF,MAAM,MAAM,aAAa,GAAG;IAC1B,8DAA8D;IAC9D,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;CAC9B,CAAC;AA+DF,oEAAoE;AACpE,eAAO,MAAM,qBAAqB,WACxB,iBAAiB,YAChB,aAAa,KACrB,eA8FD,CAAC"}

package/dist/dom/webgpuPostprocessing.d.ts

@@ -0,0 +1,4 @@
+import { type WebGPURenderer } from 'three/webgpu';
+import type { PostProcessing } from './postprocessing.ts';
+export declare const createWebGPUPostProcessing: (renderer: WebGPURenderer) => PostProcessing;
+//# sourceMappingURL=webgpuPostprocessing.d.ts.map

package/dist/dom/webgpuPostprocessing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgpuPostprocessing.d.ts","sourceRoot":"","sources":["../../src/dom/webgpuPostprocessing.ts"],"names":[],"mappings":"AA4BA,OAAO,EAA6B,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAE9E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAwB1D,eAAO,MAAM,0BAA0B,aAAc,cAAc,KAAG,cAwCrE,CAAC"}

package/dist/dom/xr.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Presenting a scene in a WebXR session through three.js's `WebXRManager`.
+ *
+ * Behavioural references: React Three Fiber `core/configuration.ts` at `d74622e` (on
+ * `sessionstart` enable XR and hand frames to `xr.setAnimationLoop`; on `sessionend` take
+ * them back and draw again), and pmndrs/xr at `0e1acd8` (`store.ts` `setupXRManager`:
+ * reference space type and framebuffer scale before `setSession`; `init.ts`
+ * `buildXRSessionInit`: the reference space required, other features optional). The
+ * player's origin is an offset reference space, as three.js's teleport example moves
+ * the viewer. Controller selects become rays, as `@react-three/xr`'s pointers hit-test
+ * along each controller's target ray.
+ *
+ * @module
+ */
+import type { Xr, XrInput } from '@opsydyn/effect-three';
+import { type Object3D } from 'three';
+import type { PresentableRenderer } from './renderSettings.ts';
+import { type Follow, type LendGeometry } from './xrSpaces.ts';
+/** Where an immersive session can come from: `navigator.xr`, or an emulator's. */
+export type XrSystem = Pick<XRSystem, 'requestSession' | 'isSessionSupported'>;
+/** The immersive session modes. */
+export type XrMode = 'immersive-vr' | 'immersive-ar';
+/**
+ * The session request for a scene's settings: its reference space required, other
+ * floors, hand tracking and anchors optional, and plane detection, a DOM overlay (on
+ * `overlay`, the scene's element) and in AR hit testing when the scene asks for them
+ * (pmndrs/xr's `buildXRSessionInit` asks for every feature it may use, optionally, and
+ * roots the overlay on the element it is given). Anchors are asked for whether or not
+ * the scene has any yet: it may place them mid-session.
+ */
+export declare const sessionInit: (settings: Xr, mode?: XrMode, overlay?: Element) => XRSessionInit;
+export type Presentation = {
+    /** Applies new settings mid-session: a new origin or heading moves the player. */
+    readonly update: (settings: Xr) => void;
+    readonly session: XRSession;
+};
+/** What a session presents: the scene, and how it is drawn, followed and told of input. */
+export type Presented = {
+    readonly scene: Object3D;
+    readonly draw: () => void;
+    /** Places the groups that follow tracked spaces (`group({ follow })`). */
+    readonly follow: Follow;
+    /** Lends detected meshes' geometry to the scene (`xrMesh(id)`). */
+    readonly lend: LendGeometry;
+    readonly input: (input: XrInput) => void;
+};
+/**
+ * Presents into `session`: frames come from the session (each read for input and the
+ * spaces groups follow, then drawn) until it ends, when `ended` is called and the page's
+ * own frames take over again. Input sources are drawn into the scene while it presents.
+ */
+export declare const present: (renderer: PresentableRenderer, session: XRSession, settings: Xr, presented: Presented, ended: () => void) => Promise<Presentation>;
+//# sourceMappingURL=xr.d.ts.map

package/dist/dom/xr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xr.d.ts","sourceRoot":"","sources":["../../src/dom/xr.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EAAE,EAAE,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAS,KAAK,QAAQ,EAAE,MAAM,OAAO,CAAC;AAE7C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAG/D,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,YAAY,EAAe,MAAM,eAAe,CAAC;AAE5E,kFAAkF;AAClF,MAAM,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,EAAE,gBAAgB,GAAG,oBAAoB,CAAC,CAAC;AAE/E,mCAAmC;AACnC,MAAM,MAAM,MAAM,GAAG,cAAc,GAAG,cAAc,CAAC;AAErD;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,aACZ,EAAE,SACN,MAAM,YACF,OAAO,KAChB,aAYD,CAAC;AAkDH,MAAM,MAAM,YAAY,GAAG;IACzB,kFAAkF;IAClF,QAAQ,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,EAAE,KAAK,IAAI,CAAC;IACxC,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC;CAC7B,CAAC;AAEF,2FAA2F;AAC3F,MAAM,MAAM,SAAS,GAAG;IACtB,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,IAAI,CAAC;IAC1B,0EAA0E;IAC1E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,mEAAmE;IACnE,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CAC1C,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,OAAO,aACR,mBAAmB,WACpB,SAAS,YACR,EAAE,aACD,SAAS,SACb,MAAM,IAAI,KAChB,OAAO,CAAC,YAAY,CAgFtB,CAAC"}

package/dist/dom/xrGlide.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Gliding with the thumbsticks while presenting (`xr({ glide })`), one frame at a time.
+ *
+ * Behavioural reference: pmndrs/xr at `0e1acd8`, `packages/xr/src/controller-locomotion.ts`:
+ * the left stick moves the player along the head's facing, flattened onto the floor, at
+ * `speed` metres per second at full stick (forward is the stick pushed away, negative y);
+ * the right stick turns, smoothly at `turnSpeed`, or by `snapDegrees` once per push past
+ * halfway, ready again once back under it. Unlike there, a still stick is a still player
+ * (a small dead zone keeps resting thumbsticks from drifting), and the frame that stops
+ * says where the player ended, for the Model.
+ *
+ * @module
+ */
+import type { Vec3, XrGlide } from '@opsydyn/effect-three';
+/** Where the player stands: the reference space's origin in the scene, and its heading. */
+export type GlidePose = {
+    readonly origin: Vec3;
+    readonly heading: number;
+};
+/** A thumbstick, `[x, y]`, each −1 to 1 (`y` negative pushed away). */
+export type Stick = readonly [x: number, y: number];
+/** Gliding's state between frames. */
+export type Glider = {
+    readonly pose: GlidePose;
+    /** Whether a snap turn is ready (the turning stick has been back under halfway). */
+    readonly snapReady: boolean;
+    /** Whether the pose moved since the last report. */
+    readonly moved: boolean;
+};
+export declare const startGlider: (pose: GlidePose) => Glider;
+/** The head's facing on the floor, from its orientation quaternion: −z turned, flattened. */
+export declare const floorFacing: (q: {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+    readonly w: number;
+}) => readonly [x: number, z: number];
+/**
+ * One frame of gliding. Returns the next state, and the pose to report when the sticks
+ * have just come to rest after moving it.
+ */
+export declare const glideFrame: (glider: Glider, glide: XrGlide, sticks: {
+    readonly move: Stick;
+    readonly turn: Stick;
+}, facing: readonly [number, number], seconds: number) => {
+    readonly glider: Glider;
+    readonly stopped: GlidePose | undefined;
+};
+//# sourceMappingURL=xrGlide.d.ts.map

package/dist/dom/xrGlide.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xrGlide.d.ts","sourceRoot":"","sources":["../../src/dom/xrGlide.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAE3D,2FAA2F;AAC3F,MAAM,MAAM,SAAS,GAAG;IAAE,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAE5E,uEAAuE;AACvE,MAAM,MAAM,KAAK,GAAG,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC;AAEpD,sCAAsC;AACtC,MAAM,MAAM,MAAM,GAAG;IACnB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,oFAAoF;IACpF,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,oDAAoD;IACpD,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB,CAAC;AAOF,eAAO,MAAM,WAAW,SAAU,SAAS,KAAG,MAAmD,CAAC;AAElG,6FAA6F;AAC7F,eAAO,MAAM,WAAW,MAAO;IAC7B,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;CACpB,KAAG,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,CAKjC,CAAC;AA2CF;;;GAGG;AACH,eAAO,MAAM,UAAU,WACb,MAAM,SACP,OAAO,UACN;IAAE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAA;CAAE,UAC9C,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,WACxB,MAAM,KACd;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,SAAS,GAAG,SAAS,CAAA;CAYpE,CAAC"}

package/dist/dom/xrHub.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The page's immersive sessions: which mounted scenes can be presented, and the one
+ * session (WebXR allows one at a time) presenting a scene.
+ *
+ * @module
+ */
+import type { Xr, XrInput } from '@opsydyn/effect-three';
+import type { Object3D } from 'three';
+import { type XrMode, type XrSystem } from './xr.ts';
+import type { Follow, LendGeometry } from './xrSpaces.ts';
+export type { XrMode } from './xr.ts';
+/** A mounted scene that can be presented. */
+export type XrTarget = {
+    readonly canvas: HTMLCanvasElement;
+    /** The scene's current `xr` description; `null` while it does not ask to be presented. */
+    readonly settings: () => Xr | null;
+    /** Draws one frame now (the session calls it for each of its frames). */
+    readonly draw: () => void;
+    /** The scene's three.js root, where input sources are drawn while it presents. */
+    readonly scene: Object3D;
+    /** The scene's element: the DOM overlay's root, when the scene asks for one. */
+    readonly element: Element;
+    /** Places the groups that follow tracked spaces. */
+    readonly follow: Follow;
+    /** Lends a geometry to the scene's store, for detected meshes. */
+    readonly lend: LendGeometry;
+    /** Input from the session: aims, selects, sticks, buttons and surfaces. */
+    readonly input: (input: XrInput) => void;
+    /** The session began presenting this scene in `mode`, or (with `null`) ended. */
+    readonly presenting: (mode: XrMode | null) => void;
+};
+export type XrHub = {
+    /** Makes a scene presentable; returns a function that withdraws it (ending its session). */
+    readonly register: (target: XrTarget) => () => void;
+    readonly supported: (mode: XrMode) => Promise<boolean>;
+    /**
+     * Requests a session and presents the first registered scene that describes `xr`.
+     * Call from a user gesture's handling: browsers require one to start a session.
+     */
+    readonly enter: (mode: XrMode) => Promise<void>;
+    readonly exit: () => Promise<void>;
+};
+/** Creates the hub for a page; `system` is `navigator.xr` when the browser has WebXR. */
+export declare const createXrHub: (system: () => XrSystem | undefined) => XrHub;
+//# sourceMappingURL=xrHub.d.ts.map

package/dist/dom/xrHub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xrHub.d.ts","sourceRoot":"","sources":["../../src/dom/xrHub.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,EAAE,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAGtC,OAAO,EAA2C,KAAK,MAAM,EAAE,KAAK,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC9F,OAAO,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAE1D,YAAY,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAEtC,6CAA6C;AAC7C,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAC;IACnC,0FAA0F;IAC1F,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IACnC,yEAAyE;IACzE,QAAQ,CAAC,IAAI,EAAE,MAAM,IAAI,CAAC;IAC1B,kFAAkF;IAClF,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;IACzB,gFAAgF;IAChF,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,oDAAoD;IACpD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,kEAAkE;IAClE,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,2EAA2E;IAC3E,QAAQ,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IACzC,iFAAiF;IACjF,QAAQ,CAAC,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;CACpD,CAAC;AAEF,MAAM,MAAM,KAAK,GAAG;IAClB,4FAA4F;IAC5F,QAAQ,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,QAAQ,KAAK,MAAM,IAAI,CAAC;IACpD,QAAQ,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACvD;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAChD,QAAQ,CAAC,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACpC,CAAC;AAIF,yFAAyF;AACzF,eAAO,MAAM,WAAW,WAAY,MAAM,QAAQ,GAAG,SAAS,KAAG,KAkEhE,CAAC"}

package/dist/dom/xrInputs.d.ts

@@ -0,0 +1,40 @@
+/**
+ * A session's input sources, each frame: where each points (`Aim`), its gamepad's sticks
+ * and buttons, in AR where its ray meets a real surface, and drawing its ray and a hand's
+ * joints into the presented scene.
+ *
+ * Behavioural references: pmndrs/xr at `0e1acd8` (`packages/xr/src/pointer` ray-casts
+ * along every source's target ray each frame; `controller-locomotion.ts` reads the
+ * `xr-standard` thumbstick, axes 2 and 3, forward negative; `hit-test.ts` requests a hit
+ * test source per space and reads `getHitTestResults` each frame), and three.js's
+ * `XRHandPrimitiveModel` at 0.186.1 (a sphere per hand joint, sized by its radius).
+ *
+ * @module
+ */
+import type { Ray, Xr, XrInput, XrStickDirection } from '@opsydyn/effect-three';
+import { Group } from 'three';
+/** A target ray pose as a ray in the reference space: from its position along its −z. */
+export declare const rayOf: (pose: XRPose) => Ray;
+/** Where a stick at `(x, y)` points, keeping `previous` until it clearly changes. */
+export declare const stickDirection: (x: number, y: number, previous: XrStickDirection) => XrStickDirection;
+export type XrInputs = {
+    /** Reads every input source in this frame, in `space` (the scene's). */
+    readonly frame: (frame: XRFrame, space: XRReferenceSpace) => void;
+    /** A source's id, the same for its selects as for its aims. */
+    readonly idOf: (source: XRInputSource) => number;
+    /** A select ended: in AR with hit tests, report where its ray met a surface. */
+    readonly selected: (source: XRInputSource) => void;
+    /** Ends tracking: every source is lost, and the visuals go. */
+    readonly stop: () => void;
+    /** Each hand's thumbstick this frame (`[0, 0]` without one). */
+    readonly sticks: () => {
+        readonly left: readonly [number, number];
+        readonly right: readonly [number, number];
+    };
+};
+/**
+ * Tracks `session`'s input sources, sending what they do to `input` and drawing them into
+ * `group` (added to the presented scene) while `settings().showInputs`.
+ */
+export declare const trackInputs: (session: XRSession, group: Group, settings: () => Xr | null, input: (input: XrInput) => void) => XrInputs;
+//# sourceMappingURL=xrInputs.d.ts.map

package/dist/dom/xrInputs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xrInputs.d.ts","sourceRoot":"","sources":["../../src/dom/xrInputs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EACV,GAAG,EAEH,EAAE,EAGF,OAAO,EACP,gBAAgB,EACjB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAGL,KAAK,EASN,MAAM,OAAO,CAAC;AAEf,yFAAyF;AACzF,eAAO,MAAM,KAAK,SAAU,MAAM,KAAG,GAQpC,CAAC;AAeF,qFAAqF;AACrF,eAAO,MAAM,cAAc,MACtB,MAAM,KACN,MAAM,YACC,gBAAgB,KACzB,gBAKF,CAAC;AA8FF,MAAM,MAAM,QAAQ,GAAG;IACrB,wEAAwE;IACxE,QAAQ,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,gBAAgB,KAAK,IAAI,CAAC;IAClE,+DAA+D;IAC/D,QAAQ,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,MAAM,CAAC;IACjD,gFAAgF;IAChF,QAAQ,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,IAAI,CAAC;IACnD,+DAA+D;IAC/D,QAAQ,CAAC,IAAI,EAAE,MAAM,IAAI,CAAC;IAC1B,gEAAgE;IAChE,QAAQ,CAAC,MAAM,EAAE,MAAM;QACrB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACzC,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KAC3C,CAAC;CACH,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,WAAW,YACb,SAAS,SACX,KAAK,YACF,MAAM,EAAE,GAAG,IAAI,SAClB,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,KAC9B,QAuHF,CAAC"}

package/dist/dom/xrSpaces.d.ts

@@ -0,0 +1,33 @@
+/**
+ * What a session tracks for the scene's description, each frame: where every space a
+ * group follows is (`group({ follow })`), the anchors the scene placed
+ * (`xr({ anchors })`), and the planes the session detected (`xr({ planes: true })`).
+ *
+ * Behavioural reference: pmndrs/xr at `0e1acd8`: `space.ts` `createGetXRSpaceMatrix` (an
+ * object on a space takes the space's pose in the reference space each frame, and none
+ * while the frame has no pose for it), `anchor.ts` `requestXRAnchor` (`frame.createAnchor`
+ * with a rigid transform in the origin's reference space), `store.ts` `updateSession` (the
+ * frame's `detectedPlanes` and `detectedMeshes` read each frame, passed on when the set
+ * changes), `plane.ts` (a plane is made again once it changes) and `mesh.ts` (a detected
+ * mesh's geometry built from its `vertices` and `indices`, again when they change).
+ *
+ * @module
+ */
+import { type BodyPose, type Xr, type XrInput, type XrSpace } from '@opsydyn/effect-three';
+import { BufferGeometry } from 'three';
+/** Places the scene's following groups where `locate` finds their spaces. */
+export type Follow = (locate: (space: XrSpace) => BodyPose | undefined) => void;
+/** Lends a geometry to the scene's store under `id`; returns a function that withdraws it. */
+export type LendGeometry = (id: string, geometry: BufferGeometry) => () => void;
+export type XrSpaces = {
+    /** Brings anchors and planes up to date in this frame, then places the following groups. */
+    readonly frame: (frame: XRFrame, space: XRReferenceSpace) => void;
+    /** Ends tracking: anchors are deleted, and every following group is hidden. */
+    readonly stop: () => void;
+};
+/**
+ * Tracks the spaces `session` can locate for the description `settings()`, placing its
+ * following groups with `follow` and reporting detected planes to `input`.
+ */
+export declare const trackSpaces: (session: XRSession, settings: () => Xr | null, follow: Follow, input: (input: XrInput) => void, lend: LendGeometry) => XrSpaces;
+//# sourceMappingURL=xrSpaces.d.ts.map

package/dist/dom/xrSpaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xrSpaces.d.ts","sourceRoot":"","sources":["../../src/dom/xrSpaces.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EACL,KAAK,QAAQ,EAEb,KAAK,EAAE,EAEP,KAAK,OAAO,EAIZ,KAAK,OAAO,EACb,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAmB,cAAc,EAAqB,MAAM,OAAO,CAAC;AAE3E,6EAA6E;AAC7E,MAAM,MAAM,MAAM,GAAG,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,QAAQ,GAAG,SAAS,KAAK,IAAI,CAAC;AAEhF,8FAA8F;AAC9F,MAAM,MAAM,YAAY,GAAG,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,KAAK,MAAM,IAAI,CAAC;AAEhF,MAAM,MAAM,QAAQ,GAAG;IACrB,4FAA4F;IAC5F,QAAQ,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,gBAAgB,KAAK,IAAI,CAAC;IAClE,+EAA+E;IAC/E,QAAQ,CAAC,IAAI,EAAE,MAAM,IAAI,CAAC;CAC3B,CAAC;AAqEF;;;GAGG;AACH,eAAO,MAAM,WAAW,YACb,SAAS,YACR,MAAM,EAAE,GAAG,IAAI,UACjB,MAAM,SACP,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,QACzB,YAAY,KACjB,QAwKF,CAAC"}

package/dist/dom/xrTarget.d.ts

@@ -0,0 +1,36 @@
+/**
+ * A mounted scene as an immersive session target: its frames handed to the session while
+ * it presents, and the session's start and end dispatched as `scene-xr` events.
+ *
+ * @module
+ */
+import type { GatedFrames, SceneEvent, Xr, XrInput } from '@opsydyn/effect-three';
+import type { Object3D } from 'three';
+import type { Latch } from './latch.ts';
+import type { XrMode, XrTarget } from './xrHub.ts';
+import type { Follow, LendGeometry } from './xrSpaces.ts';
+/**
+ * The page's frames for a scene: open while it is visible and no session presents it
+ * (a session brings its own frames, as React Three Fiber's loop stands aside).
+ */
+export declare const createFrameGate: (frames: GatedFrames) => {
+    setVisible: (next: boolean) => void;
+    setPresenting: (next: boolean) => void;
+};
+export type FrameGate = ReturnType<typeof createFrameGate>;
+/** The `scene-xr` event: the mode presenting, or `null` when the session ended. */
+export declare const dispatchXrSession: (element: Element, live: Latch, mode: XrMode | null) => void;
+/** A scene as a target for the page's immersive sessions. */
+export declare const xrTarget: (scene: {
+    readonly element: Element;
+    readonly canvas: HTMLCanvasElement;
+    readonly live: Latch;
+    readonly gate: FrameGate;
+    readonly settings: () => Xr | null;
+    readonly draw: () => void;
+    readonly scene: Object3D;
+    readonly follow: Follow;
+    readonly lend: LendGeometry;
+    readonly input: (input: XrInput) => ReadonlyArray<SceneEvent>;
+}) => XrTarget;
+//# sourceMappingURL=xrTarget.d.ts.map

package/dist/dom/xrTarget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xrTarget.d.ts","sourceRoot":"","sources":["../../src/dom/xrTarget.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,EAAE,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAClF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAEtC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACnD,OAAO,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAE1D;;;GAGG;AACH,eAAO,MAAM,eAAe,WAAY,WAAW;IAK/C,UAAU,SAAS,OAAO,KAAG,IAAI;IAIjC,aAAa,SAAS,OAAO,KAAG,IAAI;CAKvC,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC;AAE3D,mFAAmF;AACnF,eAAO,MAAM,iBAAiB,YAAa,OAAO,QAAQ,KAAK,QAAQ,MAAM,GAAG,IAAI,KAAG,IAEtF,CAAC;AAEF,6DAA6D;AAC7D,eAAO,MAAM,QAAQ,UAAW;IAC9B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAC;IACnC,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,IAAI,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,aAAa,CAAC,UAAU,CAAC,CAAC;CAC/D,KAAG,QAkBF,CAAC"}