@iwsdk/core 1.0.0-rc.1 → 1.0.0-rc.2

package/dist/gaze/gaze-system.d.ts

@@ -0,0 +1,207 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { Types } from '../ecs/index.js';
+declare const GazeSystem_base: import("elics").SystemConstructor<{
+    /**
+     * If true, gaze is suppressed whenever a near touch/grab pointer is in
+     * HOVER or SELECT. Set false to allow gaze to remain active concurrently.
+     * @default true
+     */
+    suppressWhenDirectPointerActive: {
+        type: Types.Boolean;
+        default: true;
+    };
+    /**
+     * 1€ filter min cutoff (lower = smoother, higher = more responsive).
+     * @default 1.5
+     */
+    filterMinCutoff: {
+        type: Types.Float32;
+        default: number;
+    };
+    /**
+     * 1€ filter beta (higher = less smoothing during fast saccades).
+     * @default 0.05
+     */
+    filterBeta: {
+        type: Types.Float32;
+        default: number;
+    };
+    /**
+     * Dwell window in seconds for consensus voting. `0` disables consensus.
+     * @default 0.15
+     */
+    dwellWindowSeconds: {
+        type: Types.Float32;
+        default: number;
+    };
+    /**
+     * Half-angle of the gaze selection cone, in degrees. Widening it makes
+     * small targets easier to acquire at the cost of more ambiguity between
+     * neighbours.
+     * @default 5
+     */
+    coneAngle: {
+        type: Types.Float32;
+        default: number;
+    };
+    /** Maximum gaze cone/raycast distance in meters. @default 30 */
+    maxRayLength: {
+        type: Types.Float32;
+        default: number;
+    };
+    /**
+     * On select commit, treat the pinching hand's ray space as the pointer
+     * origin instead of the eyes, so a gaze-initiated drag tracks the hand.
+     * @default true
+     */
+    pointerTransformFollowsHand: {
+        type: Types.Boolean;
+        default: true;
+    };
+    /**
+     * Emit `[iwsdk][gaze]` console diagnostics explaining why gaze is or isn't
+     * tracked, and whether the runtime's gaze ray actually separates from the
+     * head ray. Each message fires at most once per state change.
+     * @default true
+     */
+    logDiagnostics: {
+        type: Types.Boolean;
+        default: true;
+    };
+    /** Show a developer-only gaze hit reticle. @default false */
+    showDebugReticle: {
+        type: Types.Boolean;
+        default: false;
+    };
+    /** Keep gaze mode active briefly after tracking becomes invalid. @default 5 */
+    trackingLossGraceSeconds: {
+        type: Types.Float32;
+        default: number;
+    };
+}, {}, import("../ecs/world.js").World, import("../ecs/system.js").System<{
+    /**
+     * If true, gaze is suppressed whenever a near touch/grab pointer is in
+     * HOVER or SELECT. Set false to allow gaze to remain active concurrently.
+     * @default true
+     */
+    suppressWhenDirectPointerActive: {
+        type: Types.Boolean;
+        default: true;
+    };
+    /**
+     * 1€ filter min cutoff (lower = smoother, higher = more responsive).
+     * @default 1.5
+     */
+    filterMinCutoff: {
+        type: Types.Float32;
+        default: number;
+    };
+    /**
+     * 1€ filter beta (higher = less smoothing during fast saccades).
+     * @default 0.05
+     */
+    filterBeta: {
+        type: Types.Float32;
+        default: number;
+    };
+    /**
+     * Dwell window in seconds for consensus voting. `0` disables consensus.
+     * @default 0.15
+     */
+    dwellWindowSeconds: {
+        type: Types.Float32;
+        default: number;
+    };
+    /**
+     * Half-angle of the gaze selection cone, in degrees. Widening it makes
+     * small targets easier to acquire at the cost of more ambiguity between
+     * neighbours.
+     * @default 5
+     */
+    coneAngle: {
+        type: Types.Float32;
+        default: number;
+    };
+    /** Maximum gaze cone/raycast distance in meters. @default 30 */
+    maxRayLength: {
+        type: Types.Float32;
+        default: number;
+    };
+    /**
+     * On select commit, treat the pinching hand's ray space as the pointer
+     * origin instead of the eyes, so a gaze-initiated drag tracks the hand.
+     * @default true
+     */
+    pointerTransformFollowsHand: {
+        type: Types.Boolean;
+        default: true;
+    };
+    /**
+     * Emit `[iwsdk][gaze]` console diagnostics explaining why gaze is or isn't
+     * tracked, and whether the runtime's gaze ray actually separates from the
+     * head ray. Each message fires at most once per state change.
+     * @default true
+     */
+    logDiagnostics: {
+        type: Types.Boolean;
+        default: true;
+    };
+    /** Show a developer-only gaze hit reticle. @default false */
+    showDebugReticle: {
+        type: Types.Boolean;
+        default: false;
+    };
+    /** Keep gaze mode active briefly after tracking becomes invalid. @default 5 */
+    trackingLossGraceSeconds: {
+        type: Types.Float32;
+        default: number;
+    };
+}, {}>>;
+/**
+ * GazeSystem — wires the global {@link GazePointer} to ECS interactables.
+ *
+ * @remarks
+ * - Owns configuration and diagnostics only. The pointer itself lives on
+ *   {@link XRInputManager} (as `input.xr.gazePointer`) so `GrabSystem` can
+ *   identify the selecting hand; registering this system is what flips
+ *   `input.xr.gazeEnabled` and makes gaze cost anything at all.
+ * - Candidates come from the same ray-target snapshot used by hand rays.
+ * - The pointer samples the WebXR gaze target ray itself each frame;
+ *   `logDiagnostics` explains missing sources and invalid poses.
+ * - Selection is committed by either hand's pinch, with per-hand mutual
+ *   exclusion (the hand that started the pinch owns it until release).
+ * - Hover and selection flow through ordinary ray pointer events, so
+ *   {@link InputSystem} owns the shared `Hovered` / `Pressed` state.
+ * - Hand/controller far rays are disabled while gaze is available. Gaze is
+ *   optionally suppressed when a near touch/grab pointer is active, so direct
+ *   manipulation wins without an incidental far-ray hit stealing focus.
+ *
+ * @category Input
+ */
+export declare class GazeSystem extends GazeSystem_base {
+    /** One-shot latch for {@link GazeSystem.warnMissingFrame}. */
+    private warnedMissingFrame;
+    init(): void;
+    /**
+     * Push system config onto the shared pointer and its candidate provider.
+     *
+     * Cone geometry and dwell live on the provider rather than the pointer, and
+     * only the default {@link GazeConecaster} understands them — a custom
+     * provider installed via `setCandidateProvider` keeps its own tuning.
+     */
+    private applyGazeConfig;
+    update(): void;
+    /**
+     * There's a session but no frame or reference space, so the gaze pose can't
+     * be sampled at all this frame. Normally a one-frame startup blip; if it
+     * persists, gaze is unavailable and the developer should know.
+     */
+    private warnMissingFrame;
+}
+export {};
+//# sourceMappingURL=gaze-system.d.ts.map

