@origingame/engine 0.4.0 → 0.5.0

package/types/index.d.ts

@@ -153,16 +153,26 @@ export interface ColumnKinds {
   DofQuality: { readonly array: Uint32Array; readonly stride: 1; readonly value: DofQuality };
   /** A SpriteBlend field: the variant's index. */
   SpriteBlend: { readonly array: Uint32Array; readonly stride: 1; readonly value: SpriteBlend };
+  /** A SpriteFacing field: the variant's index. */
+  SpriteFacing: { readonly array: Uint32Array; readonly stride: 1; readonly value: SpriteFacing };
   /** A StripBlend field: the variant's index. */
   StripBlend: { readonly array: Uint32Array; readonly stride: 1; readonly value: StripBlend };
   /** A Palette handle field (0 is none). */
   Palette: { readonly array: Uint32Array; readonly stride: 2; readonly value: Palette };
+  /**
+   * A Look handle field (0 is none): a look og.load.look answered, kept for og.render.applyLook.
+   */
+  Look: { readonly array: Uint32Array; readonly stride: 2; readonly value: Look };
   /** A DitherPattern field: the variant's index. */
   DitherPattern: { readonly array: Uint32Array; readonly stride: 1; readonly value: DitherPattern };
   /** A StyliseSpace field: the variant's index. */
   StyliseSpace: { readonly array: Uint32Array; readonly stride: 1; readonly value: StyliseSpace };
   /** A ReflectionProbeMode field: the variant's index. */
   ReflectionProbeMode: { readonly array: Uint32Array; readonly stride: 1; readonly value: ReflectionProbeMode };
+  /**
+   * A Shader handle field (0 is none): a material shader og.load.shader answered, kept for og.render.shaderMaterial.
+   */
+  Shader: { readonly array: Uint32Array; readonly stride: 2; readonly value: Shader };
   /** A LineMode field: the variant's index. */
   LineMode: { readonly array: Uint32Array; readonly stride: 1; readonly value: LineMode };
   /** A RenderTargetFormat field: the variant's index. */
@@ -177,6 +187,14 @@ export interface ColumnKinds {
   Asset: { readonly array: Uint32Array; readonly stride: 2; readonly value: Asset };
   /** A Sound handle field. */
   Sound: { readonly array: Uint32Array; readonly stride: 2; readonly value: Sound };
+  /**
+   * A Font handle field (0 is none): a font og.load.font answered, kept for og.render.text or og.ui.configure.
+   */
+  Font: { readonly array: Uint32Array; readonly stride: 2; readonly value: Font };
+  /**
+   * A Style handle field (0 is none): a UI style og.load.style answered, kept for og.ui.configure.
+   */
+  Style: { readonly array: Uint32Array; readonly stride: 2; readonly value: Style };
   /** A SkeletonAsset handle field. */
   SkeletonAsset: { readonly array: Uint32Array; readonly stride: 2; readonly value: SkeletonAsset };
   /** A ClipAsset handle field. */
@@ -191,6 +209,12 @@ export interface ColumnKinds {
   IkSolver: { readonly array: Uint32Array; readonly stride: 1; readonly value: IkSolver };
   /** An IkSpace field: the variant's index. */
   IkSpace: { readonly array: Uint32Array; readonly stride: 1; readonly value: IkSpace };
+  /** A SpringSpace field: the variant's index. */
+  SpringSpace: { readonly array: Uint32Array; readonly stride: 1; readonly value: SpringSpace };
+  /** A SpringColliderShape field: the variant's index. */
+  SpringColliderShape: { readonly array: Uint32Array; readonly stride: 1; readonly value: SpringColliderShape };
+  /** A Rig handle field (0 is none): a humanoid map og.load.rig answered. */
+  Rig: { readonly array: Uint32Array; readonly stride: 2; readonly value: Rig };
   /** A FlipbookSheet handle field. */
   FlipbookSheet: { readonly array: Uint32Array; readonly stride: 2; readonly value: FlipbookSheet };
   /** A Rig2D handle field. */
@@ -201,6 +225,10 @@ export interface ColumnKinds {
   TilemapAsset: { readonly array: Uint32Array; readonly stride: 2; readonly value: TilemapAsset };
   /** An AudioBus field: the variant's index. */
   AudioBus: { readonly array: Uint32Array; readonly stride: 1; readonly value: AudioBus };
+  /** An AudioResampler field: the variant's index. */
+  AudioResampler: { readonly array: Uint32Array; readonly stride: 1; readonly value: AudioResampler };
+  /** A PanningModel field: the variant's index. */
+  PanningModel: { readonly array: Uint32Array; readonly stride: 1; readonly value: PanningModel };
   /** A Navigation handle field. */
   Navigation: { readonly array: Uint32Array; readonly stride: 2; readonly value: Navigation };
   /** A Behaviour handle field. */
@@ -924,7 +952,7 @@ export declare const color: ColorMath;
 // Reflection: components and resources are declared once with their field layout and metadata, and registered by name.
 // The inspector, Tune, the probe, scene text and the wiki read this one schema. Each column factory below makes one field.
 // A field holds one value, or a list of at most a fixed number of one number type or handle: `list(u32(), 8)`, `list(Asset(), 4)` (the list factory below). A list is read as a frozen copy (`push` throws) and written whole (`chain.passes = [...chain.passes, h]`); one over its capacity is refused, never truncated. A few vectors are numbered fields (`p0` to `p7`, as og.CameraRail does); a list of things with fields of their own is an entity each, with its own component, looped over by a query (a ring of skid marks, the laps of a race); a long record (a lap's taped inputs) is text in `str` fields of at most 4,096 bytes each, chunked over entities. Keep none of it in module variables: they are not world state, so a snapshot, a replay and a hot reload lose them.
-// A handle (an og.load answer, a texture, a sound, a geometry, a material, an entity) is a 64-bit number: keep it in a field of its own kind (`Asset()`, `Texture()`, `Sound()`, `Geometry()`, `Material()`, `Entity()`, the factories of the API's handle types), in a component or a resource. A `u32` field refuses one (handles pass 2^32: `4294967298 is not a u32`); an `f64` holds the number but loses its type.
+// A handle (an og.load answer, a texture, a sound, a geometry, a material, an entity) is a 64-bit number: keep it in a field of its own kind (`Asset()`, `Texture()`, `Sound()`, `Font()`, `Style()`, `Geometry()`, `Material()`, `Entity()`: every handle type of the API has its factory, named as the type), never cast to another kind, in a component or a resource. A `u32` field refuses one (handles pass 2^32: `4294967298 is not a u32`); an `f64` holds the number but loses its type.
 
 /**
  * Metadata of one field. Ranges and units are what Tune and the probe's bounds show. Nothing clamps writes: game code's writes (world.set, a resource field, a column) are stored as given, and writes from outside the game (the probe's `set`, `patch` and sweeps, Tune, a look's fields at cook) are refused outside min..max with the range named.
@@ -4387,6 +4415,23 @@ export type SpriteBlend = "alpha" | "additive";
  */
 export declare function SpriteBlend(value?: SpriteBlend, options?: FieldOptions): FieldSpec<"SpriteBlend">;
 
+/**
+ * How a world sprite turns towards the camera that draws it: a billboard (three.js Sprite). Decided as a mode of og.Sprite and SpriteDesc rather than a component of its own: a billboard is the same quad, texture, region, flash, glow, blend, layer, drop shadow and texture array layer as any sprite, drawn by the same sprite batch and shader, which only stands its corners differently. The turn is computed on the GPU from each camera's own axes (the main camera, every og.CameraView and og.Mirror, every face of a reflection probe), so it never feeds back into the simulation and a snapshot holds only the mode. The sprite turns about its anchor (a nine-slice turns as one panel), `rotation` still turns it within its own plane, and its drop shadow is cast by the quad stood upright facing the sun, so it shows the whole shape from every camera. Within its layer a faced sprite without sortY draws back to front from the camera's eye (by view depth; a probe's six faces by distance from the probe), after the layer's drop shadows and before its unfaced sprites; and it is culled by its bounds (a sphere round the anchor through the farthest corner) against the camera's view. Sprites draw over the 3D scene after its transparent meshes and particles, depth tested and not depth writing, so a billboard behind a transparent mesh still draws over it.
+ * - `"none"`: In the world's xy plane facing +z, as every sprite before billboards.
+ * - `"camera"`: In the camera's view plane: its x along the camera's right, its y along its up, as particle billboards (smoke, glints, impostors seen from any side).
+ * - `"cameraY"`: Upright, turned about the world's y axis towards the camera: its y stays +y, its x the camera's right laid level. Trees, characters and props that must stand while the camera looks down on them.
+ */
+export type SpriteFacing = "none" | "camera" | "cameraY";
+
+/**
+ * A SpriteFacing field: the variant's index.
+ *
+ * A `SpriteFacing` field: stored in a `Uint32Array` with stride 1.
+ * @param value The field's default; omitted, the column's zero value.
+ * @param options Range, unit, label, docs and the tunable flag.
+ */
+export declare function SpriteFacing(value?: SpriteFacing, options?: FieldOptions): FieldSpec<"SpriteFacing">;
+
 /**
  * How a trail, ribbon or beam is blended.
  * - `"additive"`: Added: glowing streaks, lasers, magic.
@@ -4761,6 +4806,15 @@ export type Look = number & { readonly [handleType]: "Look" };
  */
 export declare function Palette(value?: Palette, options?: FieldOptions): FieldSpec<"Palette">;
 
+/**
+ * A Look handle field (0 is none): a look og.load.look answered, kept for og.render.applyLook.
+ *
+ * A `Look` field: stored in a `Uint32Array` with stride 2.
+ * @param value The field's default; omitted, the column's zero value.
+ * @param options Range, unit, label, docs and the tunable flag.
+ */
+export declare function Look(value?: Look, options?: FieldOptions): FieldSpec<"Look">;
+
 /**
  * The threshold pattern Stylise.dither spreads the steps of posterize and palette with.
  * - `"none"`: No dither: every pixel rounds to its nearest step or colour, in flat bands.
@@ -5758,7 +5812,7 @@ export interface TextMetrics {
 }
 
 /**
- * A textured or solid quad in the world's xy plane facing +z, drawn this frame only (immediate mode, as og.render.text): submit it every tick it should show. Sprites and text are sorted by layer and drawn over the 3D scene.
+ * A textured or solid quad in the world's xy plane facing +z (or turned to the camera, `facing`), drawn this frame only (immediate mode, as og.render.text): submit it every tick it should show. Sprites and text are sorted by layer and drawn over the 3D scene.
  *
  * A desc: every field may be omitted and then takes its documented default; `{}` is valid.
  */
@@ -5894,6 +5948,12 @@ export interface SpriteDesc {
    * @default true
    */
   readonly toneMapped?: boolean;
+  /**
+   * A billboard: none keeps the quad in the world's xy plane; camera turns it into the view plane of each camera that draws it; cameraY stands it upright turned about y towards the camera (trees, characters). World sprites only (a screen sprite ignores it); see SpriteFacing for sorting, culling and its drop shadow.
+   *
+   * @default "none"
+   */
+  readonly facing?: SpriteFacing;
   /**
    * Mirror the region left to right.
    *
@@ -5941,7 +6001,7 @@ export interface SpriteDesc {
 
 
 /**
- * A sprite drawn every frame at the entity's MatrixWorld (its xy and z, its rotation about z; its scale multiplies width and height, so squash and stretch is a tween of og.Transform.scale). With an og.Flipbook on the entity, the texture (or an `array true` sheet's texture array layer), region and anchor come from the flipbook's current frame.
+ * A sprite drawn every frame at the entity's MatrixWorld (its xy and z, its rotation about z, in the xy plane or turned to the camera by `facing`; its scale multiplies width and height, so squash and stretch is a tween of og.Transform.scale). With an og.Flipbook on the entity, the texture (or an `array true` sheet's texture array layer), region and anchor come from the flipbook's current frame.
  * Sorted with the immediate sprites and text by layer, then (sortY) by y, then texture: one draw per run of one texture. Tile layers draw before the sprites of their layer.
  *
  * The value of the `Sprite` component (token `og.Sprite`).
@@ -6009,6 +6069,10 @@ export interface Sprite {
    * Within its layer, lower y draws in front: top-down characters, props and trees overlap by their feet.
    */
   sortY: boolean;
+  /**
+   * A billboard (SpriteDesc.facing): none keeps the quad in the world's xy plane; camera turns it into each camera's view plane; cameraY stands it upright turned about y towards the camera, for trees and characters in a 3D set. Its afterimages face as it does; its blob shadow stays flat.
+   */
+  facing: SpriteFacing;
   /** Mirror left to right (a character facing left). */
   flipX: boolean;
   /** Mirror top to bottom. */
@@ -6539,6 +6603,15 @@ export interface ReflectionProbe {
  */
 export type Shader = number & { readonly [handleType]: "Shader" };
 
+/**
+ * A Shader handle field (0 is none): a material shader og.load.shader answered, kept for og.render.shaderMaterial.
+ *
+ * A `Shader` field: stored in a `Uint32Array` with stride 2.
+ * @param value The field's default; omitted, the column's zero value.
+ * @param options Range, unit, label, docs and the tunable flag.
+ */
+export declare function Shader(value?: Shader, options?: FieldOptions): FieldSpec<"Shader">;
+
 
 
 
@@ -8434,6 +8507,24 @@ export declare function Asset(value?: Asset, options?: FieldOptions): FieldSpec<
  */
 export declare function Sound(value?: Sound, options?: FieldOptions): FieldSpec<"Sound">;
 
+/**
+ * A Font handle field (0 is none): a font og.load.font answered, kept for og.render.text or og.ui.configure.
+ *
+ * A `Font` field: stored in a `Uint32Array` with stride 2.
+ * @param value The field's default; omitted, the column's zero value.
+ * @param options Range, unit, label, docs and the tunable flag.
+ */
+export declare function Font(value?: Font, options?: FieldOptions): FieldSpec<"Font">;
+
+/**
+ * A Style handle field (0 is none): a UI style og.load.style answered, kept for og.ui.configure.
+ *
+ * A `Style` field: stored in a `Uint32Array` with stride 2.
+ * @param value The field's default; omitted, the column's zero value.
+ * @param options Range, unit, label, docs and the tunable flag.
+ */
+export declare function Style(value?: Style, options?: FieldOptions): FieldSpec<"Style">;
+
 /**
  * Where a load is.
  * - `"pending"`: Still loading.
@@ -8987,7 +9078,7 @@ export interface Physics {
 }
 
 /**
- * Two solid colliders started touching during the tick.
+ * Two solid colliders started touching during the tick. Read in the tick after, when og.Velocity already holds the solver's answer (the bodies parting): how hard they met is `impulse` and `relativeVelocity`, taken in the step itself.
  *
  * The payload of the `CollisionStarted` event (token `og.CollisionStarted`).
  */
@@ -8996,10 +9087,27 @@ export interface CollisionStarted {
   readonly a: Entity;
   /** The entity with the higher id. */
   readonly b: Entity;
-  /** The deepest contact point in world space (z is 0 in 2D). */
+  /**
+   * The deepest contact point in world space (z is 0 in 2D).
+   *
+   * @unit m (metres)
+   */
   readonly point: Vector3;
   /** The contact normal, from a towards b. */
   readonly normal: Vector3;
+  /**
+   * The normal impulse the solver gave the pair in the step that made the contact (every substep, every contact point), in newton-seconds: b took `impulse` along `normal`, a the same against it. Its momentum answer to the hit, at least 0; heavier and faster hits give more.
+   *
+   * @range 0..
+   * @unit newtonSecond (newton-seconds: an impulse, the momentum that changes a kilogram's velocity by one metre per second)
+   */
+  readonly impulse: number;
+  /**
+   * a's velocity relative to b at `point` as that step began, before the solver answered: each body's linear velocity plus its angular velocity crossed with the point's offset from its centre of mass (a static collider is still; z is 0 in 2D). Along `normal` it is the closing speed, positive while they approach: max(0, relativeVelocity · normal) is how hard they hit, in m/s.
+   *
+   * @unit mps (metres per second)
+   */
+  readonly relativeVelocity: Vector3;
 }
 
 /**
@@ -12158,6 +12266,364 @@ export interface IkChain {
   readonly error: number;
 }
 
+/**
+ * An aim constraint on a skeleton, applied after its clips, graph and IK chains: `joint` turns so its `axis` points at `target` and its `upAxis` leans towards `up` (three.js Object3D.lookAt: +Z at the target, +Y up). The direction is held within maxYaw and maxPitch of the animated forward; with `bones` above 1 the joint's parents share the turn. Put it on its own entity (a head, the eyes, a turret's barrel); constraints apply in query order, and og.JointLimit clamps the joints it turns.
+ *
+ * The value of the `LookAt` component (token `og.LookAt`).
+ */
+export interface LookAt {
+  /** The entity with the og.Skeleton this constraint turns. */
+  skeleton: Entity;
+  /**
+   * The joint that aims (an index into the skin's joints): the head, an eye.
+   *
+   * @range 0..
+   */
+  joint: number;
+  /**
+   * How many joints share the turn: `joint` and its parents (3 spreads a look over neck, chest and spine), each parent taking an even share and `joint` the rest.
+   *
+   * @default 1
+   * @range 1..8
+   */
+  bones: number;
+  /**
+   * The point to look at, in `space`.
+   *
+   * @unit m (metres)
+   */
+  target: Vector3;
+  /**
+   * What `target` and `up` are relative to: world (the frame the skeleton entity's og.Transform is in) or model.
+   */
+  space: IkSpace;
+  /**
+   * The joint's forward, in its own frame: the axis turned onto the target.
+   *
+   * @default { x: 0, y: 0, z: 1 }
+   */
+  axis: Vector3;
+  /**
+   * The joint's up, in its own frame: yaw turns about it, pitch towards it, and it rolls towards `up`.
+   *
+   * @default { x: 0, y: 1, z: 0 }
+   */
+  upAxis: Vector3;
+  /**
+   * The up hint, a direction in `space` the joint's `upAxis` leans to (three.js Object3D.up); the zero vector keeps the animated roll.
+   *
+   * @default { x: 0, y: 1, z: 0 }
+   */
+  up: Vector3;
+  /**
+   * The largest turn about `upAxis`, left or right of the animated forward.
+   *
+   * @default 3.1416
+   * @range 0..3.1416
+   * @unit rad (radians)
+   * @tunable
+   */
+  maxYaw: number;
+  /**
+   * The largest turn towards or away from `upAxis`, from the animated forward.
+   *
+   * @default 1.5708
+   * @range 0..1.5708
+   * @unit rad (radians)
+   * @tunable
+   */
+  maxPitch: number;
+  /**
+   * How much of the turn is applied (0 = the animated pose, 1 = aimed).
+   *
+   * @default 1
+   * @range 0..1
+   * @tunable
+   */
+  weight: number;
+  /**
+   * Written: the target lay outside maxYaw or maxPitch, so the joint aims at the nearest direction inside them.
+   *
+   * @readonly written by the engine
+   */
+  readonly clamped: boolean;
+}
+
+/**
+ * How far a joint may turn from its rest rotation when og.anim's solvers (og.IkChain, og.LookAt, og.FootLock) turn it: a swing of `axis` within a cone and a twist about it within a range. A hinge (a knee, an elbow) is `axis` along the hinge, `swing` 0 (or a little play) and the bend range as twistMin...twistMax. Put it on its own entity, one per joint; the animated pose itself is never clamped.
+ *
+ * The value of the `JointLimit` component (token `og.JointLimit`).
+ */
+export interface JointLimit {
+  /** The entity with the og.Skeleton whose joint this limits. */
+  skeleton: Entity;
+  /**
+   * The limited joint (an index into the skin's joints).
+   *
+   * @range 0..
+   */
+  joint: number;
+  /**
+   * The twist axis in the joint's rest frame: along the bone for a ball joint, along the hinge for a hinge.
+   *
+   * @default { x: 0, y: 1, z: 0 }
+   */
+  axis: Vector3;
+  /**
+   * The cone half-angle the axis may swing away from its rest direction (0 locks it: a hinge; pi is free).
+   *
+   * @default 3.1416
+   * @range 0..3.1416
+   * @unit rad (radians)
+   * @tunable
+   */
+  swing: number;
+  /**
+   * The least twist about `axis` from rest (a hinge's bend one way).
+   *
+   * @default -3.1416
+   * @range -3.1416..3.1416
+   * @unit rad (radians)
+   * @tunable
+   */
+  twistMin: number;
+  /**
+   * The most twist about `axis` from rest (a hinge's bend the other way).
+   *
+   * @default 3.1416
+   * @range -3.1416..3.1416
+   * @unit rad (radians)
+   * @tunable
+   */
+  twistMax: number;
+}
+
+/**
+ * Foot locking: while the playing clips plant `foot` (within 5 mm of its lowest in each clip, the notion retargeting uses, weighed across blends and cross-fades: planted when the planting clips hold at least half the pose), the foot stays where it touched the ground, through clip blends and root motion, its leg bent by two-bone IK and the foot keeping its animated orientation; when the clips lift it, the foot rejoins its animation over `release`. Put it on its own entity, one per foot; locks apply after root motion and before og.IkChain, in query order, and og.JointLimit clamps the leg. The lock is world state (the `og.anim` state block).
+ *
+ * The value of the `FootLock` component (token `og.FootLock`).
+ */
+export interface FootLock {
+  /** The entity with the og.Skeleton whose foot this holds. */
+  skeleton: Entity;
+  /**
+   * The foot joint (an index into the skin's joints); the two bones above it are the leg that bends.
+   *
+   * @range 0..
+   */
+  foot: number;
+  /**
+   * How much of the lock is applied (0 = the animated foot, 1 = held).
+   *
+   * @default 1
+   * @range 0..1
+   * @tunable
+   */
+  weight: number;
+  /**
+   * Seconds the foot takes to rejoin its animation once lifted (0: at once).
+   *
+   * @default 0.15
+   * @range 0..2
+   * @unit s (seconds of simulation time)
+   * @tunable
+   */
+  release: number;
+  /**
+   * Farther than this from where the animation puts the foot, the lock lets go (a leg cannot stretch).
+   *
+   * @default 0.5
+   * @range 0..
+   * @unit m (metres)
+   * @tunable
+   */
+  maxDistance: number;
+  /**
+   * Written: the playing clips plant the foot this tick.
+   *
+   * @readonly written by the engine
+   */
+  readonly planted: boolean;
+  /**
+   * Written: the foot is held at its lock this tick.
+   *
+   * @readonly written by the engine
+   */
+  readonly locked: boolean;
+}
+
+/**
+ * Where a spring bone's tails move.
+ * - `"world"`: The frame the skeleton entity's og.Transform is written in: the chain lags behind the entity's motion (walking, root motion, a jump).
+ * - `"model"`: The skeleton's model space: only the animation moves the chain (a teleport or a vehicle carrying the entity does not).
+ */
+export type SpringSpace = "world" | "model";
+
+/**
+ * A SpringSpace field: the variant's index.
+ *
+ * A `SpringSpace` field: stored in a `Uint32Array` with stride 1.
+ * @param value The field's default; omitted, the column's zero value.
+ * @param options Range, unit, label, docs and the tunable flag.
+ */
+export declare function SpringSpace(value?: SpringSpace, options?: FieldOptions): FieldSpec<"SpringSpace">;
+
+/**
+ * A spring (jiggle) bone chain, three-vrm's VRMSpringBone: `joint` and its `bones` - 1 parents swing after their parents' motion. Each joint's tail (the next joint of the chain; for the last joint its first child, or its parent bone continued at the same length) is a point pulled towards where the animated pose puts it by a damped spring (`frequency`, `damping`), under `gravity`, held at the bone's length, and the joint turns to point at it. Applied after og.IkChain and og.LookAt, top joint first; put it on its own entity (a tail, an ear, a strand of hair, a single jiggling node), one per chain. Deterministic under the fixed tick; the tails' positions and velocities are world state (the `og.anim` state block), so a restore continues a swing exactly. A changed chain (another skeleton, length or space) restarts at the animated pose.
+ *
+ * The value of the `SpringBone` component (token `og.SpringBone`).
+ */
+export interface SpringBone {
+  /** The entity with the og.Skeleton whose joints this swings. */
+  skeleton: Entity;
+  /**
+   * The chain's last joint (an index into the skin's joints): the tip of a tail, an ear.
+   *
+   * @range 0..
+   */
+  joint: number;
+  /**
+   * How many joints swing: `joint` and its parents (1 is the joint alone).
+   *
+   * @default 1
+   * @range 1..16
+   */
+  bones: number;
+  /**
+   * How fast a tail springs back to its animated place: the spring's natural frequency (0: no spring, it only hangs and swings).
+   *
+   * @default 3
+   * @range 0..30
+   * @unit hz (ticks or cycles per second)
+   * @tunable
+   */
+  frequency: number;
+  /**
+   * The damping ratio: 0 swings on, 1 settles without overshooting (critical damping).
+   *
+   * @default 0.3
+   * @range 0..2
+   * @tunable
+   */
+  damping: number;
+  /**
+   * The last joint's frequency as a multiple of `frequency`, the joints between in proportion along the chain (1: every joint alike; 0.25: the tip springs back four times slower than the top, a soft strand on a stiff root).
+   *
+   * @default 1
+   * @range 0..4
+   * @tunable
+   */
+  tipFrequency: number;
+  /**
+   * The last joint's damping ratio as a multiple of `damping`, the joints between in proportion along the chain (1: every joint alike).
+   *
+   * @default 1
+   * @range 0..4
+   * @tunable
+   */
+  tipDamping: number;
+  /**
+   * An acceleration on every tail, in `space` (three-vrm's gravityDir times gravityPower): (0, -9.8, 0) makes a chain droop.
+   *
+   * @unit mps2 (metres per second squared)
+   */
+  gravity: Vector3;
+  /**
+   * Where the tails move: world (the frame the skeleton entity's og.Transform is in, so the chain lags behind the entity's motion) or model (only the animation moves it).
+   */
+  space: SpringSpace;
+  /**
+   * How much of the swing is applied (0 = the animated pose, 1 = the spring's).
+   *
+   * @default 1
+   * @range 0..1
+   * @tunable
+   */
+  weight: number;
+  /**
+   * The tails' radius against og.SpringCollider (three-vrm's hitRadius): a tail stays this far outside every collider it meets (0: a point).
+   *
+   * @range 0..
+   * @unit m (metres)
+   * @tunable
+   */
+  radius: number;
+  /**
+   * The og.SpringCollider layers the tails are pushed out of, as bits: a collider on the same skeleton counts when its `layers` meet these.
+   *
+   * @default 4294967295
+   */
+  colliders: number;
+  /**
+   * Written: the farthest a tail is from its animated place this tick.
+   *
+   * @unit m (metres)
+   * @readonly written by the engine
+   */
+  readonly lag: number;
+}
+
+/**
+ * The shape of a spring collider.
+ * - `"sphere"`: A ball of `radius` about `offset`.
+ * - `"capsule"`: A capsule of `radius` about the segment from `offset` to `tail`.
+ */
+export type SpringColliderShape = "sphere" | "capsule";
+
+/**
+ * A SpringColliderShape field: the variant's index.
+ *
+ * A `SpringColliderShape` field: stored in a `Uint32Array` with stride 1.
+ * @param value The field's default; omitted, the column's zero value.
+ * @param options Range, unit, label, docs and the tunable flag.
+ */
+export declare function SpringColliderShape(value?: SpringColliderShape, options?: FieldOptions): FieldSpec<"SpringColliderShape">;
+
+/**
+ * A collider spring bones are kept out of, three-vrm's VRMSpringBoneCollider: a sphere or a capsule riding on a joint of a skeleton (a head, a chest, an upper arm), so hair, ears and tails do not swing through the body. Each tick, after a tail of an og.SpringBone of the same skeleton has stepped and before its joint turns, the tail is pushed out of every collider whose `layers` meet the spring's `colliders` (in query order) to `radius` plus the spring's `radius`, keeping its bone's length. Put it on its own entity, one per shape; colliders follow the pose as it is when a chain is swung, so one on a joint an earlier chain swung follows that swing.
+ *
+ * The value of the `SpringCollider` component (token `og.SpringCollider`).
+ */
+export interface SpringCollider {
+  /** The entity with the og.Skeleton whose spring bones this keeps out. */
+  skeleton: Entity;
+  /**
+   * The joint the collider rides on (an index into the skin's joints).
+   *
+   * @range 0..
+   */
+  joint: number;
+  /** A sphere about `offset`, or a capsule from `offset` to `tail`. */
+  shape: SpringColliderShape;
+  /**
+   * The sphere's centre, or the capsule's first end, in the joint's frame.
+   *
+   * @unit m (metres)
+   */
+  offset: Vector3;
+  /**
+   * The capsule's other end, in the joint's frame (a sphere ignores it).
+   *
+   * @unit m (metres)
+   */
+  tail: Vector3;
+  /**
+   * The radius, in metres of the skeleton's model space (the joint's own scale does not apply).
+   *
+   * @default 0.1
+   * @range 0..
+   * @unit m (metres)
+   * @tunable
+   */
+  radius: number;
+  /**
+   * The layers this collider is on, as bits (a spring bone's `colliders` picks them).
+   *
+   * @default 1
+   */
+  layers: number;
+}
+
 /**
  * A named marker of a clip that playback passed in the last tick (read in the tick after it fired, like every event). Cross-fades and blends fire every contributing clip's markers.
  *
@@ -12232,16 +12698,25 @@ export interface GraphDesc {
 
 
 /**
- * A humanoid map from og.load.rig (a cooked `.ogt` of `type rig`): the naming scheme a skeleton's node names follow and the standard bones it names outright.
+ * A humanoid map from og.load.rig (a cooked `.ogt` of `type rig`): the naming scheme a skeleton's node names follow, the standard bones it names outright and, with `footHeight`, how high its ankles stand above the ground.
  *
  * A generational handle: a number the engine hands out. A dead handle is an error value, never a crash.
  */
 export type Rig = number & { readonly [handleType]: "Rig" };
 
+/**
+ * A Rig handle field (0 is none): a humanoid map og.load.rig answered.
+ *
+ * A `Rig` field: stored in a `Uint32Array` with stride 2.
+ * @param value The field's default; omitted, the column's zero value.
+ * @param options Range, unit, label, docs and the tunable flag.
+ */
+export declare function Rig(value?: Rig, options?: FieldOptions): FieldSpec<"Rig">;
+
 /** One standard humanoid bone of a skeleton. */
 export interface HumanBone {
   /**
-   * The standard bone: hips, spine, chest, upperChest, neck, head, then leftShoulder, leftUpperArm, leftLowerArm, leftHand, the right arm, leftUpperLeg, leftLowerLeg, leftFoot, leftToes and the right leg.
+   * The standard bone: hips, spine, chest, upperChest, neck, head, then leftShoulder, leftUpperArm, leftLowerArm, leftHand, the right arm, leftUpperLeg, leftLowerLeg, leftFoot, leftToes and the right leg, then each hand's fingers (VRM 1.0 names): leftThumbMetacarpal, leftThumbProximal, leftThumbDistal, leftIndexProximal, leftIndexIntermediate, leftIndexDistal, the same for Middle, Ring and Little, and the right hand's.
    */
   readonly bone: string;
   /** The skeleton node that is that bone. */
@@ -12324,6 +12799,27 @@ export interface RetargetDesc {
 }
 
 
+/**
+ * A clip to play on the other side of the skeleton it was made for.
+ *
+ * A desc: every field may be omitted and then takes its documented default; `{}` is valid.
+ */
+export interface MirrorDesc {
+  /**
+   * The clip, made for `skeleton`.
+   *
+   * @default 0
+   */
+  readonly clip?: ClipAsset;
+  /**
+   * The skeleton the clip was made for (og.load.animation's `skeleton`); its left and right nodes are paired by name, the side tokens every rig naming scheme writes swapped (LeftArm and RightArm, thigh.L and thigh.R, J_Bip_L_ and J_Bip_R_, calf_l and calf_r).
+   *
+   * @default 0
+   */
+  readonly skeleton?: SkeletonAsset;
+}
+
+
 /**
  * A sprite sheet's frames and clips (a cooked `.ogt` of `type flipbook`), from og.load.flipbook.
  *
@@ -13162,6 +13658,7 @@ export interface TileCell {
 // Sound: inside the tick, the engine's og.audio system (after the game's systems and physics) turns AudioSource changes into a deterministic, time-stamped command stream; outside the tick the host's mixer renders it (an AudioWorklet on the web, the output device, a capture or a null sink natively).
 // The stream, not the PCM, is world state: snapshots, restore and the world hash cover it, and nothing a sink does reaches the world. Load sounds with og.load.sound; inserting a source plays it, setting `playing` false stops it, and a one-shot sets `playing` back to false when it ends.
 // Spatial gain and pan are computed in the tick from the source's world transform relative to the first AudioListener's (three.js convention: the listener looks down -Z, +X is right; with none, the origin looking down -Z). A source, listener or zone on a child entity is placed at its og.Transform composed down og.Parent, as og.MatrixWorld is: a sound on a child is heard where its parent carries it, a listener under a camera rig hears from the rig.
+// Propagation, all in the tick and so in the stream: a spatial source or listener that moves shifts the pitch (Doppler, from their tick velocities: AudioSource.dopplerFactor, AudioListener.dopplerFactor, Audio.speedOfSound), a source with a cone is turned down away from its +Z (coneInnerAngle, coneOuterAngle, coneOuterGain, as three.js's setDirectionalCone), and a listener whose panningModel is hrtf places sources for headphones (interaural delay and head shadow) instead of the stereo panner.
 
 /** SoundEnded.reason: a one-shot played to its end. */
 export declare const SOUND_FINISHED: 0;
@@ -13180,6 +13677,11 @@ export declare const SOUND_REPLACED: 3;
  */
 export declare const SOUND_CULLED: 4;
 
+/**
+ * SoundEnded.reason: AudioSource.retrigger started the sound again from the top; a new voice plays it.
+ */
+export declare const SOUND_RETRIGGERED: 5;
+
 /**
  * The bus a source plays on; every bus passes through master.
  * - `"master"`: The master bus: what every bus passes through.
@@ -13198,6 +13700,38 @@ export type AudioBus = "master" | "music" | "sfx" | "ui";
  */
 export declare function AudioBus(value?: AudioBus, options?: FieldOptions): FieldSpec<"AudioBus">;
 
+/**
+ * How an AudioListener places spatial sources between the ears, as Web Audio's PannerNode.panningModel.
+ * - `"equalpower"`: The stereo panner (Web Audio's equal-power law): for speakers.
+ * - `"hrtf"`: For headphones: a spherical-head model (Brown and Duda, 1998) that delays the far ear by the interaural time difference (up to 0.66 ms) and shadows its highs (up to -20 dB), so a source moves between the ears; front and back, up and down are not told apart (no pinna).
+ */
+export type PanningModel = "equalpower" | "hrtf";
+
+/**
+ * How the mixer resamples a voice whose pitch or sound rate differs from the output's.
+ * - `"linear"`: Linear interpolation: the engine's mix before round 4, cheaper, with duller highs (-3.4 dB at 15 kHz from 44.1 kHz) and images (-11.5 dB there).
+ * - `"sinc"`: A Kaiser-windowed sinc (beta 7, 16 taps, 2048 phases; widened up to 64 taps for a voice pitched up to 4x): flat to the highs, images below -70 dB.
+ */
+export type AudioResampler = "linear" | "sinc";
+
+/**
+ * An AudioResampler field: the variant's index.
+ *
+ * A `AudioResampler` field: stored in a `Uint32Array` with stride 1.
+ * @param value The field's default; omitted, the column's zero value.
+ * @param options Range, unit, label, docs and the tunable flag.
+ */
+export declare function AudioResampler(value?: AudioResampler, options?: FieldOptions): FieldSpec<"AudioResampler">;
+
+/**
+ * A PanningModel field: the variant's index.
+ *
+ * A `PanningModel` field: stored in a `Uint32Array` with stride 1.
+ * @param value The field's default; omitted, the column's zero value.
+ * @param options Range, unit, label, docs and the tunable flag.
+ */
+export declare function PanningModel(value?: PanningModel, options?: FieldOptions): FieldSpec<"PanningModel">;
+
 /**
  * A sound an entity plays. Level-triggered: while `playing` is true it plays (inserting a source plays it), setting it false stops it, and a one-shot that reaches its end sets it back to false and sends og.SoundEnded.
  * A one-shot of F frames at rate R and pitch p started in tick S ends in tick S + ceil(F * tickRate / (R * p)) - 1. A despawned entity's voice is silenced without an event.
@@ -13339,6 +13873,47 @@ export interface AudioSource {
    * @tunable
    */
   fade: number;
+  /**
+   * Doppler: how much a spatial source's and the listener's motion along the line between them shifts its pitch, from their tick velocities (world positions down og.Parent): pitch times (c - DF * vListener) / (c - DF * vSource), c being Audio.speedOfSound and DF this times AudioListener.dopplerFactor (OpenAL's model). 1 is physical, 0 is off. A jump at or past the speed of sound in a tick is a teleport and shifts nothing; DF * v is held within c/2, so the shift stays within a factor of 3.
+   *
+   * @default 1
+   * @range 0..10
+   * @tunable
+   */
+  dopplerFactor: number;
+  /**
+   * Directivity, as three.js PositionalAudio.setDirectionalCone and Web Audio's PannerNode: a spatial source plays at full volume while the listener is within this full angle about the source's +Z (its world transform's, three.js's PositionalAudio orientation); 360 with coneOuterAngle 360 is omnidirectional.
+   *
+   * @default 360
+   * @range 0..360
+   * @unit deg (degrees)
+   * @tunable
+   */
+  coneInnerAngle: number;
+  /**
+   * Past this full angle about the source's +Z it plays at coneOuterGain; between coneInnerAngle and this the gain falls linearly with the angle.
+   *
+   * @default 360
+   * @range 0..360
+   * @unit deg (degrees)
+   * @tunable
+   */
+  coneOuterAngle: number;
+  /**
+   * The gain outside coneOuterAngle.
+   *
+   * @range 0..1
+   * @tunable
+   */
+  coneOuterGain: number;
+  /**
+   * Past Audio.maxVoices it goes virtual instead of being culled: silent, its playhead running on (a one-shot still ends on its tick), and heard again from where it would be, fading in, once it stands within the cap. Without it the source is culled (SOUND_CULLED, playing false).
+   */
+  virtualize: boolean;
+  /**
+   * Set true to start the sound again from the top (its startOffset, its startAt) this tick, playing or not, without a level change on `playing`: the voice playing ends (SOUND_RETRIGGERED) and a new one starts in the same tick. The engine sets it back to false and `playing` true.
+   */
+  retrigger: boolean;
 }
 
 /**
@@ -13355,6 +13930,20 @@ export interface AudioListener {
    * @tunable
    */
   volume: number;
+  /**
+   * Scales every spatial source's Doppler shift (AudioSource.dopplerFactor); 0 turns Doppler off for this listener.
+   *
+   * @default 1
+   * @range 0..10
+   * @tunable
+   */
+  dopplerFactor: number;
+  /**
+   * How spatial sources are placed between the ears: equalpower (speakers) or hrtf (headphones). Non-spatial sources keep their pan either way; the stereo path is unchanged while it is equalpower.
+   *
+   * @default "equalpower"
+   */
+  panningModel: PanningModel;
 }
 
 /**
@@ -13443,6 +14032,21 @@ export interface Audio {
    * @readonly written by the engine
    */
   readonly outputLatency: number;
+  /**
+   * The speed of sound Doppler shifts are computed against (AudioSource.dopplerFactor).
+   *
+   * @default 343.3
+   * @range 1..10000
+   * @unit mps (metres per second)
+   * @tunable
+   */
+  speedOfSound: number;
+  /**
+   * How voices are resampled: sinc (the default) or linear, the mix before round 4, for a game that relies on its exact output. A sound at the output's rate played at pitch 1 is its own samples either way.
+   *
+   * @default "sinc"
+   */
+  resampler: AudioResampler;
 }
 
 /**
@@ -13739,7 +14343,7 @@ export interface SoundEnded {
   /** The voice id in the command stream. */
   readonly voice: number;
   /**
-   * Why: SOUND_FINISHED (0), SOUND_STOPPED (1), SOUND_REMOVED (2), SOUND_REPLACED (3) or SOUND_CULLED (4).
+   * Why: SOUND_FINISHED (0), SOUND_STOPPED (1), SOUND_REMOVED (2), SOUND_REPLACED (3), SOUND_CULLED (4) or SOUND_RETRIGGERED (5).
    */
   readonly reason: number;
 }
@@ -22270,10 +22874,10 @@ export declare namespace og {
    */
   const Beam: ComponentType<{ readonly end: FieldSpec<"Vector3">; readonly width: FieldSpec<"f32">; readonly color: FieldSpec<"Color">; readonly opacity: FieldSpec<"f32">; readonly texture: FieldSpec<"Texture">; readonly tile: FieldSpec<"f32">; readonly scroll: FieldSpec<"f32">; readonly segments: FieldSpec<"u32">; readonly jitter: FieldSpec<"f32">; readonly seed: FieldSpec<"u32">; readonly blend: FieldSpec<"StripBlend"> }, Beam>;
   /**
-   * A sprite drawn every frame at the entity's MatrixWorld (its xy and z, its rotation about z; its scale multiplies width and height, so squash and stretch is a tween of og.Transform.scale). With an og.Flipbook on the entity, the texture (or an `array true` sheet's texture array layer), region and anchor come from the flipbook's current frame.
+   * A sprite drawn every frame at the entity's MatrixWorld (its xy and z, its rotation about z, in the xy plane or turned to the camera by `facing`; its scale multiplies width and height, so squash and stretch is a tween of og.Transform.scale). With an og.Flipbook on the entity, the texture (or an `array true` sheet's texture array layer), region and anchor come from the flipbook's current frame.
    * Sorted with the immediate sprites and text by layer, then (sortY) by y, then texture: one draw per run of one texture. Tile layers draw before the sprites of their layer.
    */
-  const Sprite: ComponentType<{ readonly texture: FieldSpec<"Texture">; readonly array: FieldSpec<"TextureArray">; readonly arrayLayer: FieldSpec<"u32">; readonly width: FieldSpec<"f32">; readonly height: FieldSpec<"f32">; readonly anchor: FieldSpec<"Vector2">; readonly color: FieldSpec<"Color">; readonly opacity: FieldSpec<"f32">; readonly uvMin: FieldSpec<"Vector2">; readonly uvMax: FieldSpec<"Vector2">; readonly layer: FieldSpec<"i32">; readonly sortY: FieldSpec<"bool">; readonly flipX: FieldSpec<"bool">; readonly flipY: FieldSpec<"bool">; readonly flash: FieldSpec<"f32">; readonly flashColor: FieldSpec<"Color">; readonly glow: FieldSpec<"f32">; readonly blend: FieldSpec<"SpriteBlend">; readonly castShadow: FieldSpec<"bool">; readonly sliceX: FieldSpec<"Vector2">; readonly sliceY: FieldSpec<"Vector2">; readonly sliceScale: FieldSpec<"f32">; readonly shadow: FieldSpec<"f32">; readonly shadowSize: FieldSpec<"Vector2">; readonly shadowOffset: FieldSpec<"Vector2">; readonly dropShadow: FieldSpec<"f32">; readonly dropShadowHeight: FieldSpec<"f32">; readonly toneMapped: FieldSpec<"bool">; readonly visible: FieldSpec<"bool">; readonly layers: FieldSpec<"u32"> }, Sprite>;
+  const Sprite: ComponentType<{ readonly texture: FieldSpec<"Texture">; readonly array: FieldSpec<"TextureArray">; readonly arrayLayer: FieldSpec<"u32">; readonly width: FieldSpec<"f32">; readonly height: FieldSpec<"f32">; readonly anchor: FieldSpec<"Vector2">; readonly color: FieldSpec<"Color">; readonly opacity: FieldSpec<"f32">; readonly uvMin: FieldSpec<"Vector2">; readonly uvMax: FieldSpec<"Vector2">; readonly layer: FieldSpec<"i32">; readonly sortY: FieldSpec<"bool">; readonly facing: FieldSpec<"SpriteFacing">; readonly flipX: FieldSpec<"bool">; readonly flipY: FieldSpec<"bool">; readonly flash: FieldSpec<"f32">; readonly flashColor: FieldSpec<"Color">; readonly glow: FieldSpec<"f32">; readonly blend: FieldSpec<"SpriteBlend">; readonly castShadow: FieldSpec<"bool">; readonly sliceX: FieldSpec<"Vector2">; readonly sliceY: FieldSpec<"Vector2">; readonly sliceScale: FieldSpec<"f32">; readonly shadow: FieldSpec<"f32">; readonly shadowSize: FieldSpec<"Vector2">; readonly shadowOffset: FieldSpec<"Vector2">; readonly dropShadow: FieldSpec<"f32">; readonly dropShadowHeight: FieldSpec<"f32">; readonly toneMapped: FieldSpec<"bool">; readonly visible: FieldSpec<"bool">; readonly layers: FieldSpec<"u32"> }, Sprite>;
   /**
    * Ghosts of the entity's og.Sprite: every `interval` ticks its pose (position, rotation, scale, frame, flips) is kept, and the last `count` are drawn behind it, fading from `opacity` to 0, tinted by color. A dash, a speed-up, a teleport. The history is world state (the og.sprite state block).
    */
@@ -22961,7 +23565,9 @@ export declare namespace og {
    * The physics settings of the world. The profile is the project's; the same components serve both profiles.
    */
   const Physics: ResourceType<{ readonly profile: FieldSpec<"u32">; readonly gravity: FieldSpec<"Vector3">; readonly substeps: FieldSpec<"u32">; readonly solverIterations: FieldSpec<"u32">; readonly restSpeed: FieldSpec<"f32"> }, Physics>;
-  /** Two solid colliders started touching during the tick. */
+  /**
+   * Two solid colliders started touching during the tick. Read in the tick after, when og.Velocity already holds the solver's answer (the bodies parting): how hard they met is `impulse` and `relativeVelocity`, taken in the step itself.
+   */
   const CollisionStarted: EventType<CollisionStarted>;
   /** Two solid colliders stopped touching, or one of them went away. */
   const CollisionEnded: EventType<CollisionEnded>;
@@ -23242,6 +23848,26 @@ export declare namespace og {
    * An inverse-kinematics constraint on a skeleton, applied after its clips and graph: the chain of `bones` bones ending at joint `tip` turns so the tip reaches `target`. Put it on its own entity (a skeleton can have many chains); chains apply in query order.
    */
   const IkChain: ComponentType<{ readonly skeleton: FieldSpec<"Entity">; readonly tip: FieldSpec<"u32">; readonly bones: FieldSpec<"u32">; readonly solver: FieldSpec<"IkSolver">; readonly target: FieldSpec<"Vector3">; readonly pole: FieldSpec<"Vector3">; readonly space: FieldSpec<"IkSpace">; readonly weight: FieldSpec<"f32">; readonly iterations: FieldSpec<"u32">; readonly tolerance: FieldSpec<"f32">; readonly reached: FieldSpec<"bool">; readonly error: FieldSpec<"f32"> }, IkChain>;
+  /**
+   * An aim constraint on a skeleton, applied after its clips, graph and IK chains: `joint` turns so its `axis` points at `target` and its `upAxis` leans towards `up` (three.js Object3D.lookAt: +Z at the target, +Y up). The direction is held within maxYaw and maxPitch of the animated forward; with `bones` above 1 the joint's parents share the turn. Put it on its own entity (a head, the eyes, a turret's barrel); constraints apply in query order, and og.JointLimit clamps the joints it turns.
+   */
+  const LookAt: ComponentType<{ readonly skeleton: FieldSpec<"Entity">; readonly joint: FieldSpec<"u32">; readonly bones: FieldSpec<"u32">; readonly target: FieldSpec<"Vector3">; readonly space: FieldSpec<"IkSpace">; readonly axis: FieldSpec<"Vector3">; readonly upAxis: FieldSpec<"Vector3">; readonly up: FieldSpec<"Vector3">; readonly maxYaw: FieldSpec<"f32">; readonly maxPitch: FieldSpec<"f32">; readonly weight: FieldSpec<"f32">; readonly clamped: FieldSpec<"bool"> }, LookAt>;
+  /**
+   * How far a joint may turn from its rest rotation when og.anim's solvers (og.IkChain, og.LookAt, og.FootLock) turn it: a swing of `axis` within a cone and a twist about it within a range. A hinge (a knee, an elbow) is `axis` along the hinge, `swing` 0 (or a little play) and the bend range as twistMin...twistMax. Put it on its own entity, one per joint; the animated pose itself is never clamped.
+   */
+  const JointLimit: ComponentType<{ readonly skeleton: FieldSpec<"Entity">; readonly joint: FieldSpec<"u32">; readonly axis: FieldSpec<"Vector3">; readonly swing: FieldSpec<"f32">; readonly twistMin: FieldSpec<"f32">; readonly twistMax: FieldSpec<"f32"> }, JointLimit>;
+  /**
+   * Foot locking: while the playing clips plant `foot` (within 5 mm of its lowest in each clip, the notion retargeting uses, weighed across blends and cross-fades: planted when the planting clips hold at least half the pose), the foot stays where it touched the ground, through clip blends and root motion, its leg bent by two-bone IK and the foot keeping its animated orientation; when the clips lift it, the foot rejoins its animation over `release`. Put it on its own entity, one per foot; locks apply after root motion and before og.IkChain, in query order, and og.JointLimit clamps the leg. The lock is world state (the `og.anim` state block).
+   */
+  const FootLock: ComponentType<{ readonly skeleton: FieldSpec<"Entity">; readonly foot: FieldSpec<"u32">; readonly weight: FieldSpec<"f32">; readonly release: FieldSpec<"f32">; readonly maxDistance: FieldSpec<"f32">; readonly planted: FieldSpec<"bool">; readonly locked: FieldSpec<"bool"> }, FootLock>;
+  /**
+   * A spring (jiggle) bone chain, three-vrm's VRMSpringBone: `joint` and its `bones` - 1 parents swing after their parents' motion. Each joint's tail (the next joint of the chain; for the last joint its first child, or its parent bone continued at the same length) is a point pulled towards where the animated pose puts it by a damped spring (`frequency`, `damping`), under `gravity`, held at the bone's length, and the joint turns to point at it. Applied after og.IkChain and og.LookAt, top joint first; put it on its own entity (a tail, an ear, a strand of hair, a single jiggling node), one per chain. Deterministic under the fixed tick; the tails' positions and velocities are world state (the `og.anim` state block), so a restore continues a swing exactly. A changed chain (another skeleton, length or space) restarts at the animated pose.
+   */
+  const SpringBone: ComponentType<{ readonly skeleton: FieldSpec<"Entity">; readonly joint: FieldSpec<"u32">; readonly bones: FieldSpec<"u32">; readonly frequency: FieldSpec<"f32">; readonly damping: FieldSpec<"f32">; readonly tipFrequency: FieldSpec<"f32">; readonly tipDamping: FieldSpec<"f32">; readonly gravity: FieldSpec<"Vector3">; readonly space: FieldSpec<"SpringSpace">; readonly weight: FieldSpec<"f32">; readonly radius: FieldSpec<"f32">; readonly colliders: FieldSpec<"u32">; readonly lag: FieldSpec<"f32"> }, SpringBone>;
+  /**
+   * A collider spring bones are kept out of, three-vrm's VRMSpringBoneCollider: a sphere or a capsule riding on a joint of a skeleton (a head, a chest, an upper arm), so hair, ears and tails do not swing through the body. Each tick, after a tail of an og.SpringBone of the same skeleton has stepped and before its joint turns, the tail is pushed out of every collider whose `layers` meet the spring's `colliders` (in query order) to `radius` plus the spring's `radius`, keeping its bone's length. Put it on its own entity, one per shape; colliders follow the pose as it is when a chain is swung, so one on a joint an earlier chain swung follows that swing.
+   */
+  const SpringCollider: ComponentType<{ readonly skeleton: FieldSpec<"Entity">; readonly joint: FieldSpec<"u32">; readonly shape: FieldSpec<"SpringColliderShape">; readonly offset: FieldSpec<"Vector3">; readonly tail: FieldSpec<"Vector3">; readonly radius: FieldSpec<"f32">; readonly layers: FieldSpec<"u32"> }, SpringCollider>;
   /**
    * A named marker of a clip that playback passed in the last tick (read in the tick after it fired, like every event). Cross-fades and blends fire every contributing clip's markers.
    */
@@ -23291,13 +23917,21 @@ export declare namespace og {
      */
     function humanoid(world: World, desc?: HumanoidDesc): Result<Humanoid>;
     /**
-     * A new clip for `target` from a clip of `source`: each animated humanoid bone turns as the source's does from its rest pose (after a rest correction, so a T-pose drives an A-pose and other bone frames agree), the target keeps its bone lengths, the hips travel the source's distance scaled by the leg ratio (root motion kept, hip height scaled), and with footIk the feet land where the source's do, scaled. Same name, duration and markers. The cook does the same for a model's `animation { library }` import setting; this is for clips chosen at run time.
+     * A new clip for `target` from a clip of `source`: each animated humanoid bone turns as the source's does from its rest pose (after a rest correction, so a T-pose drives an A-pose and other bone frames agree; fingers turn from their hand, so a hand pose holds whatever the arm does), the target keeps its bone lengths, the hips travel the source's distance scaled by the leg ratio (root motion kept, hip height scaled), and with footIk the feet land where the source's do, scaled, on the ground each rig's `footHeight` names (else its rest pose's foot heights). The target's twist bones (unmapped nodes named `twist`, or Rigify's `DEF-….001`, on an upper or lower arm or leg) take a share of their segment's twist by how far along it they sit. Same name, duration and markers. The cook does the same for a model's `animation { library }` import setting; this is for clips chosen at run time.
      *
      * @param world The world whose animation owns the skeletons and the clip.
      * @param desc The clip, the two skeletons and their rigs.
      * @returns The new clip (what AnimationPlayer.clip takes). Refused for an unregistered clip, skeleton or rig, a skeleton without recognisable hips (name them in a `type rig` file), or a rig naming a missing node.
      */
     function retarget(world: World, desc?: RetargetDesc): Result<ClipInfo>;
+    /**
+     * A new clip that plays `clip` on the other side: every frame reflected in the skeleton's x = 0 plane, each node taking its counterpart's motion (a left swing becomes the right's), rotations moved in model space so left and right bone frames need not mirror each other, root motion's sideways travel and turns flipped. Assumes a symmetric rest pose; a sided node without a counterpart keeps its rest pose. Same name, duration and markers (markers keep their names). Mirroring twice gives the clip back. A clip known ahead needs no call: a graph's `clip` line with `mirror true` plays it mirrored, and the cook's `animation { mirror "<clip>" }` writes the mirrored clip into the model.
+     *
+     * @param world The world whose animation owns the skeleton and the clip.
+     * @param desc The clip and its skeleton.
+     * @returns The new clip (what AnimationPlayer.clip takes). Refused for an unregistered clip or skeleton.
+     */
+    function mirror(world: World, desc?: MirrorDesc): Result<ClipInfo>;
     /**
      * The index of a flipbook clip by name, for Flipbook.clip: `og.anim.clip(hero, "walk_down")`. -1 when the sheet has no such clip.
      *
@@ -23459,13 +24093,13 @@ export declare namespace og {
    * A sound an entity plays. Level-triggered: while `playing` is true it plays (inserting a source plays it), setting it false stops it, and a one-shot that reaches its end sets it back to false and sends og.SoundEnded.
    * A one-shot of F frames at rate R and pitch p started in tick S ends in tick S + ceil(F * tickRate / (R * p)) - 1. A despawned entity's voice is silenced without an event.
    */
-  const AudioSource: ComponentType<{ readonly sound: FieldSpec<"Sound">; readonly bus: FieldSpec<"AudioBus">; readonly volume: FieldSpec<"f32">; readonly pitch: FieldSpec<"f32">; readonly pan: FieldSpec<"f32">; readonly loop: FieldSpec<"bool">; readonly loopStart: FieldSpec<"f32">; readonly loopEnd: FieldSpec<"f32">; readonly spatial: FieldSpec<"bool">; readonly refDistance: FieldSpec<"f32">; readonly maxDistance: FieldSpec<"f32">; readonly rolloffFactor: FieldSpec<"f32">; readonly playing: FieldSpec<"bool">; readonly priority: FieldSpec<"u32">; readonly lowpass: FieldSpec<"f32">; readonly occlude: FieldSpec<"bool">; readonly distanceCutoff: FieldSpec<"f32">; readonly startAt: FieldSpec<"f64">; readonly startOffset: FieldSpec<"f64">; readonly fade: FieldSpec<"f32"> }, AudioSource>;
+  const AudioSource: ComponentType<{ readonly sound: FieldSpec<"Sound">; readonly bus: FieldSpec<"AudioBus">; readonly volume: FieldSpec<"f32">; readonly pitch: FieldSpec<"f32">; readonly pan: FieldSpec<"f32">; readonly loop: FieldSpec<"bool">; readonly loopStart: FieldSpec<"f32">; readonly loopEnd: FieldSpec<"f32">; readonly spatial: FieldSpec<"bool">; readonly refDistance: FieldSpec<"f32">; readonly maxDistance: FieldSpec<"f32">; readonly rolloffFactor: FieldSpec<"f32">; readonly playing: FieldSpec<"bool">; readonly priority: FieldSpec<"u32">; readonly lowpass: FieldSpec<"f32">; readonly occlude: FieldSpec<"bool">; readonly distanceCutoff: FieldSpec<"f32">; readonly startAt: FieldSpec<"f64">; readonly startOffset: FieldSpec<"f64">; readonly fade: FieldSpec<"f32">; readonly dopplerFactor: FieldSpec<"f32">; readonly coneInnerAngle: FieldSpec<"f32">; readonly coneOuterAngle: FieldSpec<"f32">; readonly coneOuterGain: FieldSpec<"f32">; readonly virtualize: FieldSpec<"bool">; readonly retrigger: FieldSpec<"bool"> }, AudioSource>;
   /**
    * Where spatial sources are heard from: the entity's world transform (its og.Transform down og.Parent, so a listener under a camera rig hears from the rig), looking down its -Z with +X to the right. The first listener in query order is used.
    */
-  const AudioListener: ComponentType<{ readonly volume: FieldSpec<"f32"> }, AudioListener>;
+  const AudioListener: ComponentType<{ readonly volume: FieldSpec<"f32">; readonly dopplerFactor: FieldSpec<"f32">; readonly panningModel: FieldSpec<"PanningModel"> }, AudioListener>;
   /** Bus volumes; master scales every bus. A change ramps over 256 frames in the mixer. */
-  const Audio: ResourceType<{ readonly master: FieldSpec<"f32">; readonly music: FieldSpec<"f32">; readonly sfx: FieldSpec<"f32">; readonly ui: FieldSpec<"f32">; readonly maxVoices: FieldSpec<"u32">; readonly occlusionGain: FieldSpec<"f32">; readonly occlusionCutoff: FieldSpec<"f32">; readonly reverbRoom: FieldSpec<"f32">; readonly reverbDamping: FieldSpec<"f32">; readonly outputLatency: FieldSpec<"f64"> }, Audio>;
+  const Audio: ResourceType<{ readonly master: FieldSpec<"f32">; readonly music: FieldSpec<"f32">; readonly sfx: FieldSpec<"f32">; readonly ui: FieldSpec<"f32">; readonly maxVoices: FieldSpec<"u32">; readonly occlusionGain: FieldSpec<"f32">; readonly occlusionCutoff: FieldSpec<"f32">; readonly reverbRoom: FieldSpec<"f32">; readonly reverbDamping: FieldSpec<"f32">; readonly outputLatency: FieldSpec<"f64">; readonly speedOfSound: FieldSpec<"f32">; readonly resampler: FieldSpec<"AudioResampler"> }, Audio>;
   /**
    * A bus's insert effects: a high- and low-pass (12 dB/octave), a compressor, side-chain ducking by another bus, and a send to the shared reverb, whose return joins master. One entity per bus (the first in query order counts); without one a bus passes straight through.
    * Changes reach the mixer through the command stream, so they are deterministic and in the world hash; the PCM is the mixer's.
@@ -23492,6 +24126,7 @@ export declare namespace og {
    * Sound: inside the tick, the engine's og.audio system (after the game's systems and physics) turns AudioSource changes into a deterministic, time-stamped command stream; outside the tick the host's mixer renders it (an AudioWorklet on the web, the output device, a capture or a null sink natively).
    * The stream, not the PCM, is world state: snapshots, restore and the world hash cover it, and nothing a sink does reaches the world. Load sounds with og.load.sound; inserting a source plays it, setting `playing` false stops it, and a one-shot sets `playing` back to false when it ends.
    * Spatial gain and pan are computed in the tick from the source's world transform relative to the first AudioListener's (three.js convention: the listener looks down -Z, +X is right; with none, the origin looking down -Z). A source, listener or zone on a child entity is placed at its og.Transform composed down og.Parent, as og.MatrixWorld is: a sound on a child is heard where its parent carries it, a listener under a camera rig hears from the rig.
+   * Propagation, all in the tick and so in the stream: a spatial source or listener that moves shifts the pitch (Doppler, from their tick velocities: AudioSource.dopplerFactor, AudioListener.dopplerFactor, Audio.speedOfSound), a source with a cone is turned down away from its +Z (coneInnerAngle, coneOuterAngle, coneOuterGain, as three.js's setDirectionalCone), and a listener whose panningModel is hrtf places sources for headphones (interaural delay and head shadow) instead of the stereo panner.
    */
   namespace audio {
     /**