phoria2 1.0.0 → 1.2.0

package/dist/types/Raycaster.d.ts

@@ -6,6 +6,16 @@ export type Cut = {
     plane: Float32Array;
     cap: boolean;
 };
+export type Solid = {
+    node: any;
+    world: Float32Array;
+    instance: number | null;
+    cut: Cut | null;
+    x: number;
+    y: number;
+    z: number;
+    radius: number;
+};
 export type Hit = {
     /**
      * what was hit

package/dist/types/View.d.ts

@@ -16,6 +16,7 @@ import type { ToneMapping, BloomOptions } from './webgl/WebGLRenderer.js';
 import type { CameraOptions } from './scene/cameras.js';
 import type { ColorInput, Vec3Input } from './types.js';
 import type { Node } from './scene/Node.js';
+import type { KeyboardOptions } from './keyboard.js';
 export type RenderMode = 'auto' | 'always' | 'manual';
 export type ViewOptions = {
     /**
@@ -73,6 +74,11 @@ export type ViewOptions = {
      * (default true)
      */
     antialias?: boolean;
+    /**
+     * soft-edged outlines with round corners (default: as antialias); change it
+     * any time with view.renderer.outlineAntialias
+     */
+    outlineAntialias?: boolean;
     /**
      * which WebGL context draws it: 'own' gives the canvas one of
      * its own; 'shared' draws with the page's one shared context and copies the picture over, so a page can hold
@@ -101,6 +107,24 @@ export type ViewOptions = {
      * longest frame step in seconds, so a background tab doesn't jump (default 0.1)
      */
     maxDelta?: number;
+    /**
+     * cut motion short, for people it makes unwell: frame() jumps rather
+     * than glides, auto-rotation holds, and charts change at once with their flows still. Default 'auto': as the
+     * system's setting (prefers-reduced-motion), followed as it changes
+     */
+    reducedMotion?: 'auto' | boolean;
+    /**
+     * use without a pointer: the canvas joins the page's tab order, and
+     * the arrow keys step through what can be hovered or clicked - each with the hover tint, the tooltip and hover
+     * handlers - with Enter or Space to click and Escape to leave. A screen reader hears each one. { label: (hit) =>
+     * text } says what it hears (default: the tooltip's text, the data, or the name). Default false
+     */
+    keyboard?: boolean | KeyboardOptions;
+    /**
+     * what the view shows, for screen readers: the canvas's label. With keyboard
+     * on and no description, one is made from the scene (charts describe themselves)
+     */
+    description?: string | null;
 };
 export type ViewEvent = 'click' | 'hover';
 export type ViewHandler = (hit: Hit | null, event: PointerEvent | MouseEvent | null) => void;