package/dist/gaze/gaze-system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gaze-system.d.ts","sourceRoot":"","sources":["../../src/gaze/gaze-system.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAgB,KAAK,EAAE,MAAM,iBAAiB,CAAC;;IA0BlD;;;;OAIG;;;;;IAEH;;;OAGG;;;;;IAEH;;;OAGG;;;;;IAEH;;;OAGG;;;;;IAEH;;;;;OAKG;;;;;IAEH,gEAAgE;;;;;IAEhE;;;;OAIG;;;;;IAEH;;;;;OAKG;;;;;IAEH,6DAA6D;;;;;IAE7D,+EAA+E;;;;;;IA7C/E;;;;OAIG;;;;;IAEH;;;OAGG;;;;;IAEH;;;OAGG;;;;;IAEH;;;OAGG;;;;;IAEH;;;;;OAKG;;;;;IAEH,gEAAgE;;;;;IAEhE;;;;OAIG;;;;;IAEH;;;;;OAKG;;;;;IAEH,6DAA6D;;;;;IAE7D,+EAA+E;;;;;;AArEnF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,UAAW,SAAQ,eAmD/B;IACC,8DAA8D;IAC9D,OAAO,CAAC,kBAAkB,CAAS;IAEnC,IAAI,IAAI,IAAI;IA6BZ;;;;;;OAMG;IACH,OAAO,CAAC,eAAe;IAsBvB,MAAM,IAAI,IAAI;IAWd;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;CAUzB"}

package/dist/gaze/gaze-system.js

@@ -0,0 +1,168 @@
+import { GazeConecaster } from '@iwsdk/xr-input';
+import { createSystem } from '../ecs/system.js';
+import '../ecs/world.js';
+import { Types } from 'elics';
+import '@iwsdk/scene-composition';
+import '../ecs/builtin-components.js';
+import '../ecs/entity.js';
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * GazeSystem — wires the global {@link GazePointer} to ECS interactables.
+ *
+ * @remarks
+ * - Owns configuration and diagnostics only. The pointer itself lives on
+ *   {@link XRInputManager} (as `input.xr.gazePointer`) so `GrabSystem` can
+ *   identify the selecting hand; registering this system is what flips
+ *   `input.xr.gazeEnabled` and makes gaze cost anything at all.
+ * - Candidates come from the same ray-target snapshot used by hand rays.
+ * - The pointer samples the WebXR gaze target ray itself each frame;
+ *   `logDiagnostics` explains missing sources and invalid poses.
+ * - Selection is committed by either hand's pinch, with per-hand mutual
+ *   exclusion (the hand that started the pinch owns it until release).
+ * - Hover and selection flow through ordinary ray pointer events, so
+ *   {@link InputSystem} owns the shared `Hovered` / `Pressed` state.
+ * - Hand/controller far rays are disabled while gaze is available. Gaze is
+ *   optionally suppressed when a near touch/grab pointer is active, so direct
+ *   manipulation wins without an incidental far-ray hit stealing focus.
+ *
+ * @category Input
+ */
+class GazeSystem extends createSystem({}, {
+    /**
+     * If true, gaze is suppressed whenever a near touch/grab pointer is in
+     * HOVER or SELECT. Set false to allow gaze to remain active concurrently.
+     * @default true
+     */
+    suppressWhenDirectPointerActive: { type: Types.Boolean, default: true },
+    /**
+     * 1€ filter min cutoff (lower = smoother, higher = more responsive).
+     * @default 1.5
+     */
+    filterMinCutoff: { type: Types.Float32, default: 1.5 },
+    /**
+     * 1€ filter beta (higher = less smoothing during fast saccades).
+     * @default 0.05
+     */
+    filterBeta: { type: Types.Float32, default: 0.05 },
+    /**
+     * Dwell window in seconds for consensus voting. `0` disables consensus.
+     * @default 0.15
+     */
+    dwellWindowSeconds: { type: Types.Float32, default: 0.15 },
+    /**
+     * Half-angle of the gaze selection cone, in degrees. Widening it makes
+     * small targets easier to acquire at the cost of more ambiguity between
+     * neighbours.
+     * @default 5
+     */
+    coneAngle: { type: Types.Float32, default: 5 },
+    /** Maximum gaze cone/raycast distance in meters. @default 30 */
+    maxRayLength: { type: Types.Float32, default: 30 },
+    /**
+     * On select commit, treat the pinching hand's ray space as the pointer
+     * origin instead of the eyes, so a gaze-initiated drag tracks the hand.
+     * @default true
+     */
+    pointerTransformFollowsHand: { type: Types.Boolean, default: true },
+    /**
+     * Emit `[iwsdk][gaze]` console diagnostics explaining why gaze is or isn't
+     * tracked, and whether the runtime's gaze ray actually separates from the
+     * head ray. Each message fires at most once per state change.
+     * @default true
+     */
+    logDiagnostics: { type: Types.Boolean, default: true },
+    /** Show a developer-only gaze hit reticle. @default false */
+    showDebugReticle: { type: Types.Boolean, default: false },
+    /** Keep gaze mode active briefly after tracking becomes invalid. @default 5 */
+    trackingLossGraceSeconds: { type: Types.Float32, default: 5 },
+}) {
+    constructor() {
+        super(...arguments);
+        /** One-shot latch for {@link GazeSystem.warnMissingFrame}. */
+        this.warnedMissingFrame = false;
+    }
+    init() {
+        // Registering this system is the opt-in: until now the pointer existed but
+        // never sampled a pose or cast a cone.
+        this.input.xr.gazeEnabled = true;
+        this.cleanupFuncs.push(() => {
+            this.input.xr.gazeEnabled = false;
+        });
+        this.applyGazeConfig();
+        // Re-push on every config change so the editor's live tweaks land without
+        // rebuilding the pointer.
+        for (const key of [
+            'suppressWhenDirectPointerActive',
+            'filterMinCutoff',
+            'filterBeta',
+            'dwellWindowSeconds',
+            'coneAngle',
+            'maxRayLength',
+            'pointerTransformFollowsHand',
+            'logDiagnostics',
+            'showDebugReticle',
+            'trackingLossGraceSeconds',
+        ]) {
+            this.cleanupFuncs.push(this.config[key].subscribe(() => this.applyGazeConfig()));
+        }
+    }
+    /**
+     * Push system config onto the shared pointer and its candidate provider.
+     *
+     * Cone geometry and dwell live on the provider rather than the pointer, and
+     * only the default {@link GazeConecaster} understands them — a custom
+     * provider installed via `setCandidateProvider` keeps its own tuning.
+     */
+    applyGazeConfig() {
+        const pointer = this.input.xr.gazePointer;
+        pointer.suppressWhenDirectPointerActive =
+            this.config.suppressWhenDirectPointerActive.peek();
+        pointer.pointerTransformFollowsHand =
+            this.config.pointerTransformFollowsHand.peek();
+        pointer.diagnosticsEnabled = this.config.logDiagnostics.peek();
+        pointer.showDebugReticle = this.config.showDebugReticle.peek();
+        pointer.trackingLossGraceSeconds =
+            this.config.trackingLossGraceSeconds.peek();
+        pointer.filter.minCutoff = this.config.filterMinCutoff.peek();
+        pointer.filter.beta = this.config.filterBeta.peek();
+        const provider = pointer.provider;
+        if (provider instanceof GazeConecaster) {
+            // The conecaster works in radians; the config is in degrees.
+            provider.coneAngle = (this.config.coneAngle.peek() * Math.PI) / 180;
+            provider.coneLength = this.config.maxRayLength.peek();
+            provider.dwellWindowSeconds = this.config.dwellWindowSeconds.peek();
+        }
+    }
+    update() {
+        const session = this.xrManager.getSession();
+        if (!session) {
+            this.warnedMissingFrame = false;
+            return;
+        }
+        if (!this.xrManager.getFrame() || !this.xrManager.getReferenceSpace()) {
+            this.warnMissingFrame();
+        }
+    }
+    /**
+     * There's a session but no frame or reference space, so the gaze pose can't
+     * be sampled at all this frame. Normally a one-frame startup blip; if it
+     * persists, gaze is unavailable and the developer should know.
+     */
+    warnMissingFrame() {
+        if (this.warnedMissingFrame || !this.config.logDiagnostics.peek()) {
+            return;
+        }
+        this.warnedMissingFrame = true;
+        console.warn('[iwsdk][gaze] in an XR session but the renderer has no XRFrame or ' +
+            'reference space yet, so XR input cannot be sampled until this resolves.');
+    }
+}
+
+export { GazeSystem };
+//# sourceMappingURL=gaze-system.js.map