@@ -163,6 +187,22 @@ export declare class View {
     get highlight(): Color | null;
     /** @param {ColorInput | null} v */
     set highlight(v: ColorInput | null);
+    /**
+     * Is motion cut short - glides, auto-rotation, chart transitions? Set true or false, or 'auto' (the
+     * default) to follow the system's setting. Read it for motion of your own, such as a timeline.
+     * @returns {boolean}
+     */
+    get reducedMotion(): boolean;
+    /** @param {'auto' | boolean} v */
+    set reducedMotion(v: 'auto' | boolean);
+    /**
+     * What the view shows, for screen readers - the canvas's label - or null. With keyboard on and no
+     * description, one is made from the scene.
+     * @returns {string | null}
+     */
+    get description(): string | null;
+    /** @param {string | null} v */
+    set description(v: string | null);
     /** Canvas width in CSS pixels. */
     get width(): number;
     /** Canvas height in CSS pixels. */
@@ -215,7 +255,8 @@ export declare class View {
      * @param {Node | Box3} [target] (default the scene)
      * @param {{ padding?: number, direction?: CameraPreset | Vec3Input, duration?: number }} [options] padding is
      *   the margin around it, as a fraction of its size: 0 is a tight fit, 0.2 (the default) leaves a fifth.
-     *   duration is in seconds (default 0: straight there); a press or the wheel stops the glide
+     *   duration is in seconds (default 0: straight there); a press or the wheel stops the glide, and with
+     *   reducedMotion it goes straight there
      * @returns {this}
      */
     frame(target?: Node | Box3, { padding, direction: towards, duration }?: {
@@ -223,6 +264,28 @@ export declare class View {
         direction?: CameraPreset | Vec3Input;
         duration?: number;
     }): this;
+    /**
+     * Where frame() would put the camera, without moving it: its position, target and - for an
+     * orthographic camera - height, or null when there is nothing to frame. For a camera of your own
+     * that eases after something moving rather than jumping each frame:
+     *
+     *     const aim = view.framing(debris)
+     *     if (aim) {
+     *       view.camera.position.lerp(aim.position, 0.1)
+     *       view.camera.target.lerp(aim.target, 0.1)
+     *     }
+     * @param {Node | Box3} [target] (default the scene)
+     * @param {{ padding?: number, direction?: CameraPreset | Vec3Input }} [options] as frame()
+     * @returns {{ position: Vec3, target: Vec3, height?: number } | null}
+     */
+    framing(target?: Node | Box3, { padding, direction }?: {
+        padding?: number;
+        direction?: CameraPreset | Vec3Input;
+    }): {
+        position: Vec3;
+        target: Vec3;
+        height?: number;
+    } | null;
     /**
      * The nearest hit under a canvas position - CSS pixels from the canvas's top left, or a pointer
      * event. Found on the GPU from the last frame drawn (one pass, however many instances), then made

package/dist/types/charts/Chart.d.ts

@@ -45,6 +45,13 @@ export declare class Chart extends Group {
     filter(fn: ((row: any) => boolean) | null): this;
     /** One line about this chart, for view.explain(). */
     explain(): string;
+    /**
+     * One sentence about this chart for screen readers - the spec's description, or its title and what
+     * it shows: "Sales by month: bar chart of 12 rows by Month, Sales". A View with keyboard: true labels
+     * its canvas with this.
+     * @returns {string}
+     */
+    summary(): string;
     toJSON(): Record<string, unknown>;
     /** A new chart from the same spec and transform. @returns {any} */
     clone(): any;

package/dist/types/explain.d.ts

@@ -36,6 +36,9 @@ export type ExplainInfo = {
         click: number;
         tooltip: boolean;
         highlight: boolean;
+        keyboard?: boolean;
+        reducedMotion?: boolean;
+        description?: string | null;
     };
     /**
      * lines from nodes that describe themselves, such as charts

package/dist/types/frame.d.ts

@@ -146,6 +146,11 @@ export type FrameLabel = {
      * in front of the camera and inside the view
      */
     visible: boolean;
+    /**
+     * how far zoomed in at the point: half the view's height, in world units, is 1 / scale -
+     * the layer turns it into pixels to one world unit, for minScale
+     */
+    scale: number;
 };
 export type ShadowFrame = {
     light: FrameLight;
@@ -353,6 +358,8 @@ export type FrameDescription = {
  * @property {[number, number]} ndc [x, y] in -1..1
  * @property {number} depth
  * @property {boolean} visible in front of the camera and inside the view
+ * @property {number} scale how far zoomed in at the point: half the view's height, in world units, is 1 / scale -
+ *   the layer turns it into pixels to one world unit, for minScale
  */
 /**
  * The shadow-casting directional light's view of the scene: what to draw into its depth map.

package/dist/types/geometry/Geometry.d.ts

@@ -12,6 +12,11 @@ export type GeometryOptions = {
      * uv per vertex - glTF convention, (0, 0) is the image's top left
      */
     uvs?: ArrayLike<number>;
+    /**
+     * a second uv per vertex, for maps that need every surface on its own
+     * patch of texture - baked occlusion and light maps (a texture's uvSet: 1 reads it)
+     */
+    uvs2?: ArrayLike<number>;
     /**
      * rgb per vertex, sRGB 0-1 like every colour input
      */
@@ -31,6 +36,7 @@ export declare class Geometry {
     static OPTIONS: string[];
     /** @type {Float32Array} */ positions: Float32Array;
     /** @type {Float32Array | null} */ uvs: Float32Array | null;
+    /** A second UV set, for baked occlusion and light maps. @type {Float32Array | null} */ uvs2: Float32Array | null;
     /** @type {Float32Array | null} */ colors: Float32Array | null;
     /** @type {Uint16Array | Uint32Array | null} */ indices: Uint16Array | Uint32Array | null;
     /**
@@ -50,7 +56,9 @@ export declare class Geometry {
     constructor(options: GeometryOptions);
     /**
      * xyz per vertex. Computed (smooth) from the triangles on first read when not supplied, so
-     * points and lines - whose geometry has no triangles - never pay for them.
+     * points and lines - whose geometry has no triangles - never pay for them - and computed again after
+     * needsUpdate(), so they follow positions edited in place. Normals that were supplied, assigned or
+     * made by calling computeNormals() are kept as they are.
      * @type {Float32Array}
      */
     get normals(): Float32Array;
@@ -71,7 +79,11 @@ export declare class Geometry {
     get drawnVertices(): number;
     /** Local space bounds, cached until needsUpdate(). @returns {Box3} */
     get bounds(): Box3;
-    /** Call after editing the arrays in place. It is no longer what its generator made, so toJSON() saves the arrays. @returns {this} */
+    /**
+     * Call after editing the arrays in place. It is no longer what its generator made, so toJSON() saves
+     * the arrays; normals that were worked out on first read are worked out again on the next.
+     * @returns {this}
+     */
     needsUpdate(): this;
     /**
      * Compute vertex normals from the triangles. Smooth normals average the faces sharing each vertex;

package/dist/types/keyboard.d.ts

@@ -0,0 +1,48 @@
+import type { Hit } from './Raycaster.js';
+import type { TooltipContent } from './tooltip.js';
+import type { Node } from './scene/Node.js';
+import type { View } from './View.js';
+export type KeyboardOptions = {
+    /**
+     * what a screen reader says for each thing stepped to (default: the
+     * tooltip's text, then its data, then the node's name)
+     */
+    label?: (hit: Hit) => string;
+};
+export type KeyboardHooks = {
+    /**
+     * show this as hovered, or nothing
+     */
+    focus: (hit: Hit | null) => void;
+    /**
+     * click it
+     */
+    press: (hit: Hit) => void;
+    /**
+     * the tooltip's content for it, if there is a tooltip
+     */
+    tooltip: (hit: Hit) => TooltipContent;
+    /**
+     * does the View itself answer hovers or clicks (a tooltip, handlers)?
+     */
+    viewWide: () => boolean;
+};
+export type Item = {
+    node: Node;
+    index: number | null;
+    whole: Node | null;
+};
+export declare class Keyboard {
+    #private;
+    /** @param {View} view @param {KeyboardHooks} hooks @param {KeyboardOptions} options */
+    constructor(view: View, hooks: KeyboardHooks, options: KeyboardOptions);
+    /**
+     * The canvas's label for screen readers: the View's description, or - when it has none - one made
+     * from the scene: what its charts show, and how many things there are to step through.
+     * @param {string | null} text
+     */
+    setDescription(text: string | null): void;
+    /** Step off whatever was stepped to: the pointer has taken over, or focus has gone. */
+    clear(): void;
+    dispose(): void;
+}

package/dist/types/labels.d.ts

@@ -18,6 +18,10 @@ export type LabelStats = {
      * behind the camera or outside the view
      */
     offscreen: number;
+    /**
+     * hidden because the view isn't zoomed in to their minScale
+     */
+    zoomedOut: number;
 };
 export type Entry = {
     el: HTMLDivElement;

package/dist/types/material/Material.d.ts

@@ -76,6 +76,20 @@ export type MaterialOptions = {
      * multiplies the emissive colour
      */
     emissiveMap?: MapInput | null;
+    /**
+     * light baked into a texture, added as light from all round - usually on
+     * the second UV set (uvSet: 1)
+     */
+    lightMap?: MapInput | null;
+    /**
+     * (default 1)
+     */
+    lightMapIntensity?: number;
+    /**
+     * this material's share of the environment's light and reflections:
+     * lower for a matte floor in a shiny showroom, higher to make one thing catch the light (default 1)
+     */
+    environmentIntensity?: number;
     /**
      * glow colour (default black)
      */
@@ -84,6 +98,74 @@ export type MaterialOptions = {
      * (default 1)
      */
     emissiveIntensity?: number;
+    /**
+     * 0-1: how much light passes through, as through glass (default 0). Unlike
+     * opacity, which fades the whole surface, glass keeps its reflections, and shows less of what is behind it
+     * towards its edges. Its colour shows in proportion to 1 - transmission
+     */
+    transmission?: number;
+    /**
+     * 0-1: a clear glossy layer over the surface - car paint, lacquer, varnish (default 0)
+     */
+    clearcoat?: number;
+    /**
+     * 0-1: how glossy the coat is, 0 a mirror (default 0)
+     */
+    clearcoatRoughness?: number;
+    /**
+     * 0-1: the soft bright rim of cloth at grazing angles - velvet, felt, upholstery (default 0)
+     */
+    sheen?: number;
+    /**
+     * the sheen's colour (default white)
+     */
+    sheenColor?: ColorInput;
+    /**
+     * 0-1: a thin bright rim at 0, a broad soft glow at 1 (default 0.5)
+     */
+    sheenRoughness?: number;
+    /**
+     * index of refraction, 1 or more: how strongly a non-metal reflects - water 1.33, glass and
+     * plastic 1.5 (the default), diamond 2.4
+     */
+    ior?: number;
+    /**
+     * 0-1: scales a non-metal's reflections, 0 for none - chalk, clay (default 1)
+     */
+    specularIntensity?: number;
+    /**
+     * tints a non-metal's reflections face on (default white)
+     */
+    specularColor?: ColorInput;
+    /**
+     * 0-1: brushed metal - highlights drawn out along the brushing, which runs along
+     * the UVs' u (around the mesh where it has no UVs) (default 0)
+     */
+    anisotropy?: number;
+    /**
+     * turns the brushing from the UVs' u, in radians (default 0)
+     */
+    anisotropyRotation?: number;
+    /**
+     * 0-1: light through thin surfaces, lighting them from behind - leaves, paper,
+     * lampshades, curtains (default 0)
+     */
+    translucency?: number;
+    /**
+     * tints the light that comes through (default white)
+     */
+    translucencyColor?: ColorInput;
+    /**
+     * a picture of a lit sphere that gives the whole look - clay, wax, chrome,
+     * a painted ball - picked by which way the surface faces the camera. Lights, shadows and the environment are
+     * ignored; the colour and colour map multiply it
+     */
+    matcap?: MapInput | null;
+    /**
+     * cartoon shading in this many flat tones (2 or more) with a hard-edged highlight;
+     * 0 (the default) is smooth
+     */
+    toon?: number;
     /**
      * flat colour that ignores lights (default false)
      */
@@ -144,7 +226,17 @@ export declare class Material {
         side: string;
         wireframe: string;
         shininess: string;
+        envMapIntensity: string;
+        reflectivityScale: string;
+        matcapMap: string;
+        gradientMap: string;
+        cel: string;
+        celShading: string;
         specular: string;
+        reflectivity: string;
+        anisotropyStrength: string;
+        diffuseTransmission: string;
+        subsurface: string;
         colour: string;
         emissiveColor: string;
         alpha: string;
@@ -159,6 +251,19 @@ export declare class Material {
     /** @type {number} */ roughness: number;
     /** @type {number} */ metalness: number;
     /** @type {number} */ emissiveIntensity: number;
+    /** How much light passes through, as through glass: 0-1. @type {number} */ transmission: number;
+    /** A clear glossy layer over the surface: 0-1. @type {number} */ clearcoat: number;
+    /** How glossy the coat is, 0 a mirror. @type {number} */ clearcoatRoughness: number;
+    /** The soft bright rim of cloth: 0-1. @type {number} */ sheen: number;
+    /** A thin bright rim at 0, a broad soft glow at 1. @type {number} */ sheenRoughness: number;
+    /** Index of refraction: how strongly a non-metal reflects (1.5). @type {number} */ ior: number;
+    /** Scales a non-metal's reflections, 0-1. @type {number} */ specularIntensity: number;
+    /** Brushed metal: 0-1. @type {number} */ anisotropy: number;
+    /** Turns the brushing from the UVs' u, in radians. @type {number} */ anisotropyRotation: number;
+    /** Light through thin surfaces: 0-1. @type {number} */ translucency: number;
+    /** Cartoon shading in this many flat tones; 0 is smooth. @type {number} */ toon: number;
+    /** @type {number} */ lightMapIntensity: number;
+    /** This material's share of the environment's light and reflections. @type {number} */ environmentIntensity: number;
     /** @type {boolean} */ unlit: boolean;
     /** @type {boolean} */ flatShading: boolean;
     /** @type {boolean} */ doubleSided: boolean;
@@ -180,6 +285,18 @@ export declare class Material {
     get emissive(): Color;
     /** @param {ColorInput} v */
     set emissive(v: ColorInput);
+    /** The sheen's colour; assign any colour input. @returns {Color} */
+    get sheenColor(): Color;
+    /** @param {ColorInput} v */
+    set sheenColor(v: ColorInput);
+    /** Tints a non-metal's reflections face on; assign any colour input. @returns {Color} */
+    get specularColor(): Color;
+    /** @param {ColorInput} v */
+    set specularColor(v: ColorInput);
+    /** Tints the light that comes through a translucent surface; assign any colour input. @returns {Color} */
+    get translucencyColor(): Color;
+    /** @param {ColorInput} v */
+    set translucencyColor(v: ColorInput);
     /** @returns {Texture | null} */
     get map(): Texture | null;
     /** @param {MapInput | null} v */
@@ -208,6 +325,14 @@ export declare class Material {
     get emissiveMap(): Texture | null;
     /** @param {MapInput | null} v */
     set emissiveMap(v: MapInput | null);
+    /** Light baked into a texture. @returns {Texture | null} */
+    get lightMap(): Texture | null;
+    /** @param {MapInput | null} v */
+    set lightMap(v: MapInput | null);
+    /** A picture of a lit sphere that gives the whole look. @returns {Texture | null} */
+    get matcap(): Texture | null;
+    /** @param {MapInput | null} v */
+    set matcap(v: MapInput | null);
     /** The maps that are set, by slot. @returns {[string, Texture][]} */
     get textures(): [string, Texture][];
     /** Rendered in the transparent pass: an opacity below 1, additive or multiply blending, or set for maps with soft alpha. @returns {boolean} */

package/dist/types/material/Texture.d.ts

@@ -11,7 +11,8 @@ export type TextureOptions = {
     image?: TextureImage;
     /**
      * image to load (starts loading immediately in a browser); a .hdr file loads as
-     * linear HDR radiance, for scene.environment
+     * linear HDR radiance, for scene.environment; a video (.mp4, .webm, .ogv, .mov, .m4v) plays muted and on a
+     * loop, and texture.image is its <video> to pause, seek or unmute
      */
     url?: string;
     /**
@@ -31,12 +32,26 @@ export type TextureOptions = {
      * [u, v] (default [0, 0])
      */
     offset?: number[];
+    /**
+     * turns the image on the surface, in radians, about `center` (default 0)
+     */
+    rotation?: number;
+    /**
+     * [u, v] the point rotation turns about, in repeated UVs (default [0, 0], the
+     * corner, as glTF has it; [0.5, 0.5] for the middle of an unrepeated image)
+     */
+    center?: number[];
+    /**
+     * which UV set to read: 0 the first, 1 the second (Geometry uvs2) - baked occlusion
+     * and light maps usually come on the second (default 0)
+     */
+    uvSet?: 0 | 1;
     /**
      * (default 'linear')
      */
     filter?: 'linear' | 'nearest';
     /**
-     * (default true)
+     * (default true; false for a video, which would make them every frame)
      */
     mipmaps?: boolean;
     /**
@@ -49,7 +64,10 @@ export type TextureOptions = {
      */
     flipY?: boolean;
 };
-/** An image for a material map. Canvas and video textures: set `needsUpdate()` after drawing. */
+/**
+ * An image for a material map. A video's frames upload by themselves as it plays; after drawing on
+ * a canvas, call `needsUpdate()`.
+ */
 export declare class Texture {
     #private;
     /** The options it takes, and hints for names people reach for instead. */
@@ -59,15 +77,22 @@ export declare class Texture {
         encoding: string;
         wrapS: string;
         maxAnisotropy: string;
+        channel: string;
+        texCoord: string;
+        scale: string;
     };
-    /** @type {TextureImage | null} null until loaded */
-    image: TextureImage | null;
     /** @type {string | null} */
     url: string | null;
     /** @type {'repeat' | 'clamp' | 'mirror'} */
     wrap: 'repeat' | 'clamp' | 'mirror';
     repeat: number[];
     offset: number[];
+    /** Turns the image on the surface, in radians, about `center`. */
+    rotation: number;
+    /** [u, v] the point rotation turns about, in repeated UVs. */
+    center: number[];
+    /** Which UV set it reads: 0 the first, 1 the second (Geometry uvs2). @type {0 | 1} */
+    uvSet: 0 | 1;
     /** @type {'linear' | 'nearest'} */
     filter: 'linear' | 'nearest';
     mipmaps: boolean;
@@ -79,6 +104,13 @@ export declare class Texture {
     /** @param {TextureOptions | string} [options] options, or just a url */
     constructor(options?: TextureOptions | string);
     /** Call after redrawing a canvas or advancing a video. @returns {this} */
+    /**
+     * The pixels: null until loaded. A <video>'s frames upload by themselves while it plays.
+     * @returns {TextureImage | null}
+     */
+    get image(): TextureImage | null;
+    /** @param {TextureImage | null} v */
+    set image(v: TextureImage | null);
     /** 'srgb' for colour (decoded to linear by the GPU), 'linear' for data such as normals and roughness. Call needsUpdate() after changing it. @returns {'srgb' | 'linear'} */
     get colorSpace(): 'srgb' | 'linear';
     set colorSpace(v: 'srgb' | 'linear');

package/dist/types/scene/Node.d.ts

@@ -5,7 +5,7 @@ import { Mat4 } from '../value/Mat4.js';
 import { Quat } from '../value/Quat.js';
 import { Vec3 } from '../value/Vec3.js';
 import { Clip } from '../clip.js';
-import type { ColorInput, Vec3Input } from '../types.js';
+import type { ColorInput, QuatInput, Vec3Input } from '../types.js';
 import type { Hit } from '../Raycaster.js';
 import type { Camera } from './cameras.js';
 import type { ClipOptions } from '../clip.js';
@@ -59,9 +59,9 @@ export type NodeOptions = {
      */
     rotation?: Vec3Input | Euler;
     /**
-     * [x, y, z, w] - instead of rotation
+     * [x, y, z, w] or { x, y, z, w } - instead of rotation
      */
-    quaternion?: ArrayLike<number>;
+    quaternion?: QuatInput;
     /**
      * a number scales uniformly
      */
@@ -87,9 +87,10 @@ export type NodeOptions = {
      */
     tooltip?: ((hit: Hit) => any) | null;
     /**
-     * hover tint for this subtree, over the View's
+     * hover tint for this subtree, over the View's; false for none - a
+     * floor or wall left plain under a View that tints everything else (null: the View's)
      */
-    highlight?: ColorInput | null;
+    highlight?: ColorInput | null | false;
     /**
      * hovering any part of this subtree tints all of it, as one thing - a
      * piece of furniture, a machine - rather than just the part under the pointer (default false)
@@ -127,7 +128,7 @@ export type NodeOptions = {
      */
     clip?: ClipOptions | Clip | null;
 };
-/** @import { ColorInput, Vec3Input } from '../types.js' */
+/** @import { ColorInput, QuatInput, Vec3Input } from '../types.js' */
 /** @import { Hit } from '../Raycaster.js' */
 /** @import { Camera } from './cameras.js' */
 /** @import { ClipOptions } from '../clip.js' */
@@ -157,7 +158,7 @@ export type NodeOptions = {
  * @property {string} [name]
  * @property {Vec3Input} [position]
  * @property {Vec3Input | Euler} [rotation] Euler angles in radians, XYZ order
- * @property {ArrayLike<number>} [quaternion] [x, y, z, w] - instead of rotation
+ * @property {QuatInput} [quaternion] [x, y, z, w] or { x, y, z, w } - instead of rotation
  * @property {Vec3Input | number} [scale] a number scales uniformly
  * @property {boolean} [visible]
  * @property {boolean} [pickable] include in view.pick() (default true)
@@ -167,7 +168,8 @@ export type NodeOptions = {
  * @property {UpdateHandler | UpdateHandler[]} [onUpdate]
  * @property {((hit: Hit) => any) | null} [tooltip] tooltip for anything picked in this subtree; nearer nodes win, and
  *   all win over the View's
- * @property {ColorInput | null} [highlight] hover tint for this subtree, over the View's
+ * @property {ColorInput | null | false} [highlight] hover tint for this subtree, over the View's; false for none - a
+ *   floor or wall left plain under a View that tints everything else (null: the View's)
  * @property {boolean} [highlightWhole] hovering any part of this subtree tints all of it, as one thing - a
  *   piece of furniture, a machine - rather than just the part under the pointer (default false)
  * @property {((hit: Hit | null) => void) | null} [onHover] called as the thing under the pointer in this subtree changes
@@ -244,14 +246,17 @@ export declare class Node {
     set rotation(v: Vec3Input);
     /** Kept in sync with rotation. Assigning copies, normalised. @returns {Quat} */
     get quaternion(): Quat;
-    /** @param {ArrayLike<number>} v */
-    set quaternion(v: ArrayLike<number>);
+    /** @param {QuatInput} v */
+    set quaternion(v: QuatInput);
     /** @param {NodeOptions} [options] */
     constructor(options?: NodeOptions);
-    /** Hover tint for this subtree, over the View's; set any colour, or null. @returns {Color | null} */
-    get highlight(): Color | null;
-    /** @param {ColorInput | null} value */
-    set highlight(value: ColorInput | null);
+    /**
+     * Hover tint for this subtree, over the View's: a colour, false for none, or null to use the View's.
+     * @returns {Color | null | false}
+     */
+    get highlight(): Color | null | false;
+    /** @param {ColorInput | null | false} value */
+    set highlight(value: ColorInput | null | false);
     /**
      * The section plane cutting this subtree, or null. Set { normal, offset, cap }, a Clip or null;
      * move the cut by changing its offset or normal in place.