package/dist/gaze/gaze-system.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gaze-system.js","sources":["../../src/gaze/gaze-system.ts"],"sourcesContent":["/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nimport { GazeConecaster } from '@iwsdk/xr-input';\nimport { createSystem, Types } from '../ecs/index.js';\n\n/**\n * GazeSystem — wires the global {@link GazePointer} to ECS interactables.\n *\n * @remarks\n * - Owns configuration and diagnostics only. The pointer itself lives on\n *   {@link XRInputManager} (as `input.xr.gazePointer`) so `GrabSystem` can\n *   identify the selecting hand; registering this system is what flips\n *   `input.xr.gazeEnabled` and makes gaze cost anything at all.\n * - Candidates come from the same ray-target snapshot used by hand rays.\n * - The pointer samples the WebXR gaze target ray itself each frame;\n *   `logDiagnostics` explains missing sources and invalid poses.\n * - Selection is committed by either hand's pinch, with per-hand mutual\n *   exclusion (the hand that started the pinch owns it until release).\n * - Hover and selection flow through ordinary ray pointer events, so\n *   {@link InputSystem} owns the shared `Hovered` / `Pressed` state.\n * - Hand/controller far rays are disabled while gaze is available. Gaze is\n *   optionally suppressed when a near touch/grab pointer is active, so direct\n *   manipulation wins without an incidental far-ray hit stealing focus.\n *\n * @category Input\n */\nexport class GazeSystem extends createSystem(\n  {},\n  {\n    /**\n     * If true, gaze is suppressed whenever a near touch/grab pointer is in\n     * HOVER or SELECT. Set false to allow gaze to remain active concurrently.\n     * @default true\n     */\n    suppressWhenDirectPointerActive: { type: Types.Boolean, default: true },\n    /**\n     * 1€ filter min cutoff (lower = smoother, higher = more responsive).\n     * @default 1.5\n     */\n    filterMinCutoff: { type: Types.Float32, default: 1.5 },\n    /**\n     * 1€ filter beta (higher = less smoothing during fast saccades).\n     * @default 0.05\n     */\n    filterBeta: { type: Types.Float32, default: 0.05 },\n    /**\n     * Dwell window in seconds for consensus voting. `0` disables consensus.\n     * @default 0.15\n     */\n    dwellWindowSeconds: { type: Types.Float32, default: 0.15 },\n    /**\n     * Half-angle of the gaze selection cone, in degrees. Widening it makes\n     * small targets easier to acquire at the cost of more ambiguity between\n     * neighbours.\n     * @default 5\n     */\n    coneAngle: { type: Types.Float32, default: 5 },\n    /** Maximum gaze cone/raycast distance in meters. @default 30 */\n    maxRayLength: { type: Types.Float32, default: 30 },\n    /**\n     * On select commit, treat the pinching hand's ray space as the pointer\n     * origin instead of the eyes, so a gaze-initiated drag tracks the hand.\n     * @default true\n     */\n    pointerTransformFollowsHand: { type: Types.Boolean, default: true },\n    /**\n     * Emit `[iwsdk][gaze]` console diagnostics explaining why gaze is or isn't\n     * tracked, and whether the runtime's gaze ray actually separates from the\n     * head ray. Each message fires at most once per state change.\n     * @default true\n     */\n    logDiagnostics: { type: Types.Boolean, default: true },\n    /** Show a developer-only gaze hit reticle. @default false */\n    showDebugReticle: { type: Types.Boolean, default: false },\n    /** Keep gaze mode active briefly after tracking becomes invalid. @default 5 */\n    trackingLossGraceSeconds: { type: Types.Float32, default: 5 },\n  },\n) {\n  /** One-shot latch for {@link GazeSystem.warnMissingFrame}. */\n  private warnedMissingFrame = false;\n\n  init(): void {\n    // Registering this system is the opt-in: until now the pointer existed but\n    // never sampled a pose or cast a cone.\n    this.input.xr.gazeEnabled = true;\n    this.cleanupFuncs.push(() => {\n      this.input.xr.gazeEnabled = false;\n    });\n\n    this.applyGazeConfig();\n    // Re-push on every config change so the editor's live tweaks land without\n    // rebuilding the pointer.\n    for (const key of [\n      'suppressWhenDirectPointerActive',\n      'filterMinCutoff',\n      'filterBeta',\n      'dwellWindowSeconds',\n      'coneAngle',\n      'maxRayLength',\n      'pointerTransformFollowsHand',\n      'logDiagnostics',\n      'showDebugReticle',\n      'trackingLossGraceSeconds',\n    ] as const) {\n      this.cleanupFuncs.push(\n        this.config[key].subscribe(() => this.applyGazeConfig()),\n      );\n    }\n  }\n\n  /**\n   * Push system config onto the shared pointer and its candidate provider.\n   *\n   * Cone geometry and dwell live on the provider rather than the pointer, and\n   * only the default {@link GazeConecaster} understands them — a custom\n   * provider installed via `setCandidateProvider` keeps its own tuning.\n   */\n  private applyGazeConfig(): void {\n    const pointer = this.input.xr.gazePointer;\n    pointer.suppressWhenDirectPointerActive =\n      this.config.suppressWhenDirectPointerActive.peek();\n    pointer.pointerTransformFollowsHand =\n      this.config.pointerTransformFollowsHand.peek();\n    pointer.diagnosticsEnabled = this.config.logDiagnostics.peek();\n    pointer.showDebugReticle = this.config.showDebugReticle.peek();\n    pointer.trackingLossGraceSeconds =\n      this.config.trackingLossGraceSeconds.peek();\n    pointer.filter.minCutoff = this.config.filterMinCutoff.peek();\n    pointer.filter.beta = this.config.filterBeta.peek();\n\n    const provider = pointer.provider;\n    if (provider instanceof GazeConecaster) {\n      // The conecaster works in radians; the config is in degrees.\n      provider.coneAngle = (this.config.coneAngle.peek() * Math.PI) / 180;\n      provider.coneLength = this.config.maxRayLength.peek();\n      provider.dwellWindowSeconds = this.config.dwellWindowSeconds.peek();\n    }\n  }\n\n  update(): void {\n    const session = this.xrManager.getSession();\n    if (!session) {\n      this.warnedMissingFrame = false;\n      return;\n    }\n    if (!this.xrManager.getFrame() || !this.xrManager.getReferenceSpace()) {\n      this.warnMissingFrame();\n    }\n  }\n\n  /**\n   * There's a session but no frame or reference space, so the gaze pose can't\n   * be sampled at all this frame. Normally a one-frame startup blip; if it\n   * persists, gaze is unavailable and the developer should know.\n   */\n  private warnMissingFrame(): void {\n    if (this.warnedMissingFrame || !this.config.logDiagnostics.peek()) {\n      return;\n    }\n    this.warnedMissingFrame = true;\n    console.warn(\n      '[iwsdk][gaze] in an XR session but the renderer has no XRFrame or ' +\n        'reference space yet, so XR input cannot be sampled until this resolves.',\n    );\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/gaze/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export * from './gaze-system.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/gaze/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/gaze/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,kBAAkB,CAAC"}

package/dist/grab/grab-helpers.d.ts

@@ -8,8 +8,8 @@ import { HandleStore } from '@pmndrs/handle';
 /**
  * Pure helpers backing {@link GrabSystem.forceRelease} and
  * {@link GrabSystem.getHolderHand}. Kept side-effect-free and dependency-light
- * so they can be unit-tested without spinning up the full ECS / xr-input
- * import chain.
+ * so they can be unit-tested without spinning up the full ECS / xr-input import
+ * chain.
  *
  * Not part of the public package API surface — `grab-system.ts` is the only
  * intended caller.
@@ -31,9 +31,10 @@ export declare function cancelGrabHandle(handle: HandleStore<unknown> | undefine
  * object). Passing both keeps `getHolderHand` correct across both grab
  * styles without leaking pointer-kind selection into callers.
  *
- * Returns `'left'` / `'right'` for single-hand grabs, `'left'` for two-hand
- * grabs (deterministic), and `null` when the entity has no active grabs or
- * none of the candidate IDs match.
+ * A capture from the gaze ray is attributed to the hand that initiated its
+ * current select. Returns `'left'` / `'right'` for single-hand grabs, `'left'`
+ * for two-hand grabs (deterministic), and `null` when the entity has no active
+ * grabs or none of the candidate IDs match.
  */
-export declare function findHolderHand(handle: HandleStore<unknown> | undefined, leftPointerIds: readonly number[], rightPointerIds: readonly number[]): 'left' | 'right' | null;
+export declare function findHolderHand(handle: HandleStore<unknown> | undefined, leftPointerIds: readonly number[], rightPointerIds: readonly number[], gazePointerId?: number, gazeHand?: 'left' | 'right' | null): 'left' | 'right' | null;
 //# sourceMappingURL=grab-helpers.d.ts.map

package/dist/grab/grab-helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"grab-helpers.d.ts","sourceRoot":"","sources":["../../src/grab/grab-helpers.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE7C;;;;;;;;GAQG;AAEH;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,GAAG,SAAS,GACvC,IAAI,CAON;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,GAAG,SAAS,EACxC,cAAc,EAAE,SAAS,MAAM,EAAE,EACjC,eAAe,EAAE,SAAS,MAAM,EAAE,GACjC,MAAM,GAAG,OAAO,GAAG,IAAI,CAWzB"}
+{"version":3,"file":"grab-helpers.d.ts","sourceRoot":"","sources":["../../src/grab/grab-helpers.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE7C;;;;;;;;GAQG;AAEH;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,GAAG,SAAS,GACvC,IAAI,CAON;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,GAAG,SAAS,EACxC,cAAc,EAAE,SAAS,MAAM,EAAE,EACjC,eAAe,EAAE,SAAS,MAAM,EAAE,EAClC,aAAa,CAAC,EAAE,MAAM,EACtB,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,GACjC,MAAM,GAAG,OAAO,GAAG,IAAI,CAezB"}

package/dist/grab/grab-helpers.js

@@ -7,8 +7,8 @@
 /**
  * Pure helpers backing {@link GrabSystem.forceRelease} and
  * {@link GrabSystem.getHolderHand}. Kept side-effect-free and dependency-light
- * so they can be unit-tested without spinning up the full ECS / xr-input
- * import chain.
+ * so they can be unit-tested without spinning up the full ECS / xr-input import
+ * chain.
  *
  * Not part of the public package API surface — `grab-system.ts` is the only
  * intended caller.
@@ -38,11 +38,12 @@ function cancelGrabHandle(handle) {
  * object). Passing both keeps `getHolderHand` correct across both grab
  * styles without leaking pointer-kind selection into callers.
  *
- * Returns `'left'` / `'right'` for single-hand grabs, `'left'` for two-hand
- * grabs (deterministic), and `null` when the entity has no active grabs or
- * none of the candidate IDs match.
+ * A capture from the gaze ray is attributed to the hand that initiated its
+ * current select. Returns `'left'` / `'right'` for single-hand grabs, `'left'`
+ * for two-hand grabs (deterministic), and `null` when the entity has no active
+ * grabs or none of the candidate IDs match.
  */
-function findHolderHand(handle, leftPointerIds, rightPointerIds) {
+function findHolderHand(handle, leftPointerIds, rightPointerIds, gazePointerId, gazeHand) {
     if (!handle || handle.inputState.size === 0) {
         return null;
     }
@@ -52,7 +53,11 @@ function findHolderHand(handle, leftPointerIds, rightPointerIds) {
     if (rightPointerIds.some((id) => handle.inputState.has(id))) {
         return 'right';
     }
-    return null;
+    return gazeHand != null && gazePointerId != null
+        ? handle.inputState.has(gazePointerId)
+            ? gazeHand
+            : null
+        : null;
 }
 
 export { cancelGrabHandle, findHolderHand };

package/dist/grab/grab-helpers.js.map

@@ -1 +1 @@
-{"version":3,"file":"grab-helpers.js","sources":["../../src/grab/grab-helpers.ts"],"sourcesContent":["/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nimport { HandleStore } from '@pmndrs/handle';\n\n/**\n * Pure helpers backing {@link GrabSystem.forceRelease} and\n * {@link GrabSystem.getHolderHand}. Kept side-effect-free and dependency-light\n * so they can be unit-tested without spinning up the full ECS / xr-input\n * import chain.\n *\n * Not part of the public package API surface — `grab-system.ts` is the only\n * intended caller.\n */\n\n/**\n * Cancel every active pointer on a grab `handle`. Safe to call when `handle`\n * is `undefined`, when the entity is not currently held, or when the\n * underlying `cancel()` throws (errors are swallowed to match the cleanup\n * semantics already used inside `GrabSystem` on Handle-component disqualify).\n */\nexport function cancelGrabHandle(\n  handle: HandleStore<unknown> | undefined,\n): void {\n  if (!handle) {\n    return;\n  }\n  try {\n    handle.cancel();\n  } catch {}\n}\n\n/**\n * Determine which controller is currently holding the entity backing\n * `handle`, given the candidate pointer IDs per hand.\n *\n * Each hand contributes the IDs of every pointer kind that can capture a\n * grab handle today — near grabs use the `grab` sub-pointer, distance grabs\n * use the `ray` sub-pointer (per `pointerEventsType` on the handle's\n * object). Passing both keeps `getHolderHand` correct across both grab\n * styles without leaking pointer-kind selection into callers.\n *\n * Returns `'left'` / `'right'` for single-hand grabs, `'left'` for two-hand\n * grabs (deterministic), and `null` when the entity has no active grabs or\n * none of the candidate IDs match.\n */\nexport function findHolderHand(\n  handle: HandleStore<unknown> | undefined,\n  leftPointerIds: readonly number[],\n  rightPointerIds: readonly number[],\n): 'left' | 'right' | null {\n  if (!handle || handle.inputState.size === 0) {\n    return null;\n  }\n  if (leftPointerIds.some((id) => handle.inputState.has(id))) {\n    return 'left';\n  }\n  if (rightPointerIds.some((id) => handle.inputState.has(id))) {\n    return 'right';\n  }\n  return null;\n}\n"],"names":[],"mappings":"AAAA;;;;;AAKG;AAIH;;;;;;;;AAQG;AAEH;;;;;AAKG;AACG,SAAU,gBAAgB,CAC9B,MAAwC,EAAA;IAExC,IAAI,CAAC,MAAM,EAAE;QACX;IACF;AACA,IAAA,IAAI;QACF,MAAM,CAAC,MAAM,EAAE;IACjB;IAAE,OAAA,EAAA,EAAM,EAAC;AACX;AAEA;;;;;;;;;;;;;AAaG;SACa,cAAc,CAC5B,MAAwC,EACxC,cAAiC,EACjC,eAAkC,EAAA;IAElC,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,UAAU,CAAC,IAAI,KAAK,CAAC,EAAE;AAC3C,QAAA,OAAO,IAAI;IACb;AACA,IAAA,IAAI,cAAc,CAAC,IAAI,CAAC,CAAC,EAAE,KAAK,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,EAAE;AAC1D,QAAA,OAAO,MAAM;IACf;AACA,IAAA,IAAI,eAAe,CAAC,IAAI,CAAC,CAAC,EAAE,KAAK,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,EAAE;AAC3D,QAAA,OAAO,OAAO;IAChB;AACA,IAAA,OAAO,IAAI;AACb;;;;"}
+{"version":3,"file":"grab-helpers.js","sources":["../../src/grab/grab-helpers.ts"],"sourcesContent":["/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nimport { HandleStore } from '@pmndrs/handle';\n\n/**\n * Pure helpers backing {@link GrabSystem.forceRelease} and\n * {@link GrabSystem.getHolderHand}. Kept side-effect-free and dependency-light\n * so they can be unit-tested without spinning up the full ECS / xr-input import\n * chain.\n *\n * Not part of the public package API surface — `grab-system.ts` is the only\n * intended caller.\n */\n\n/**\n * Cancel every active pointer on a grab `handle`. Safe to call when `handle`\n * is `undefined`, when the entity is not currently held, or when the\n * underlying `cancel()` throws (errors are swallowed to match the cleanup\n * semantics already used inside `GrabSystem` on Handle-component disqualify).\n */\nexport function cancelGrabHandle(\n  handle: HandleStore<unknown> | undefined,\n): void {\n  if (!handle) {\n    return;\n  }\n  try {\n    handle.cancel();\n  } catch {}\n}\n\n/**\n * Determine which controller is currently holding the entity backing\n * `handle`, given the candidate pointer IDs per hand.\n *\n * Each hand contributes the IDs of every pointer kind that can capture a\n * grab handle today — near grabs use the `grab` sub-pointer, distance grabs\n * use the `ray` sub-pointer (per `pointerEventsType` on the handle's\n * object). Passing both keeps `getHolderHand` correct across both grab\n * styles without leaking pointer-kind selection into callers.\n *\n * A capture from the gaze ray is attributed to the hand that initiated its\n * current select. Returns `'left'` / `'right'` for single-hand grabs, `'left'`\n * for two-hand grabs (deterministic), and `null` when the entity has no active\n * grabs or none of the candidate IDs match.\n */\nexport function findHolderHand(\n  handle: HandleStore<unknown> | undefined,\n  leftPointerIds: readonly number[],\n  rightPointerIds: readonly number[],\n  gazePointerId?: number,\n  gazeHand?: 'left' | 'right' | null,\n): 'left' | 'right' | null {\n  if (!handle || handle.inputState.size === 0) {\n    return null;\n  }\n  if (leftPointerIds.some((id) => handle.inputState.has(id))) {\n    return 'left';\n  }\n  if (rightPointerIds.some((id) => handle.inputState.has(id))) {\n    return 'right';\n  }\n  return gazeHand != null && gazePointerId != null\n    ? handle.inputState.has(gazePointerId)\n      ? gazeHand\n      : null\n    : null;\n}\n"],"names":[],"mappings":"AAAA;;;;;AAKG;AAIH;;;;;;;;AAQG;AAEH;;;;;AAKG;AACG,SAAU,gBAAgB,CAC9B,MAAwC,EAAA;IAExC,IAAI,CAAC,MAAM,EAAE;QACX;IACF;AACA,IAAA,IAAI;QACF,MAAM,CAAC,MAAM,EAAE;IACjB;IAAE,OAAA,EAAA,EAAM,EAAC;AACX;AAEA;;;;;;;;;;;;;;AAcG;AACG,SAAU,cAAc,CAC5B,MAAwC,EACxC,cAAiC,EACjC,eAAkC,EAClC,aAAsB,EACtB,QAAkC,EAAA;IAElC,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,UAAU,CAAC,IAAI,KAAK,CAAC,EAAE;AAC3C,QAAA,OAAO,IAAI;IACb;AACA,IAAA,IAAI,cAAc,CAAC,IAAI,CAAC,CAAC,EAAE,KAAK,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,EAAE;AAC1D,QAAA,OAAO,MAAM;IACf;AACA,IAAA,IAAI,eAAe,CAAC,IAAI,CAAC,CAAC,EAAE,KAAK,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,EAAE;AAC3D,QAAA,OAAO,OAAO;IAChB;AACA,IAAA,OAAO,QAAQ,IAAI,IAAI,IAAI,aAAa,IAAI;UACxC,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,aAAa;AACnC,cAAE;AACF,cAAE;UACF,IAAI;AACV;;;;"}

package/dist/grab/grab-system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"grab-system.d.ts","sourceRoot":"","sources":["../../src/grab/grab-system.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAC5C,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;;IAmEtC;;;;OAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAJH;;;;OAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAtDP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,qBAAa,UAAW,SAAQ,eAuB/B;IACC,IAAI;IAmDJ,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IA4CzC;;;;;;;;;;;;;;;;;OAiBG;IACH,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAMlC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI;IActD,OAAO,CAAC,uBAAuB;IAqC/B,OAAO,CAAC,wBAAwB;IAoDhC,OAAO,CAAC,wBAAwB;CA0FjC"}
+{"version":3,"file":"grab-system.d.ts","sourceRoot":"","sources":["../../src/grab/grab-system.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAC5C,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;;IAmEtC;;;;OAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAJH;;;;OAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAtDP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,qBAAa,UAAW,SAAQ,eAuB/B;IACC,IAAI;IAmDJ,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IA4CzC;;;;;;;;;;;;;;;;;OAiBG;IACH,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAMlC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI;IAiBtD,OAAO,CAAC,uBAAuB;IAqC/B,OAAO,CAAC,wBAAwB;IAoDhC,OAAO,CAAC,wBAAwB;CA0FjC"}

package/dist/grab/grab-system.js

@@ -210,12 +210,13 @@ class GrabSystem extends createSystem({
     getHolderHand(entity) {
         const left = this.input.xr.multiPointers.left;
         const right = this.input.xr.multiPointers.right;
+        const gaze = this.input.xr.gazePointer;
         return findHolderHand(Handle.data.instance[entity.index], 
         // Near grabs capture via the `grab` sub-pointer; distance grabs capture
         // via `ray` (see `initializeDistanceHandle` setting
         // `pointerEventsType = { deny: 'grab' }`). Check both per hand so
         // distance-held entities don't silently report `null`.
-        [left.getPointer('grab').id, left.getPointer('ray').id], [right.getPointer('grab').id, right.getPointer('ray').id]);
+        [left.getPointer('grab').id, left.getPointer('ray').id], [right.getPointer('grab').id, right.getPointer('ray').id], gaze.pointer.id, gaze.getHeldByHand());
     }
     initializeOneHandHandle(entity) {
         if (entity.hasComponent(Handle)) {