@origingame/engine 0.3.0 → 0.5.0

package/types/index.d.ts

@@ -31,12 +31,32 @@ export interface FieldSpec<K extends ColumnKind = ColumnKind> {
   readonly capacity?: number;
 }
 
+/** The column kinds a list holds: one number (`f32`, `f64`, `u32`, `i32`) or a handle. */
+export type ListKind = {
+  [K in ColumnKind]: ColumnKinds[K]["value"] extends number ? K : never;
+}[ColumnKind];
+
+/**
+ * A list field, made by `list(of, capacity)`: at most `list` values of the
+ * element's kind, starting empty. Its value is a frozen array: read it as a
+ * copy, write it whole (`post.custom = [...post.custom, h]`).
+ */
+export interface ListSpec<K extends ListKind = ListKind> {
+  readonly kind: K;
+  readonly default: readonly ColumnKinds[K]["value"][];
+  readonly options: FieldOptions;
+  /** The capacity in elements, 1 to 1024. */
+  readonly list: number;
+}
+
 /** A reflected layout: field names to field specs. */
-export type Fields = { readonly [field: string]: FieldSpec };
+export type Fields = { readonly [field: string]: FieldSpec | ListSpec };
 
-/** The value of a layout: each field as its column's value type. */
+/** The value of a layout: each field as its column's value type, a list as a read-only array of it. */
 export type FieldValues<F extends Fields> = {
-  -readonly [K in keyof F]: ColumnKinds[F[K]["kind"]]["value"];
+  -readonly [K in keyof F]: F[K] extends { readonly list: number }
+    ? readonly ColumnKinds[F[K]["kind"]]["value"][]
+    : ColumnKinds[F[K]["kind"]]["value"];
 };
 
 /** The typed views of a layout: each field as its column's typed array. */
@@ -117,6 +137,8 @@ export interface ColumnKinds {
   Material: { readonly array: Uint32Array; readonly stride: 2; readonly value: Material };
   /** A ToneMapping field: the variant's index. */
   ToneMapping: { readonly array: Uint32Array; readonly stride: 1; readonly value: ToneMapping };
+  /** A QualityPreset field: the variant's index. */
+  QualityPreset: { readonly array: Uint32Array; readonly stride: 1; readonly value: QualityPreset };
   /** A Texture handle field (0 is none). */
   Texture: { readonly array: Uint32Array; readonly stride: 2; readonly value: Texture };
   /** A Lut handle field (0 is none). */
@@ -131,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. */
@@ -155,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. */
@@ -169,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. */
@@ -179,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. */
@@ -901,8 +951,8 @@ export declare const color: ColorMath;
 // ── reflect ─────────────────────────────────────────────────────
 // 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: there is no array or list column. A few values are numbered fields (`p0` to `p7`, as og.CameraRail does); a list of things 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 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()`, `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.
@@ -1055,6 +1105,17 @@ export declare function Color(value?: Color, options?: FieldOptions): FieldSpec<
  */
 export declare function str(capacity: number, value?: string, options?: FieldOptions): FieldSpec<"str">;
 
+/**
+ * A list of at most `capacity` values of one number column (`f32`, `f64`, `u32`, `i32`) or handle column (`Asset`, `Entity`, `Post`, ...), stored inline: a count, then the elements, zeros past the count, so `[]` and `[0]` differ and the list is world state like a number. The capacity is 1 to 1,024 elements; it starts empty and is never tunable.
+ * Reading it answers a frozen array, a copy: `push`, `splice` and index writes throw, so change it by writing a whole array (`v.passes = [...v.passes, h]`, `v.passes = []`). A list over the capacity is refused with the fix named (an error value from world.insert/world.set, a throw from a resource's setter), never truncated. Scene text and looks give it on one line, its elements in order (`passes 3 5`), the key alone for the empty list. Its view is the element's typed array with a stride of (capacity + 1) elements, the count first.
+ *
+ * A list field: stored in the element's typed array, (capacity + 1) of its lanes per entity, the count first.
+ * @param of The element's column factory, called for its kind: `u32()`, `Asset()`, `Post()` (its default and options are not used).
+ * @param capacity The most elements it holds, 1 to 1024.
+ * @param options Label and docs (a list has no range and is not tunable).
+ */
+export declare function list<K extends ListKind>(of: FieldSpec<K>, capacity: number, options?: FieldOptions): ListSpec<K>;
+
 /**
  * Declare a component: plain data stored per entity in engine memory, one column per field.
  * Registration is by name, so a hot reload re-registers the same component and migrates its fields by name.
@@ -4030,7 +4091,33 @@ export type ToneMapping = "aces" | "agx" | "none";
 export declare function ToneMapping(value?: ToneMapping, options?: FieldOptions): FieldSpec<"ToneMapping">;
 
 /**
- * The frame's look after lighting: environment light, sky, bloom, exposure metering and tone mapping. Read after each tick; it never feeds back into the simulation. Camera.exposure is the manual exposure.
+ * A graphics preset: a row of RenderSettings' quality fields that og.render.applyQuality writes (its doc has the table). The settings screen (og.ui.settingsScreen) offers the three.
+ * - `"medium"`: The full frame: every quality field at its default.
+ * - `"low"`: The cheapest frame: no rect-light shadows, two shadowed lights, half-size shadow maps, plain fog, hard particles, no screen-space reflections or ambient occlusion, FXAA for MSAA.
+ * - `"high"`: The full frame with the shadow maps at twice their side.
+ */
+export type GraphicsQuality = "medium" | "low" | "high";
+
+/**
+ * The preset RenderSettings' quality fields were last written with (RenderSettings.quality).
+ * - `"none"`: No preset applied: the fields are their defaults or the game's own.
+ * - `"low"`: og.render.applyQuality(world, "low").
+ * - `"medium"`: og.render.applyQuality(world, "medium").
+ * - `"high"`: og.render.applyQuality(world, "high").
+ */
+export type QualityPreset = "none" | "low" | "medium" | "high";
+
+/**
+ * A QualityPreset field: the variant's index.
+ *
+ * A `QualityPreset` 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 QualityPreset(value?: QualityPreset, options?: FieldOptions): FieldSpec<"QualityPreset">;
+
+/**
+ * The frame's look after lighting: environment light, sky, bloom, exposure metering and tone mapping, and what the frame may cost: the quality fields (rectShadows to msaaSamples) that og.render.applyQuality sets from a graphics preset. Read after each tick; it never feeds back into the simulation. Camera.exposure is the manual exposure.
  *
  * The `RenderSettings` resource (token `og.RenderSettings`).
  */
@@ -4115,7 +4202,7 @@ export interface RenderSettings {
    */
   decalAtlas: Texture;
   /**
-   * A multiplier on every model's projected size when its level of detail is picked (og.Model.lodBias multiplies it again): 1 is the engine's choice, 2 keeps full meshes twice as far, 0.5 simplifies sooner; 0 draws every model at its full mesh.
+   * A multiplier on every model's projected level-of-detail error when its level is picked (og.Model.lodBias multiplies it again): a level is drawn while its error, measured by the cook against the full mesh, covers less than a pixel on the screen. 1 is the engine's choice, 2 keeps full meshes twice as far, 0.5 simplifies sooner; 0 draws every model at its full mesh.
    *
    * @default 1
    * @range 0..16
@@ -4128,6 +4215,61 @@ export interface RenderSettings {
    * @default true
    */
   bakedLighting: boolean;
+  /**
+   * The graphics preset og.render.applyQuality last wrote into the quality fields below (rectShadows to msaaSamples), or none. A record for the settings screen and the probe: the renderer reads the fields, never this, so a field the game sets after the preset is drawn as set.
+   */
+  quality: QualityPreset;
+  /**
+   * Rect lights whose castShadow is on cast their soft shadows; false draws every rect light unshadowed, each keeping its castShadow for when this is on again. The low preset turns it off: a rect light's shadow is the costliest light in the frame.
+   *
+   * @default true
+   */
+  rectShadows: boolean;
+  /**
+   * At most this many point, spot and rect lights cast shadows in a frame, the brightest at the camera kept (RenderCapabilities.shadowedLights caps it); 0 casts none. The directional light's cascades are not counted.
+   *
+   * @default 8
+   * @range 0..8
+   */
+  shadowedLights: number;
+  /**
+   * The shadow maps at this fraction of their full side: the directional light's cascades (2048 texels by default) and the local lights' layers (512), each kept within 64 texels and the device's limit (4096 for the cascades). Changing it makes the maps again at the next frame; RenderCapabilities.shadowMapSize is the cascades' side drawn.
+   *
+   * @default 1
+   * @range 0.125..4
+   */
+  shadowMapScale: number;
+  /**
+   * An og.VolumetricFog is drawn lit, with its light shafts; false draws the same medium as plain distance and height fog.
+   *
+   * @default true
+   */
+  volumetricFog: boolean;
+  /**
+   * Particles with a softDistance fade against the scene behind them; false draws them hard-edged and asks no depth prepass for them.
+   *
+   * @default true
+   */
+  softParticles: boolean;
+  /**
+   * PostEffects.ssr draws (on the full tier); false leaves smooth surfaces the reflection probes' and the environment's reflection. PostEffects keeps its settings either way.
+   *
+   * @default true
+   */
+  screenSpaceReflections: boolean;
+  /**
+   * PostEffects.ao darkens creases; false draws none. PostEffects keeps its settings either way.
+   *
+   * @default true
+   */
+  ambientOcclusion: boolean;
+  /**
+   * Samples per pixel where the antialiasing multisamples (msaa, the WebGL2 tier's choice; RenderCapabilities.antialias): 4, or 1, which draws FXAA instead. TAA, FXAA and no antialiasing take one sample whatever it says. Changing it makes the multisampled targets and pipelines again at the next frame.
+   *
+   * @default 4
+   * @range 1..4
+   */
+  msaaSamples: number;
 }
 
 /**
@@ -4273,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.
@@ -4617,23 +4776,11 @@ export interface PostEffects {
    */
   ssrIntensity: number;
   /**
-   * The first custom post pass (og.load.post, a `type post` asset; 0 is none). PostEffects.custom1 to custom8 are an ordered list, as many as og-render runs (RenderCapabilities.maxCustomPosts): each runs over the one before it (the lit image for the first), after depth of field and motion blur and before exposure, bloom and the tone curve, and reads the lit image, depth and normals too (it turns the prepass on). Its parameters are set with og.render.setPostParam. A pass the device fails to compile is reported (og.render.postErrors) and skipped.
+   * The custom post passes, in order (og.load.post, `type post` assets): at most RenderCapabilities.maxCustomPosts (8, og-render's MAX_CUSTOM_POSTS). Each runs over the one before it (the lit image for the first), after depth of field and motion blur and before exposure, bloom and the tone curve, and reads the lit image, depth and normals too (any pass turns the prepass on). Write the whole list: `post.custom = [grade, crt]`, `post.custom = []`; a look gives it on one line (`custom "post/tint.ogt" "post/crt.ogt"`). A 0 in it is skipped. Its parameters are set with og.render.setPostParam. A pass the device fails to compile is reported (og.render.postErrors) and skipped.
+   *
+   * @capacity 8 elements (List.Post.8): reading answers a frozen copy (push throws); write a whole array, refused over the capacity, never truncated
    */
-  custom1: Post;
-  /** The second custom post pass, over the first's output (0 skips the slot). */
-  custom2: Post;
-  /** The third custom post pass. */
-  custom3: Post;
-  /** The fourth custom post pass. */
-  custom4: Post;
-  /** The fifth custom post pass. */
-  custom5: Post;
-  /** The sixth custom post pass. */
-  custom6: Post;
-  /** The seventh custom post pass. */
-  custom7: Post;
-  /** The eighth and last custom post pass, over every one before it. */
-  custom8: Post;
+  custom: readonly Post[];
 }
 
 /**
@@ -4659,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.
@@ -5656,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.
  */
@@ -5792,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.
    *
@@ -5839,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`).
@@ -5907,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. */
@@ -6323,7 +6489,7 @@ export interface RenderCapabilities {
   /** The largest side of a render target (the device's largest 2D texture). */
   readonly maxRenderTargetSize: number;
   /**
-   * The most custom post passes a frame runs: 8 on every tier, PostEffects.custom1 to custom8 (numbered fields, as a reflected record has no list field).
+   * The most custom post passes a frame runs: 8 on every tier, PostEffects.custom's capacity.
    */
   readonly maxCustomPosts: number;
   /**
@@ -6339,9 +6505,17 @@ export interface RenderCapabilities {
    */
   readonly maxLightCookies: number;
   /**
-   * Whether the device times each render pass on the GPU (timestamp queries: Vulkan, Metal and D3D12 adapters that have them, WebGPU with `timestamp-query`; never WebGL2): ProbeTimings.gpuPasses and the trace's gpu thread are filled only where it is true.
+   * Whether the device times each render pass on the GPU (timestamp queries: Vulkan, Metal and D3D12 adapters that have them, WebGPU with `timestamp-query`; never WebGL2, and never in a publish build, which leaves the queries out): ProbeTimings.gpuPasses and the trace's gpu thread are filled only where it is true.
    */
   readonly gpuTimestamps: boolean;
+  /**
+   * The anisotropic filtering of sprites and og.ui's images (text is not filtered anisotropically: its distance field would lose its edge): 16 where the device filters anisotropically (WebGPU, Vulkan, Metal, WebGL2 with EXT_texture_filter_anisotropic), 1 where it has none and on a software rasterizer (the vulkan-cpu tier: lavapipe's anisotropic filter softens even an image drawn 1:1), 0 without a renderer. Above 1, an image squeezed along one axis keeps the other axis's detail: a style's nine-slice middle squeezed into a short button keeps its outline as crisp as the corners. At 1 the squeezed piece reads a smaller mip level and blurs; og.ui bounds a middle's squeeze at twice its art, so the outline there is one mip level softer than the corners.
+   */
+  readonly spriteAnisotropy: number;
+  /**
+   * Whether the renderer draws the 3D world subsystems: terrain, planar water (og.Water), the 3D fluids, scattered copies and volumetric fog. False in the 2D profile's publish and lanes modules, which leave them out (a scene's are not drawn, og.terrain's calls and a SHAPE_HEIGHTFIELD collider answer a refusal naming this field, and `og build --publish` refuses a 2D project whose scenes hold og.Terrain, og.TerrainScatter, og.Water, og.WaterSurface or og.Fluid3D, by scene file and line); true in the 3D modules, the dev module and the native host.
+   */
+  readonly world3d: boolean;
 }
 
 /**
@@ -6429,6 +6603,16 @@ 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">;
+
+
 
 
 
@@ -6860,177 +7044,696 @@ export interface TubeGeometryDesc {
 
 
 /**
- * How a line set's points join, as three.js's three line objects.
- * - `"strip"`: One polyline through every point, as three.js Line.
- * - `"segments"`: Pairs of points, each its own segment, as three.js LineSegments.
- * - `"loop"`: A polyline closed back to its first point, as three.js LineLoop.
+ * A shape as points, what og.Shape.extractPoints returns and what shapeGeometry, extrudeGeometry and sweepGeometry read: the outline, then each hole. A repeated closing point is dropped, as three.js drops it.
  */
-export type LineMode = "strip" | "segments" | "loop";
+export interface ShapePoints {
+  /** The outline's points, in order. */
+  readonly shape: readonly Vector2[];
+  /** Each hole's points, in order. */
+  readonly holes: readonly (readonly Vector2[])[];
+}
 
 /**
- * A LineMode field: the variant's index.
+ * A flat shape with holes in the xy plane facing +Z, as three.js ShapeGeometry(shapes, curveSegments): triangulated by earcut (three.js's own port), the outline made clockwise and the holes counter-clockwise first, so its vertices and triangles are three.js's for the same shape. uvs are world x and y (v flipped to run down the image).
  *
- * A `LineMode` 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.
+ * A desc: every field may be omitted and then takes its documented default; `{}` is valid.
  */
-export declare function LineMode(value?: LineMode, options?: FieldOptions): FieldSpec<"LineMode">;
+export interface ShapeGeometryDesc {
+  /**
+   * One og.Shape (an og.Path2 is a shape without holes), a list of them, or the outline's points. Without it, three.js's default triangle (0, 0.5), (-0.5, -0.5), (0.5, -0.5).
+   *
+   * @default null
+   */
+  readonly shapes?: Path2 | readonly Path2[] | readonly Vector2[] | null;
+  /**
+   * Points per curve when an og.Shape's curves are flattened (three.js extractPoints(curveSegments); an ellipse takes twice as many, a spline as many per point).
+   *
+   * @default 12
+   * @range 1..
+   */
+  readonly curveSegments?: number;
+  /**
+   * How many times a texture repeats across it, along u and v: its UVs scaled by uvRepeat (three.js texture.repeat, here on the geometry; material textures sample with repeat wrapping).
+   *
+   * @default { x: 1, y: 1 }
+   */
+  readonly uvRepeat?: Vector2;
+  /**
+   * Register it as a physics mesh too (BufferGeometryDesc.physics).
+   *
+   * @default true
+   */
+  readonly physics?: boolean;
+  /**
+   * Whether og.render.updateGeometry may rewrite it later (BufferGeometryDesc.dynamic).
+   *
+   * @default false
+   */
+  readonly dynamic?: boolean;
+}
 
 /**
- * Lines through points, drawn this frame only (immediate mode, as og.render.sprite): submit them every tick they should show. three.js Line, LineSegments and LineLoop with a LineBasicMaterial or LineDashedMaterial, but any width on every tier (each segment is a quad in screen space with a feathered edge, so WebGL2's one-pixel lines do not apply).
- * World lines are drawn in the scene after the transparent meshes and particles, exposed, bloomed and tone mapped with it; screen lines over the finished frame, after every post effect and under the UI.
+ * Shapes pushed along +Z, or along a path, as three.js ExtrudeGeometry(shapes, options) with its option names and defaults: a closed solid, its lids from earcut and its walls ring by ring, rounded by a bevel of bevelSegments rings at each face. Unindexed as three.js's (every triangle its own vertices, flat normals), three.js's vertex order and counts; uvs from three.js's WorldUVGenerator (v flipped to run down the image).
  *
  * A desc: every field may be omitted and then takes its documented default; `{}` is valid.
  */
-export interface LinesDesc {
+export interface ExtrudeGeometryDesc {
   /**
-   * The points, in order: world positions, or with screen CSS pixels from the top left of the play surface with y down (z ignored).
+   * One og.Shape, a list of them, or the outline's points. Without it, three.js's default square of side 1.
    *
-   * @default []
+   * @default null
+   */
+  readonly shapes?: Path2 | readonly Path2[] | readonly Vector2[] | null;
+  /**
+   * How far the shape is pushed along +Z (without extrudePath).
+   *
+   * @default 1
+   * @range 0..
    * @unit m (metres)
    */
-  readonly points?: readonly Vector3[];
+  readonly depth?: number;
   /**
-   * Per point linear colours, blended along each segment (three.js vertexColors); empty is `color` for all.
+   * Rings along the depth or the path.
    *
-   * @default []
+   * @default 1
+   * @range 1..
    */
-  readonly colors?: readonly Color[];
+  readonly steps?: number;
   /**
-   * The linear colour.
+   * Round the edges of both faces.
    *
-   * @default { r: 1, g: 1, b: 1 }
+   * @default true
    */
-  readonly color?: Color;
+  readonly bevelEnabled?: boolean;
   /**
-   * The alpha.
+   * How far the bevel reaches beyond each face, along z.
    *
-   * @default 1
-   * @range 0..1
+   * @default 0.2
+   * @range 0..
+   * @unit m (metres)
    */
-  readonly opacity?: number;
+  readonly bevelThickness?: number;
   /**
-   * How the points join.
+   * How far the bevel reaches out from the outline. Null or unset, bevelThickness - 0.1, as three.js derives it (0.1 at the default thickness, 0 at a thickness of 0.1).
    *
-   * @default "strip"
+   * @default null
+   * @unit m (metres)
    */
-  readonly mode?: LineMode;
+  readonly bevelSize?: number | null;
   /**
-   * The width: CSS pixels, or world units with worldUnits.
+   * How far the bevel starts out from the outline.
    *
-   * @default 1
-   * @range 0..
+   * @default 0
+   * @unit m (metres)
    */
-  readonly width?: number;
+  readonly bevelOffset?: number;
   /**
-   * Measure width in world units (a line that thins with distance) instead of CSS pixels (as wide at any distance).
+   * Rings in each bevel.
    *
-   * @default false
+   * @default 3
+   * @range 1..
    */
-  readonly worldUnits?: boolean;
+  readonly bevelSegments?: number;
   /**
-   * Hidden behind nearer geometry, as three.js Material.depthTest; false draws it over the scene. Screen lines are never depth tested.
+   * Points per curve when an og.Shape's curves are flattened.
    *
-   * @default true
+   * @default 12
+   * @range 1..
    */
-  readonly depthTest?: boolean;
+  readonly curveSegments?: number;
   /**
-   * Draw in screen space over the finished frame: points in CSS pixels, width in CSS pixels.
+   * A path (og.path.create or og.path.find) to extrude along instead of +Z: the shape's x along the path's normal and y along its binormal (three.js's Frenet frames), steps rings evenly spaced along it. A path turns the bevel off, as three.js. 0 extrudes along +Z.
    *
-   * @default false
+   * @default 0
    */
-  readonly screen?: boolean;
+  readonly extrudePath?: Path;
   /**
-   * Dashes, as three.js LineDashedMaterial: dashSize on, gapSize off, along the line from its first point.
+   * How many times a texture repeats across it, along u and v: its UVs scaled by uvRepeat (three.js texture.repeat, here on the geometry; material textures sample with repeat wrapping).
    *
-   * @default false
+   * @default { x: 1, y: 1 }
    */
-  readonly dashed?: boolean;
+  readonly uvRepeat?: Vector2;
   /**
-   * A dash's length: world units (CSS pixels for screen lines).
+   * Register it as a physics mesh too.
    *
-   * @default 3
-   * @range 0..
+   * @default true
    */
-  readonly dashSize?: number;
+  readonly physics?: boolean;
   /**
-   * A gap's length.
+   * Whether og.render.updateGeometry may rewrite it later.
    *
-   * @default 1
-   * @range 0..
+   * @default false
    */
-  readonly gapSize?: number;
+  readonly dynamic?: boolean;
 }
 
-
 /**
- * A point cloud drawn this frame only (immediate mode), as three.js Points with a PointsMaterial: a square per point facing the camera. Submit it every tick it should show (og.Points keeps a static set).
+ * A profile turned round +Y, as three.js LatheGeometry(points, segments, phiStart, phiLength): vases, bottles, columns, wheels. three.js's vertices, indices and smooth normals; u round the axis, v along the profile (flipped to run down the image). A whole turn's seam meets exactly.
  *
  * A desc: every field may be omitted and then takes its documented default; `{}` is valid.
  */
-export interface PointsDesc {
+export interface LatheGeometryDesc {
   /**
-   * The positions: world, or with screen CSS pixels from the top left, y down.
+   * The profile, x the distance from the axis and y the height, in order (at least two). Without it, three.js's default (0, -0.5), (0.5, 0), (0, 0.5).
    *
    * @default []
    * @unit m (metres)
    */
-  readonly points?: readonly Vector3[];
-  /**
-   * Per point linear colours; empty is `color` for all.
-   *
-   * @default []
-   */
-  readonly colors?: readonly Color[];
+  readonly points?: readonly Vector2[];
   /**
-   * The linear colour.
+   * Segments round the axis.
    *
-   * @default { r: 1, g: 1, b: 1 }
+   * @default 12
+   * @range 1..
    */
-  readonly color?: Color;
+  readonly segments?: number;
   /**
-   * The alpha.
+   * Where the turn starts, from +Z towards +X.
    *
-   * @default 1
-   * @range 0..1
+   * @default 0
+   * @unit rad (radians)
    */
-  readonly opacity?: number;
+  readonly phiStart?: number;
   /**
-   * The side of each square: world units with sizeAttenuation, else CSS pixels.
+   * How far it turns; 2 pi is whole (clamped to it).
    *
-   * @default 1
-   * @range 0..
+   * @default 6.283185307179586
+   * @unit rad (radians)
    */
-  readonly size?: number;
+  readonly phiLength?: number;
   /**
-   * Size in world units, smaller with distance, as three.js PointsMaterial.sizeAttenuation; false keeps every point `size` CSS pixels.
+   * How many times a texture repeats across it, along u and v: its UVs scaled by uvRepeat (three.js texture.repeat, here on the geometry; material textures sample with repeat wrapping).
    *
-   * @default true
+   * @default { x: 1, y: 1 }
    */
-  readonly sizeAttenuation?: boolean;
+  readonly uvRepeat?: Vector2;
   /**
-   * Hidden behind nearer geometry; false draws them over the scene.
+   * Register it as a physics mesh too.
    *
    * @default true
    */
-  readonly depthTest?: boolean;
+  readonly physics?: boolean;
   /**
-   * Draw in screen space over the finished frame, positions and size in CSS pixels.
+   * Whether og.render.updateGeometry may rewrite it later.
    *
    * @default false
    */
-  readonly screen?: boolean;
+  readonly dynamic?: boolean;
 }
 
-
 /**
- * Draws a geometry's vertices as lines at the entity's MatrixWorld, every frame (three.js Line, LineSegments or LineLoop over a BufferGeometry): a static set of lines kept as data, a level's outline, a track, a constellation. The vertices are taken in order (the geometry's indices are not read), with its vertex colours times color.
+ * A polyhedron from vertices and faces, every face subdivided `detail` times and every vertex pushed onto the sphere of `radius`, as three.js PolyhedronGeometry(vertices, indices, radius, detail): unindexed, flat normals at detail 0 and the sphere's above, three.js's spherical uvs.
  *
- * The value of the `Lines` component (token `og.Lines`).
+ * A desc: every field may be omitted and then takes its documented default; `{}` is valid.
  */
-export interface Lines {
-  /** The vertices (og.render.bufferGeometry: an unindexed one of any count). */
-  geometry: Geometry;
+export interface PolyhedronGeometryDesc {
+  /**
+   * The corners, x y z each (three.js's flat array).
+   *
+   * @default []
+   */
+  readonly vertices?: readonly number[];
+  /**
+   * The faces, three corner indices each, counter-clockwise seen from outside.
+   *
+   * @default []
+   */
+  readonly indices?: readonly number[];
+  /**
+   * The sphere the vertices are pushed onto.
+   *
+   * @default 1
+   * @range 0..
+   * @unit m (metres)
+   */
+  readonly radius?: number;
+  /**
+   * Subdivisions of each face: (detail + 1)² triangles a face.
+   *
+   * @default 0
+   * @range ..64
+   */
+  readonly detail?: number;
+  /**
+   * How many times a texture repeats across it, along u and v: its UVs scaled by uvRepeat (three.js texture.repeat, here on the geometry; material textures sample with repeat wrapping).
+   *
+   * @default { x: 1, y: 1 }
+   */
+  readonly uvRepeat?: Vector2;
+  /**
+   * Register it as a physics mesh too.
+   *
+   * @default true
+   */
+  readonly physics?: boolean;
+  /**
+   * Whether og.render.updateGeometry may rewrite it later.
+   *
+   * @default false
+   */
+  readonly dynamic?: boolean;
+}
+
+/**
+ * A regular solid, as three.js IcosahedronGeometry, DodecahedronGeometry, OctahedronGeometry and TetrahedronGeometry(radius, detail): PolyhedronGeometryDesc with the solid's own vertices and faces. An icosahedron at detail 2 or more is a sphere with even triangles.
+ *
+ * A desc: every field may be omitted and then takes its documented default; `{}` is valid.
+ */
+export interface SolidGeometryDesc {
+  /**
+   * The radius.
+   *
+   * @default 1
+   * @range 0..
+   * @unit m (metres)
+   */
+  readonly radius?: number;
+  /**
+   * Subdivisions of each face.
+   *
+   * @default 0
+   * @range ..64
+   */
+  readonly detail?: number;
+  /**
+   * How many times a texture repeats across it, along u and v: its UVs scaled by uvRepeat (three.js texture.repeat, here on the geometry; material textures sample with repeat wrapping).
+   *
+   * @default { x: 1, y: 1 }
+   */
+  readonly uvRepeat?: Vector2;
+  /**
+   * Register it as a physics mesh too.
+   *
+   * @default true
+   */
+  readonly physics?: boolean;
+  /**
+   * Whether og.render.updateGeometry may rewrite it later.
+   *
+   * @default false
+   */
+  readonly dynamic?: boolean;
+}
+
+/**
+ * A value at a fraction of a sweep's path: linear between keys, held before the first and past the last.
+ */
+export interface SweepKey {
+  /**
+   * The fraction of the path's length, 0 to 1.
+   *
+   * @unit ratio (a fraction between 0 and 1)
+   */
+  readonly t: number;
+  /** The value there. */
+  readonly value: number;
+}
+
+/**
+ * A section swept along a path, scaled and twisted over it: horns, tusks, handles, blades, tapered pipes, twisted columns (img2threejs's tapered sweep; three.js has no class for it). The section's x lies along the path's normal and y along its binormal (three.js's Frenet frames), rings evenly spaced along the path's length; u runs along the path, v round the section (flipped to run down the image), the sides smooth. An open path's ends are capped.
+ *
+ * A desc: every field may be omitted and then takes its documented default; `{}` is valid.
+ */
+export interface SweepGeometryDesc {
+  /**
+   * The section's outline: an og.Shape or og.Path2 (flattened by curveSegments; holes are not swept) or its points, at least three, either winding.
+   *
+   * @default null
+   */
+  readonly section?: Path2 | readonly Vector2[] | null;
+  /**
+   * The path (og.path.create or og.path.find).
+   *
+   * @default 0
+   */
+  readonly path?: Path;
+  /**
+   * Rings along the path, less one.
+   *
+   * @default 64
+   * @range 1..
+   */
+  readonly steps?: number;
+  /**
+   * The section's scale over the path (none: 1 throughout). A horn: [{ t: 0, value: 1 }, { t: 1, value: 0.05 }].
+   *
+   * @default []
+   */
+  readonly scale?: readonly SweepKey[];
+  /**
+   * The section's turn round the path over its length, in radians (none: 0).
+   *
+   * @default []
+   */
+  readonly twist?: readonly SweepKey[];
+  /**
+   * Close the ends of an open path.
+   *
+   * @default true
+   */
+  readonly caps?: boolean;
+  /**
+   * Points per curve when an og.Shape section is flattened.
+   *
+   * @default 12
+   * @range 1..
+   */
+  readonly curveSegments?: number;
+  /**
+   * How many times a texture repeats across it, along u and v: its UVs scaled by uvRepeat (three.js texture.repeat, here on the geometry; material textures sample with repeat wrapping).
+   *
+   * @default { x: 1, y: 1 }
+   */
+  readonly uvRepeat?: Vector2;
+  /**
+   * Register it as a physics mesh too.
+   *
+   * @default true
+   */
+  readonly physics?: boolean;
+  /**
+   * Whether og.render.updateGeometry may rewrite it later.
+   *
+   * @default false
+   */
+  readonly dynamic?: boolean;
+}
+
+/**
+ * The world axis a part is mirrored along, after its placement.
+ * - `"none"`: Not mirrored.
+ * - `"x"`: x negated: the mirror image across the yz plane.
+ * - `"y"`: y negated: across the xz plane.
+ * - `"z"`: z negated: across the xy plane.
+ */
+export type MirrorAxis = "none" | "x" | "y" | "z";
+
+/**
+ * A geometry placed as an Object3D is (scale, then rotate, then move), then mirrored: one part of og.render.mergeGeometries or an operand of og.render.csgGeometry.
+ *
+ * A desc: every field may be omitted and then takes its documented default; `{}` is valid.
+ */
+export interface GeometryPart {
+  /**
+   * Any geometry: made, a primitive or a loaded glTF's.
+   *
+   * @default 0
+   */
+  readonly geometry?: Geometry;
+  /**
+   * Where it goes.
+   *
+   * @default { x: 0, y: 0, z: 0 }
+   * @unit m (metres)
+   */
+  readonly position?: Vector3;
+  /**
+   * How it turns.
+   *
+   * @default { x: 0, y: 0, z: 0, w: 1 }
+   */
+  readonly quaternion?: Quaternion;
+  /**
+   * Its scale (a negative component mirrors it as `mirror` does).
+   *
+   * @default { x: 1, y: 1, z: 1 }
+   */
+  readonly scale?: Vector3;
+  /**
+   * Mirror it along a world axis after placing it: a symmetric prop is one half twice, the second mirrored.
+   *
+   * @default "none"
+   */
+  readonly mirror?: MirrorAxis;
+}
+
+/**
+ * A boolean operation on two solids.
+ * - `"union"`: Everything in either: a + b.
+ * - `"subtract"`: What of a is not in b: a - b (holes, notches, a dice's pips).
+ * - `"intersect"`: What is in both.
+ */
+export type CsgOp = "union" | "subtract" | "intersect";
+
+/**
+ * Two closed geometries combined by a boolean operation, each placed first: a box with a hole bored through it, a dice, a window cut in a wall. The result is closed when both are (every edge shared by two triangles, wound opposite), every piece keeps its source's normals, uvs and colours (b's turned inside out where it is subtracted). Where a plane side or an edge crossing is decided, the decision is exact (Shewchuk's predicates), so every host makes the same cuts; faces that coincide keep one copy or none, as the operation says.
+ *
+ * A desc: every field may be omitted and then takes its documented default; `{}` is valid.
+ */
+export interface CsgGeometryDesc {
+  /**
+   * The operation.
+   *
+   * @default "union"
+   */
+  readonly op?: CsgOp;
+  /**
+   * The first operand.
+   *
+   * @default {}
+   */
+  readonly a?: GeometryPart;
+  /**
+   * The second operand.
+   *
+   * @default {}
+   */
+  readonly b?: GeometryPart;
+  /**
+   * How many times a texture repeats across it, along u and v: its UVs scaled by uvRepeat (three.js texture.repeat, here on the geometry; material textures sample with repeat wrapping).
+   *
+   * @default { x: 1, y: 1 }
+   */
+  readonly uvRepeat?: Vector2;
+  /**
+   * Register it as a physics mesh too.
+   *
+   * @default true
+   */
+  readonly physics?: boolean;
+  /**
+   * Whether og.render.updateGeometry may rewrite it later.
+   *
+   * @default false
+   */
+  readonly dynamic?: boolean;
+}
+
+/**
+ * Geometries placed and merged into one, as three.js BufferGeometryUtils.mergeGeometries after applying each part's matrix: a prop of parts drawn in one draw, a mirrored half, an array (the same part at several placements). Normals follow each placement; a mirrored part turns its triangles so they still face out. Vertex colours are kept when any part has them.
+ *
+ * A desc: every field may be omitted and then takes its documented default; `{}` is valid.
+ */
+export interface MergeGeometriesDesc {
+  /**
+   * The parts, in order (at least one).
+   *
+   * @default []
+   */
+  readonly parts?: readonly GeometryPart[];
+  /**
+   * How many times a texture repeats across it, along u and v: its UVs scaled by uvRepeat (three.js texture.repeat, here on the geometry; material textures sample with repeat wrapping).
+   *
+   * @default { x: 1, y: 1 }
+   */
+  readonly uvRepeat?: Vector2;
+  /**
+   * Register it as a physics mesh too.
+   *
+   * @default true
+   */
+  readonly physics?: boolean;
+  /**
+   * Whether og.render.updateGeometry may rewrite it later.
+   *
+   * @default false
+   */
+  readonly dynamic?: boolean;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+/**
+ * How a line set's points join, as three.js's three line objects.
+ * - `"strip"`: One polyline through every point, as three.js Line.
+ * - `"segments"`: Pairs of points, each its own segment, as three.js LineSegments.
+ * - `"loop"`: A polyline closed back to its first point, as three.js LineLoop.
+ */
+export type LineMode = "strip" | "segments" | "loop";
+
+/**
+ * A LineMode field: the variant's index.
+ *
+ * A `LineMode` 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 LineMode(value?: LineMode, options?: FieldOptions): FieldSpec<"LineMode">;
+
+/**
+ * Lines through points, drawn this frame only (immediate mode, as og.render.sprite): submit them every tick they should show. three.js Line, LineSegments and LineLoop with a LineBasicMaterial or LineDashedMaterial, but any width on every tier (each segment is a quad in screen space with a feathered edge, so WebGL2's one-pixel lines do not apply).
+ * World lines are drawn in the scene after the transparent meshes and particles, exposed, bloomed and tone mapped with it; screen lines over the finished frame, after every post effect and under the UI.
+ *
+ * A desc: every field may be omitted and then takes its documented default; `{}` is valid.
+ */
+export interface LinesDesc {
+  /**
+   * The points, in order: world positions, or with screen CSS pixels from the top left of the play surface with y down (z ignored).
+   *
+   * @default []
+   * @unit m (metres)
+   */
+  readonly points?: readonly Vector3[];
+  /**
+   * Per point linear colours, blended along each segment (three.js vertexColors); empty is `color` for all.
+   *
+   * @default []
+   */
+  readonly colors?: readonly Color[];
+  /**
+   * The linear colour.
+   *
+   * @default { r: 1, g: 1, b: 1 }
+   */
+  readonly color?: Color;
+  /**
+   * The alpha.
+   *
+   * @default 1
+   * @range 0..1
+   */
+  readonly opacity?: number;
+  /**
+   * How the points join.
+   *
+   * @default "strip"
+   */
+  readonly mode?: LineMode;
+  /**
+   * The width: CSS pixels, or world units with worldUnits.
+   *
+   * @default 1
+   * @range 0..
+   */
+  readonly width?: number;
+  /**
+   * Measure width in world units (a line that thins with distance) instead of CSS pixels (as wide at any distance).
+   *
+   * @default false
+   */
+  readonly worldUnits?: boolean;
+  /**
+   * Hidden behind nearer geometry, as three.js Material.depthTest; false draws it over the scene. Screen lines are never depth tested.
+   *
+   * @default true
+   */
+  readonly depthTest?: boolean;
+  /**
+   * Draw in screen space over the finished frame: points in CSS pixels, width in CSS pixels.
+   *
+   * @default false
+   */
+  readonly screen?: boolean;
+  /**
+   * Dashes, as three.js LineDashedMaterial: dashSize on, gapSize off, along the line from its first point.
+   *
+   * @default false
+   */
+  readonly dashed?: boolean;
+  /**
+   * A dash's length: world units (CSS pixels for screen lines).
+   *
+   * @default 3
+   * @range 0..
+   */
+  readonly dashSize?: number;
+  /**
+   * A gap's length.
+   *
+   * @default 1
+   * @range 0..
+   */
+  readonly gapSize?: number;
+}
+
+
+/**
+ * A point cloud drawn this frame only (immediate mode), as three.js Points with a PointsMaterial: a square per point facing the camera. Submit it every tick it should show (og.Points keeps a static set).
+ *
+ * A desc: every field may be omitted and then takes its documented default; `{}` is valid.
+ */
+export interface PointsDesc {
+  /**
+   * The positions: world, or with screen CSS pixels from the top left, y down.
+   *
+   * @default []
+   * @unit m (metres)
+   */
+  readonly points?: readonly Vector3[];
+  /**
+   * Per point linear colours; empty is `color` for all.
+   *
+   * @default []
+   */
+  readonly colors?: readonly Color[];
+  /**
+   * The linear colour.
+   *
+   * @default { r: 1, g: 1, b: 1 }
+   */
+  readonly color?: Color;
+  /**
+   * The alpha.
+   *
+   * @default 1
+   * @range 0..1
+   */
+  readonly opacity?: number;
+  /**
+   * The side of each square: world units with sizeAttenuation, else CSS pixels.
+   *
+   * @default 1
+   * @range 0..
+   */
+  readonly size?: number;
+  /**
+   * Size in world units, smaller with distance, as three.js PointsMaterial.sizeAttenuation; false keeps every point `size` CSS pixels.
+   *
+   * @default true
+   */
+  readonly sizeAttenuation?: boolean;
+  /**
+   * Hidden behind nearer geometry; false draws them over the scene.
+   *
+   * @default true
+   */
+  readonly depthTest?: boolean;
+  /**
+   * Draw in screen space over the finished frame, positions and size in CSS pixels.
+   *
+   * @default false
+   */
+  readonly screen?: boolean;
+}
+
+
+/**
+ * Draws a geometry's vertices as lines at the entity's MatrixWorld, every frame (three.js Line, LineSegments or LineLoop over a BufferGeometry): a static set of lines kept as data, a level's outline, a track, a constellation. The vertices are taken in order (the geometry's indices are not read), with its vertex colours times color.
+ *
+ * The value of the `Lines` component (token `og.Lines`).
+ */
+export interface Lines {
+  /** The vertices (og.render.bufferGeometry: an unindexed one of any count). */
+  geometry: Geometry;
   /** How the vertices join. */
   mode: LineMode;
   /**
@@ -7578,6 +8281,165 @@ export interface BakedScene {
 }
 
 
+// ── shapes ──────────────────────────────────────────────────────
+// Two-dimensional outlines in three.js's words: og.Shape and og.Path2 are three.js's Shape and Path, built by the same calls (moveTo, lineTo, quadraticCurveTo, bezierCurveTo, splineThru, arc, absarc, ellipse, absellipse, closePath) and flattened to points by getPoints, so a three.js outline is a paste. og.render.shapeGeometry, extrudeGeometry and sweepGeometry take them; only their points cross to the engine.
+// They are TypeScript values, not world state: make them in start or a command and let the geometry made from them be what the world keeps. Points come from basic arithmetic (no Math.sin), so they are the same on every host.
+// A prop of these parts belongs in an asset: an `.ogt` of `type model` names each part's geometry by its og.render call (`extrudeGeometry { shape { absarc 0 0 1 0 6.283185307179586 false } depth 0.2 }`), its shapes as og.Shape's calls one a line with `hole { }` blocks, places parts as mergeGeometries does (`position`, `quaternion`, `scale`, `mirror`, or several `at { }` blocks: one mesh drawn instanced), gives each a `material` and hangs it from a named `pivot` (a node). og cook builds it into the model blob a glTF cooks to (levels of detail, raycast BVH, nodes), refuses it past project.ogt's triangle and vertex budgets, and og dev re-cooks it on an edit; og.load.gltf and a scene's `model` line take it as any model. The og-game skill §18 has a whole example.
+
+/** A shape's holes, as three.js Shape.holes: an array; push a path to add a hole. */
+export interface PathList {
+  /** How many holes. */
+  readonly length: number;
+  /**
+   * Add a hole (Array.push).
+   *
+   * @param path The hole's outline, either winding.
+   */
+  push(path: Path2): number;
+}
+
+/**
+ * An outline of curves, as three.js Path: each call adds a curve from the current point (moveTo only moves it). Every method but getPoints returns the path, so calls chain.
+ */
+export interface Path2 {
+  /**
+   * Move the current point without drawing, as three.js Path.moveTo.
+   *
+   * @param x x.
+   * @param y y.
+   */
+  moveTo(x: number, y: number): this;
+  /**
+   * A straight line to (x, y), as three.js Path.lineTo.
+   *
+   * @param x x.
+   * @param y y.
+   */
+  lineTo(x: number, y: number): this;
+  /**
+   * A quadratic Bézier curve through one control point to (x, y), as three.js Path.quadraticCurveTo.
+   *
+   * @param cpX The control point's x.
+   * @param cpY The control point's y.
+   * @param x The end's x.
+   * @param y The end's y.
+   */
+  quadraticCurveTo(cpX: number, cpY: number, x: number, y: number): this;
+  /**
+   * A cubic Bézier curve through two control points to (x, y), as three.js Path.bezierCurveTo.
+   *
+   * @param cp1X The first control point's x.
+   * @param cp1Y The first control point's y.
+   * @param cp2X The second control point's x.
+   * @param cp2Y The second control point's y.
+   * @param x The end's x.
+   * @param y The end's y.
+   */
+  bezierCurveTo(cp1X: number, cp1Y: number, cp2X: number, cp2Y: number, x: number, y: number): this;
+  /**
+   * A Catmull-Rom spline from the current point through the points, as three.js Path.splineThru (a SplineCurve).
+   *
+   * @param points The points it passes through, in order.
+   */
+  splineThru(points: readonly Vector2[]): this;
+  /**
+   * A circular arc centred at (x, y) from the current point, as three.js Path.arc.
+   *
+   * @param x The centre's x, from the current point.
+   * @param y The centre's y, from the current point.
+   * @param radius The radius.
+   * @param startAngle Where it starts, from +x towards +y.
+   * @param endAngle Where it ends.
+   * @param clockwise Go clockwise. Default `false`.
+   */
+  arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, clockwise?: boolean): this;
+  /**
+   * A circular arc centred at (x, y), as three.js Path.absarc: a line joins it to the current point when they differ.
+   *
+   * @param x The centre's x.
+   * @param y The centre's y.
+   * @param radius The radius.
+   * @param startAngle Where it starts, from +x towards +y.
+   * @param endAngle Where it ends.
+   * @param clockwise Go clockwise. Default `false`.
+   */
+  absarc(x: number, y: number, radius: number, startAngle: number, endAngle: number, clockwise?: boolean): this;
+  /**
+   * An elliptic arc centred at (x, y) from the current point, as three.js Path.ellipse.
+   *
+   * @param x The centre's x, from the current point.
+   * @param y The centre's y, from the current point.
+   * @param xRadius The radius along x.
+   * @param yRadius The radius along y.
+   * @param startAngle Where it starts.
+   * @param endAngle Where it ends.
+   * @param clockwise Go clockwise. Default `false`.
+   * @param rotation The ellipse's turn round its centre. Default `0`.
+   */
+  ellipse(x: number, y: number, xRadius: number, yRadius: number, startAngle: number, endAngle: number, clockwise?: boolean, rotation?: number): this;
+  /**
+   * An elliptic arc centred at (x, y), as three.js Path.absellipse.
+   *
+   * @param x The centre's x.
+   * @param y The centre's y.
+   * @param xRadius The radius along x.
+   * @param yRadius The radius along y.
+   * @param startAngle Where it starts.
+   * @param endAngle Where it ends.
+   * @param clockwise Go clockwise. Default `false`.
+   * @param rotation The ellipse's turn round its centre. Default `0`.
+   */
+  absellipse(x: number, y: number, xRadius: number, yRadius: number, startAngle: number, endAngle: number, clockwise?: boolean, rotation?: number): this;
+  /**
+   * Start at the first point and draw lines through the rest, as three.js Path.setFromPoints.
+   *
+   * @param points The points.
+   */
+  setFromPoints(points: readonly Vector2[]): this;
+  /**
+   * A line back to the first point when the outline does not end there, as three.js CurvePath.closePath.
+   */
+  closePath(): this;
+  /**
+   * The outline as points, as three.js CurvePath.getPoints: each curve divided into `divisions` (an ellipse twice as many, a spline as many per point, a line one), repeated points dropped.
+   *
+   * @param divisions Divisions per curve. Default `12`.
+   */
+  getPoints(divisions?: number): readonly Vector2[];
+}
+
+/** An outline with holes, as three.js Shape. */
+export interface Shape extends Path2 {
+  /** The holes: `shape.holes.push(hole)`. */
+  readonly holes: PathList;
+  /**
+   * The outline's and the holes' points, as three.js Shape.extractPoints.
+   *
+   * @param divisions Divisions per curve. Default `12`.
+   */
+  extractPoints(divisions?: number): ShapePoints;
+}
+
+/** og.Path2: `new og.Path2(points?)`. */
+export interface Path2Class {
+  /**
+   * A path, through the points when given (setFromPoints).
+   *
+   * @param points Points to start from.
+   */
+  new(points?: readonly Vector2[] | null): Path2;
+}
+
+/** og.Shape: `new og.Shape(points?)`. */
+export interface ShapeClass {
+  /**
+   * A shape, through the points when given (setFromPoints).
+   *
+   * @param points Points to start from.
+   */
+  new(points?: readonly Vector2[] | null): Shape;
+}
+
 // ── load ────────────────────────────────────────────────────────
 // Asset loading from cooked output: `og cook` turns assets/ into cooked/ (.ogb blobs and the manifest cooked/.cook.ogt), and the runtime reads only cooked/.
 // Paths are asset ids: the path under assets/ (`models/ship.glb`, `scenes/main.ogt`); an `assets/` prefix is accepted. Every blob is checked against the manifest's type, schema version and cook stamp.
@@ -7645,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.
@@ -7818,7 +8698,7 @@ export interface Model {
    */
   visible: boolean;
   /**
-   * This instance's level of detail bias, multiplied with RenderSettings.lodBias: the cook simplifies every mesh into levels (a model's import settings, `model { lods 1 0.5 0.25 }` by default, the triangle fraction of each level; a glTF with MSFT_lod keeps its own levels), and the renderer draws the level its projected size calls for, with hysteresis so it does not flicker at the boundary. Above 1 keeps detail farther (a hero), below 1 drops it sooner (a crowd); 0 always draws the full mesh. dump_entity shows the level drawn.
+   * This instance's level of detail bias, multiplied with RenderSettings.lodBias: the cook simplifies every mesh into levels (a model's import settings, `model { lods 1 0.5 0.25 }` by default, the triangle fraction of each level; a glTF with MSFT_lod keeps its own levels) and measures each level's error against the full mesh, and the renderer draws the coarsest level whose error covers less than a pixel at the model's distance, with hysteresis so it does not flicker at the boundary. Above 1 keeps detail farther (a hero), below 1 drops it sooner (a crowd); 0 always draws the full mesh. dump_entity shows the level drawn.
    *
    * @default 1
    * @range 0..16
@@ -8198,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`).
  */
@@ -8207,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;
 }
 
 /**
@@ -11039,334 +11936,692 @@ export type IkSpace = "world" | "model";
 export declare function IkSpace(value?: IkSpace, options?: FieldOptions): FieldSpec<"IkSpace">;
 
 /**
- * A posed skeleton: the entity is drawn skinned by the joint palette og.anim writes each tick. The pose itself (every node's local transform) is world state kept by the `og.anim` state block.
+ * A posed skeleton: the entity is drawn skinned by the joint palette og.anim writes each tick. The pose itself (every node's local transform) is world state kept by the `og.anim` state block.
+ *
+ * The value of the `Skeleton` component (token `og.Skeleton`).
+ */
+export interface Skeleton {
+  /** The skeleton asset (og.load.animation's `skeleton`); 0 is none. */
+  asset: SkeletonAsset;
+  /**
+   * Which of the asset's skins the joint palette is for (glTF skin index).
+   *
+   * @range 0..
+   */
+  skin: number;
+  /**
+   * Root motion extraction: off (animate in place), planar (xz travel and yaw move og.Transform) or full.
+   */
+  rootMotion: RootMotion;
+  /**
+   * The joint whose motion is extracted (an index into the skin's joints; 0 is its first joint, usually the hips).
+   *
+   * @range 0..
+   */
+  rootJoint: number;
+  /**
+   * Written: the number of joints in the palette (0 until the first tick).
+   *
+   * @readonly written by the engine
+   */
+  readonly jointCount: number;
+}
+
+/**
+ * Plays one clip on a skeleton. Alone it poses the skeleton from its rest pose; with an og.AnimationGraph it plays over the graph's result with `weight`. Changing `clip` cross-fades from the previous one over `fade`; a clip change starts the new clip at 0 (or at `time` if the game wrote it in the same tick).
+ *
+ * The value of the `AnimationPlayer` component (token `og.AnimationPlayer`).
+ */
+export interface AnimationPlayer {
+  /** The clip asset; 0 plays nothing. */
+  clip: ClipAsset;
+  /**
+   * The playback position; written every tick, set it to seek (no markers fire across a seek).
+   *
+   * @range 0..
+   * @unit s (seconds of simulation time)
+   */
+  time: number;
+  /**
+   * Playback rate (1 = as authored, negative plays backwards).
+   *
+   * @default 1
+   * @range -10..10
+   * @tunable
+   */
+  speed: number;
+  /**
+   * Wrap at the end of the clip; otherwise hold the last frame and set `finished`.
+   *
+   * @default true
+   */
+  loop: boolean;
+  /**
+   * How much of the pose this player decides (0 = none, 1 = all).
+   *
+   * @default 1
+   * @range 0..1
+   * @tunable
+   */
+  weight: number;
+  /**
+   * Cross-fade duration when `clip` changes.
+   *
+   * @default 0.2
+   * @range 0..10
+   * @unit s (seconds of simulation time)
+   * @tunable
+   */
+  fade: number;
+  /**
+   * Stepped playback: each pose is held for 1/stepFps seconds, the clip sampled at its time floored to that step (12 is stop motion "on twos", 8 on threes), the same on every tick rate; 0 samples every tick. `time`, markers and root motion stay continuous; a one-shot still ends on its last frame.
+   *
+   * @range 0..60
+   * @tunable
+   */
+  stepFps: number;
+  /**
+   * Written: a non-looping clip reached its end.
+   *
+   * @readonly written by the engine
+   */
+  readonly finished: boolean;
+}
+
+/**
+ * Runs a blend-tree graph (og.anim.graph) on a skeleton: its layers' state machines pick motions by the parameters p0...p7, which the graph names in `param` order (`param speed` is p0, the next `param` is p1, ...).
+ *
+ * The value of the `AnimationGraph` component (token `og.AnimationGraph`).
+ */
+export interface AnimationGraph {
+  /** The graph asset; 0 is none. */
+  asset: GraphAsset;
+  /**
+   * How much of the pose the graph decides over the rest pose.
+   *
+   * @default 1
+   * @range 0..1
+   * @tunable
+   */
+  weight: number;
+  /**
+   * A playback-rate multiplier for every layer.
+   *
+   * @default 1
+   * @range 0..10
+   * @tunable
+   */
+  speed: number;
+  /**
+   * Parameter 0 (the graph's first `param`).
+   *
+   * @tunable
+   */
+  p0: number;
+  /**
+   * Parameter 1.
+   *
+   * @tunable
+   */
+  p1: number;
+  /**
+   * Parameter 2.
+   *
+   * @tunable
+   */
+  p2: number;
+  /**
+   * Parameter 3.
+   *
+   * @tunable
+   */
+  p3: number;
+  /**
+   * Parameter 4.
+   *
+   * @tunable
+   */
+  p4: number;
+  /**
+   * Parameter 5.
+   *
+   * @tunable
+   */
+  p5: number;
+  /**
+   * Parameter 6.
+   *
+   * @tunable
+   */
+  p6: number;
+  /**
+   * Parameter 7.
+   *
+   * @tunable
+   */
+  p7: number;
+  /**
+   * Written: the base layer's current state (its index in the graph file).
+   *
+   * @readonly written by the engine
+   */
+  readonly state: number;
+  /**
+   * Written: seconds since the base layer entered `state`.
+   *
+   * @unit s (seconds of simulation time)
+   * @readonly written by the engine
+   */
+  readonly stateTime: number;
+}
+
+/**
+ * Morph-target weights of the skeleton entity's mesh, in the order of the glTF mesh's targets. With `source` clips the playing clips' weight channels write them; with `component` game code does.
+ *
+ * The value of the `Blendshapes` component (token `og.Blendshapes`).
+ */
+export interface Blendshapes {
+  /**
+   * Who decides the weights: component (game code writes w0...w7) or clips (the animation writes them).
+   */
+  source: BlendshapeSource;
+  /**
+   * The glTF mesh index whose targets the weights drive (0 is the first mesh).
+   *
+   * @range 0..
+   */
+  mesh: number;
+  /**
+   * Weight of target 0.
+   *
+   * @range -1..2
+   * @tunable
+   */
+  w0: number;
+  /**
+   * Weight of target 1.
+   *
+   * @range -1..2
+   * @tunable
+   */
+  w1: number;
+  /**
+   * Weight of target 2.
+   *
+   * @range -1..2
+   * @tunable
+   */
+  w2: number;
+  /**
+   * Weight of target 3.
+   *
+   * @range -1..2
+   * @tunable
+   */
+  w3: number;
+  /**
+   * Weight of target 4.
+   *
+   * @range -1..2
+   * @tunable
+   */
+  w4: number;
+  /**
+   * Weight of target 5.
+   *
+   * @range -1..2
+   * @tunable
+   */
+  w5: number;
+  /**
+   * Weight of target 6.
+   *
+   * @range -1..2
+   * @tunable
+   */
+  w6: number;
+  /**
+   * Weight of target 7.
+   *
+   * @range -1..2
+   * @tunable
+   */
+  w7: number;
+}
+
+/**
+ * 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.
  *
- * The value of the `Skeleton` component (token `og.Skeleton`).
+ * The value of the `IkChain` component (token `og.IkChain`).
  */
-export interface Skeleton {
-  /** The skeleton asset (og.load.animation's `skeleton`); 0 is none. */
-  asset: SkeletonAsset;
+export interface IkChain {
+  /** The entity with the og.Skeleton this chain bends. */
+  skeleton: Entity;
   /**
-   * Which of the asset's skins the joint palette is for (glTF skin index).
+   * The end joint (an index into the skin's joints): the foot or the hand.
    *
    * @range 0..
    */
-  skin: number;
+  tip: number;
   /**
-   * Root motion extraction: off (animate in place), planar (xz travel and yaw move og.Transform) or full.
+   * How many bones above the tip turn (two-bone always uses 2).
+   *
+   * @default 2
+   * @range 1..32
    */
-  rootMotion: RootMotion;
+  bones: number;
+  /** twoBone (analytic, with a pole) or fabrik (iterative, any length). */
+  solver: IkSolver;
   /**
-   * The joint whose motion is extracted (an index into the skin's joints; 0 is its first joint, usually the hips).
+   * Where the tip should be, in `space`: for `world`, the frame of the skeleton entity's og.Transform (its parent's frame when it has a parent, not true world).
+   *
+   * @unit m (metres)
+   */
+  target: Vector3;
+  /**
+   * A point the middle joint bends towards (two-bone); the zero vector keeps the animated bend.
+   *
+   * @unit m (metres)
+   */
+  pole: Vector3;
+  /**
+   * What `target` and `pole` are relative to: world (the frame the skeleton entity's og.Transform is in, so its parent's frame for a child entity, not true world) or model.
+   */
+  space: IkSpace;
+  /**
+   * How much of the solved rotation is applied (0 = the animated pose, 1 = fully solved).
+   *
+   * @default 1
+   * @range 0..1
+   * @tunable
+   */
+  weight: number;
+  /**
+   * FABRIK iterations at most.
+   *
+   * @default 10
+   * @range 1..64
+   */
+  iterations: number;
+  /**
+   * The tip distance (model units) at which the target counts as reached.
    *
+   * @default 0.001
    * @range 0..
+   * @unit m (metres)
    */
-  rootJoint: number;
+  tolerance: number;
   /**
-   * Written: the number of joints in the palette (0 until the first tick).
+   * Written: the tip is within `tolerance` of the target after solving.
    *
    * @readonly written by the engine
    */
-  readonly jointCount: number;
+  readonly reached: boolean;
+  /**
+   * Written: the tip's distance from the target after solving, in model units.
+   *
+   * @unit m (metres)
+   * @readonly written by the engine
+   */
+  readonly error: number;
 }
 
 /**
- * Plays one clip on a skeleton. Alone it poses the skeleton from its rest pose; with an og.AnimationGraph it plays over the graph's result with `weight`. Changing `clip` cross-fades from the previous one over `fade`; a clip change starts the new clip at 0 (or at `time` if the game wrote it in the same tick).
+ * 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 `AnimationPlayer` component (token `og.AnimationPlayer`).
+ * The value of the `LookAt` component (token `og.LookAt`).
  */
-export interface AnimationPlayer {
-  /** The clip asset; 0 plays nothing. */
-  clip: ClipAsset;
+export interface LookAt {
+  /** The entity with the og.Skeleton this constraint turns. */
+  skeleton: Entity;
   /**
-   * The playback position; written every tick, set it to seek (no markers fire across a seek).
+   * The joint that aims (an index into the skin's joints): the head, an eye.
    *
    * @range 0..
-   * @unit s (seconds of simulation time)
    */
-  time: number;
+  joint: number;
   /**
-   * Playback rate (1 = as authored, negative plays backwards).
+   * 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 -10..10
-   * @tunable
+   * @range 1..8
    */
-  speed: number;
+  bones: number;
   /**
-   * Wrap at the end of the clip; otherwise hold the last frame and set `finished`.
+   * The point to look at, in `space`.
    *
-   * @default true
+   * @unit m (metres)
    */
-  loop: boolean;
+  target: Vector3;
   /**
-   * How much of the pose this player decides (0 = none, 1 = all).
+   * 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 1
-   * @range 0..1
+   * @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
    */
-  weight: number;
+  maxYaw: number;
   /**
-   * Cross-fade duration when `clip` changes.
+   * The largest turn towards or away from `upAxis`, from the animated forward.
    *
-   * @default 0.2
-   * @range 0..10
-   * @unit s (seconds of simulation time)
+   * @default 1.5708
+   * @range 0..1.5708
+   * @unit rad (radians)
    * @tunable
    */
-  fade: number;
+  maxPitch: number;
   /**
-   * Stepped playback: each pose is held for 1/stepFps seconds, the clip sampled at its time floored to that step (12 is stop motion "on twos", 8 on threes), the same on every tick rate; 0 samples every tick. `time`, markers and root motion stay continuous; a one-shot still ends on its last frame.
+   * How much of the turn is applied (0 = the animated pose, 1 = aimed).
    *
-   * @range 0..60
+   * @default 1
+   * @range 0..1
    * @tunable
    */
-  stepFps: number;
+  weight: number;
   /**
-   * Written: a non-looping clip reached its end.
+   * Written: the target lay outside maxYaw or maxPitch, so the joint aims at the nearest direction inside them.
    *
    * @readonly written by the engine
    */
-  readonly finished: boolean;
+  readonly clamped: boolean;
 }
 
 /**
- * Runs a blend-tree graph (og.anim.graph) on a skeleton: its layers' state machines pick motions by the parameters p0...p7, which the graph names in `param` order (`param speed` is p0, the next `param` is p1, ...).
+ * 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 `AnimationGraph` component (token `og.AnimationGraph`).
+ * The value of the `JointLimit` component (token `og.JointLimit`).
  */
-export interface AnimationGraph {
-  /** The graph asset; 0 is none. */
-  asset: GraphAsset;
-  /**
-   * How much of the pose the graph decides over the rest pose.
-   *
-   * @default 1
-   * @range 0..1
-   * @tunable
-   */
-  weight: number;
+export interface JointLimit {
+  /** The entity with the og.Skeleton whose joint this limits. */
+  skeleton: Entity;
   /**
-   * A playback-rate multiplier for every layer.
+   * The limited joint (an index into the skin's joints).
    *
-   * @default 1
-   * @range 0..10
-   * @tunable
+   * @range 0..
    */
-  speed: number;
+  joint: number;
   /**
-   * Parameter 0 (the graph's first `param`).
+   * The twist axis in the joint's rest frame: along the bone for a ball joint, along the hinge for a hinge.
    *
-   * @tunable
+   * @default { x: 0, y: 1, z: 0 }
    */
-  p0: number;
+  axis: Vector3;
   /**
-   * Parameter 1.
+   * 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
    */
-  p1: number;
+  swing: number;
   /**
-   * Parameter 2.
+   * 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
    */
-  p2: number;
+  twistMin: number;
   /**
-   * Parameter 3.
+   * 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
    */
-  p3: number;
+  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;
   /**
-   * Parameter 4.
+   * The foot joint (an index into the skin's joints); the two bones above it are the leg that bends.
    *
-   * @tunable
+   * @range 0..
    */
-  p4: number;
+  foot: number;
   /**
-   * Parameter 5.
+   * How much of the lock is applied (0 = the animated foot, 1 = held).
    *
+   * @default 1
+   * @range 0..1
    * @tunable
    */
-  p5: number;
+  weight: number;
   /**
-   * Parameter 6.
+   * 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
    */
-  p6: number;
+  release: number;
   /**
-   * Parameter 7.
+   * 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
    */
-  p7: number;
+  maxDistance: number;
   /**
-   * Written: the base layer's current state (its index in the graph file).
+   * Written: the playing clips plant the foot this tick.
    *
    * @readonly written by the engine
    */
-  readonly state: number;
+  readonly planted: boolean;
   /**
-   * Written: seconds since the base layer entered `state`.
+   * Written: the foot is held at its lock this tick.
    *
-   * @unit s (seconds of simulation time)
    * @readonly written by the engine
    */
-  readonly stateTime: number;
+  readonly locked: boolean;
 }
 
 /**
- * Morph-target weights of the skeleton entity's mesh, in the order of the glTF mesh's targets. With `source` clips the playing clips' weight channels write them; with `component` game code does.
+ * 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.
  *
- * The value of the `Blendshapes` component (token `og.Blendshapes`).
+ * 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 interface Blendshapes {
+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;
   /**
-   * Who decides the weights: component (game code writes w0...w7) or clips (the animation writes them).
+   * The chain's last joint (an index into the skin's joints): the tip of a tail, an ear.
+   *
+   * @range 0..
    */
-  source: BlendshapeSource;
+  joint: number;
   /**
-   * The glTF mesh index whose targets the weights drive (0 is the first mesh).
+   * How many joints swing: `joint` and its parents (1 is the joint alone).
    *
-   * @range 0..
+   * @default 1
+   * @range 1..16
    */
-  mesh: number;
+  bones: number;
   /**
-   * Weight of target 0.
+   * How fast a tail springs back to its animated place: the spring's natural frequency (0: no spring, it only hangs and swings).
    *
-   * @range -1..2
+   * @default 3
+   * @range 0..30
+   * @unit hz (ticks or cycles per second)
    * @tunable
    */
-  w0: number;
+  frequency: number;
   /**
-   * Weight of target 1.
+   * The damping ratio: 0 swings on, 1 settles without overshooting (critical damping).
    *
-   * @range -1..2
+   * @default 0.3
+   * @range 0..2
    * @tunable
    */
-  w1: number;
+  damping: number;
   /**
-   * Weight of target 2.
+   * 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).
    *
-   * @range -1..2
+   * @default 1
+   * @range 0..4
    * @tunable
    */
-  w2: number;
+  tipFrequency: number;
   /**
-   * Weight of target 3.
+   * The last joint's damping ratio as a multiple of `damping`, the joints between in proportion along the chain (1: every joint alike).
    *
-   * @range -1..2
+   * @default 1
+   * @range 0..4
    * @tunable
    */
-  w3: number;
+  tipDamping: number;
   /**
-   * Weight of target 4.
+   * An acceleration on every tail, in `space` (three-vrm's gravityDir times gravityPower): (0, -9.8, 0) makes a chain droop.
    *
-   * @range -1..2
+   * @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
    */
-  w4: number;
+  weight: number;
   /**
-   * Weight of target 5.
+   * The tails' radius against og.SpringCollider (three-vrm's hitRadius): a tail stays this far outside every collider it meets (0: a point).
    *
-   * @range -1..2
+   * @range 0..
+   * @unit m (metres)
    * @tunable
    */
-  w5: number;
+  radius: number;
   /**
-   * Weight of target 6.
+   * The og.SpringCollider layers the tails are pushed out of, as bits: a collider on the same skeleton counts when its `layers` meet these.
    *
-   * @range -1..2
-   * @tunable
+   * @default 4294967295
    */
-  w6: number;
+  colliders: number;
   /**
-   * Weight of target 7.
+   * Written: the farthest a tail is from its animated place this tick.
    *
-   * @range -1..2
-   * @tunable
+   * @unit m (metres)
+   * @readonly written by the engine
    */
-  w7: number;
+  readonly lag: number;
 }
 
 /**
- * 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.
+ * 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.
  *
- * The value of the `IkChain` component (token `og.IkChain`).
+ * 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 interface IkChain {
-  /** The entity with the og.Skeleton this chain bends. */
+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 end joint (an index into the skin's joints): the foot or the hand.
+   * The joint the collider rides on (an index into the skin's joints).
    *
    * @range 0..
    */
-  tip: number;
-  /**
-   * How many bones above the tip turn (two-bone always uses 2).
-   *
-   * @default 2
-   * @range 1..32
-   */
-  bones: number;
-  /** twoBone (analytic, with a pole) or fabrik (iterative, any length). */
-  solver: IkSolver;
+  joint: number;
+  /** A sphere about `offset`, or a capsule from `offset` to `tail`. */
+  shape: SpringColliderShape;
   /**
-   * Where the tip should be, in `space`: for `world`, the frame of the skeleton entity's og.Transform (its parent's frame when it has a parent, not true world).
+   * The sphere's centre, or the capsule's first end, in the joint's frame.
    *
    * @unit m (metres)
    */
-  target: Vector3;
+  offset: Vector3;
   /**
-   * A point the middle joint bends towards (two-bone); the zero vector keeps the animated bend.
+   * The capsule's other end, in the joint's frame (a sphere ignores it).
    *
    * @unit m (metres)
    */
-  pole: Vector3;
-  /**
-   * What `target` and `pole` are relative to: world (the frame the skeleton entity's og.Transform is in, so its parent's frame for a child entity, not true world) or model.
-   */
-  space: IkSpace;
-  /**
-   * How much of the solved rotation is applied (0 = the animated pose, 1 = fully solved).
-   *
-   * @default 1
-   * @range 0..1
-   * @tunable
-   */
-  weight: number;
-  /**
-   * FABRIK iterations at most.
-   *
-   * @default 10
-   * @range 1..64
-   */
-  iterations: number;
+  tail: Vector3;
   /**
-   * The tip distance (model units) at which the target counts as reached.
+   * The radius, in metres of the skeleton's model space (the joint's own scale does not apply).
    *
-   * @default 0.001
+   * @default 0.1
    * @range 0..
    * @unit m (metres)
+   * @tunable
    */
-  tolerance: number;
-  /**
-   * Written: the tip is within `tolerance` of the target after solving.
-   *
-   * @readonly written by the engine
-   */
-  readonly reached: boolean;
+  radius: number;
   /**
-   * Written: the tip's distance from the target after solving, in model units.
+   * The layers this collider is on, as bits (a spring bone's `colliders` picks them).
    *
-   * @unit m (metres)
-   * @readonly written by the engine
+   * @default 1
    */
-  readonly error: number;
+  layers: number;
 }
 
 /**
@@ -11443,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. */
@@ -11535,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.
  *
@@ -11734,6 +13019,12 @@ export interface Skeleton2D {
    * The sprite layer it draws in, sorted with the sprites there (after them when they share the layer).
    */
   layer: number;
+  /**
+   * The skin it wears: an index into Rig2DInfo.skins (0 is the rig's default; `rig.skins.indexOf("armor")` finds one by name). A skin shows its own attachment wherever the setup pose or a clip shows the default's; a slot the skin leaves alone shows the default's. Change it any tick: the pose is drawn from it.
+   *
+   * @range 0..
+   */
+  skin: number;
   /**
    * Written: a clip that does not loop reached its end (or its start, played backwards).
    *
@@ -11743,7 +13034,7 @@ export interface Skeleton2D {
 }
 
 /**
- * A 2D skeleton's clip passed one of its events (`event 0.2 "step"` in the rig) in the last tick: footsteps, the frame a swing lands. Read in the tick after, like every event; a clip started at 0 fires its events at 0, a looping clip fires each once per pass.
+ * A 2D skeleton's clip, or the clip a child armature in one of its slots plays, passed one of its events (`event 0.2 "step"` in the rig) in the last tick: footsteps, the frame a swing lands. Read in the tick after, like every event; a clip started at 0 fires its events at 0, a looping clip fires each once per pass.
  *
  * The payload of the `Skeleton2DEvent` event (token `og.Skeleton2DEvent`).
  */
@@ -11760,6 +13051,10 @@ export interface Skeleton2DEvent {
    * @unit s (seconds of simulation time)
    */
   readonly time: number;
+  /**
+   * Empty for the skeleton's own clip; for an event of a child armature shown in one of its slots, that armature's name (`clip` and `time` are then the child's clip and its time): a flame's crackle apart from the keeper's footsteps (at most 63 bytes).
+   */
+  readonly armature: string;
 }
 
 /**
@@ -11847,6 +13142,10 @@ export interface Rig2DInfo {
   readonly slots: readonly string[];
   /** The IK constraints' names: an index here is IkTarget2D.constraint. */
   readonly constraints: readonly string[];
+  /**
+   * Its skins' names, `default` (the rig's own attachments) first: an index here is Skeleton2D.skin.
+   */
+  readonly skins: readonly string[];
   /** Its clips, in file order. */
   readonly clips: readonly Rig2DClipInfo[];
 }
@@ -12359,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;
@@ -12377,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.
@@ -12395,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.
@@ -12536,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;
 }
 
 /**
@@ -12552,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;
 }
 
 /**
@@ -12640,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;
 }
 
 /**
@@ -12936,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;
 }
@@ -16908,14 +18315,6 @@ export interface ScreenTransitionResult {
 
 
 
-/**
- * A graphics quality preset.
- * - `"medium"`: Medium.
- * - `"low"`: Low: the fewest effects.
- * - `"high"`: High: every effect.
- */
-export type GraphicsQuality = "medium" | "low" | "high";
-
 /**
  * A template's action, by its id (a menu item, `buy:<item>`, `share`).
  *
@@ -17219,6 +18618,12 @@ export interface SettingsDesc {
    * @default null
    */
   readonly onSave?: SettingsChanged | null;
+  /**
+   * The world the graphics preset is drawn in: when the player picks another preset the screen calls og.render.applyQuality(world, preset) before onChange. Null leaves applying it to the game. Inside a system, the system declares RenderSettings among its writes.
+   *
+   * @default null
+   */
+  readonly world?: World | null;
   /**
    * The dialog's title. Every word of the screen is a field with its English default: a localised game passes its string table's (og.i18n.t).
    *
@@ -20012,7 +21417,7 @@ export interface EngineProbe extends RuntimeProbe {
 
 // ── terrain ─────────────────────────────────────────────────────
 // Terrain (phase 2): a height field over a rectangle, cooked by `og cook` from a `type terrain` .ogt (a 16-bit grey PNG or an EXR heightmap, an optional control map, up to four layered materials with slope and altitude rules, their maps separate textures or layers of two texture arrays: `layers` and `layerNormals` with each layer's `albedoLayer` and `normalLayer`, two sampled textures instead of up to eight) into tiles; drawn as a geometry clipmap around the camera (nested levels by distance, no cracks) that casts and receives shadows under the fog; collided with as a height field; baked into navmeshes by a navmesh file's `terrain` entry.
-// Load it with og.terrain.load, then place it: an og.Terrain on an entity draws it placed by the entity's world transform (centred on its position, turned and scaled with it), and an og.Collider of shape SHAPE_HEIGHTFIELD naming the TerrainInfo's geometry makes it solid. og.TerrainScatter grows grass, flowers or stones over a layer near the camera. og.terrain.sample answers the surface's height and normal anywhere (pass it the entity's position, quaternion and scale); og.terrain.edit raises, lowers, flattens, smooths or paints it at runtime, and og.terrain.setLayer retunes a layer. Edits are world state: a snapshot keeps them, the world hash covers them, and a restore brings the ground back as it was (rebuilt from the cook with the restored edits replayed, for the renderer, physics and sample alike).
+// Load it with og.terrain.load, then place it: an og.Terrain on an entity draws it placed by the entity's world transform (centred on its position, turned and scaled with it), and an og.Collider of shape SHAPE_HEIGHTFIELD naming the TerrainInfo's geometry makes it solid. og.TerrainScatter grows grass, flowers or stones over a layer near the camera. og.terrain.sample answers the surface's height and normal anywhere (pass it the entity's position, quaternion and scale); og.terrain.edit raises, lowers, flattens, smooths or paints it at runtime, and og.terrain.setLayer retunes a layer. Terrain is 3D: the 2D profile's publish and lanes modules leave it out (RenderCapabilities.world3d is false), where every call here answers a refusal naming that field. Edits are world state: a snapshot keeps them, the world hash covers them, and a restore brings the ground back as it was (rebuilt from the cook with the restored edits replayed, for the renderer, physics and sample alike).
 // Its tiles stream (phase 3): the cook stores the field as a pyramid of tiles, each compressed on its own, and every frame the renderer keeps on the GPU only the tiles the camera's clipmap wants, within each terrain's tile budget (16 MiB by default), decoded off the frame (a worker thread natively, the browser's DecompressionStream on the Web) a few at a time, the most needed first; until a tile arrives its area draws from the coarser level that holds it, then fades in. Nothing a tick reads depends on which tiles are resident (collision and og.terrain.sample read the whole field), so a run's world hash is the same streamed or not. The probe's `terrain_stream:resident` decodes every wanted tile before each frame instead (`terrain_stream:stream[:<MiB>]` streams again, within that budget), and `dump_stream`'s `terrain` gives the tiles resident, waiting, decoding and cached.
 
 /**
@@ -20183,6 +21588,12 @@ export interface TerrainInfo {
   readonly collision: boolean;
   /** Its terrain file's `castShadows`. */
   readonly castShadows: boolean;
+  /**
+   * A generated terrain's sea level (`generate { sea <m> }`) above its entity: place an og.Water there, the terrain's size; null without a sea.
+   *
+   * @unit m (metres)
+   */
+  readonly seaLevel: number | null;
 }
 
 /**
@@ -21413,9 +22824,9 @@ export declare namespace og {
   /** A cone of light along the entity's local -Z, as three.js SpotLight. */
   const SpotLight: ComponentType<{ readonly color: FieldSpec<"Color">; readonly intensity: FieldSpec<"f32">; readonly distance: FieldSpec<"f32">; readonly angle: FieldSpec<"f32">; readonly penumbra: FieldSpec<"f32">; readonly castShadow: FieldSpec<"bool">; readonly cookie: FieldSpec<"Texture"> }, SpotLight>;
   /**
-   * The frame's look after lighting: environment light, sky, bloom, exposure metering and tone mapping. Read after each tick; it never feeds back into the simulation. Camera.exposure is the manual exposure.
+   * The frame's look after lighting: environment light, sky, bloom, exposure metering and tone mapping, and what the frame may cost: the quality fields (rectShadows to msaaSamples) that og.render.applyQuality sets from a graphics preset. Read after each tick; it never feeds back into the simulation. Camera.exposure is the manual exposure.
    */
-  const RenderSettings: ResourceType<{ readonly environmentIntensity: FieldSpec<"f32">; readonly sky: FieldSpec<"bool">; readonly bloom: FieldSpec<"bool">; readonly bloomThreshold: FieldSpec<"f32">; readonly bloomKnee: FieldSpec<"f32">; readonly bloomIntensity: FieldSpec<"f32">; readonly autoExposure: FieldSpec<"bool">; readonly adaptSpeedUp: FieldSpec<"f32">; readonly adaptSpeedDown: FieldSpec<"f32">; readonly toneMapped: FieldSpec<"bool">; readonly toneMapping: FieldSpec<"ToneMapping">; readonly exposure: FieldSpec<"f32">; readonly decalAtlas: FieldSpec<"Texture">; readonly lodBias: FieldSpec<"f32">; readonly bakedLighting: FieldSpec<"bool"> }, RenderSettings>;
+  const RenderSettings: ResourceType<{ readonly environmentIntensity: FieldSpec<"f32">; readonly sky: FieldSpec<"bool">; readonly bloom: FieldSpec<"bool">; readonly bloomThreshold: FieldSpec<"f32">; readonly bloomKnee: FieldSpec<"f32">; readonly bloomIntensity: FieldSpec<"f32">; readonly autoExposure: FieldSpec<"bool">; readonly adaptSpeedUp: FieldSpec<"f32">; readonly adaptSpeedDown: FieldSpec<"f32">; readonly toneMapped: FieldSpec<"bool">; readonly toneMapping: FieldSpec<"ToneMapping">; readonly exposure: FieldSpec<"f32">; readonly decalAtlas: FieldSpec<"Texture">; readonly lodBias: FieldSpec<"f32">; readonly bakedLighting: FieldSpec<"bool">; readonly quality: FieldSpec<"QualityPreset">; readonly rectShadows: FieldSpec<"bool">; readonly shadowedLights: FieldSpec<"u32">; readonly shadowMapScale: FieldSpec<"f32">; readonly volumetricFog: FieldSpec<"bool">; readonly softParticles: FieldSpec<"bool">; readonly screenSpaceReflections: FieldSpec<"bool">; readonly ambientOcclusion: FieldSpec<"bool">; readonly msaaSamples: FieldSpec<"u32"> }, RenderSettings>;
   /**
    * Image-based light from a cooked HDR environment map instead of the sky, as three.js scene.environment, and the map behind the scene, as scene.background = the environment. Load the map with og.load.environment: the cook has already prefiltered it (GGX levels for reflections from mirror to rough, harmonics for the diffuse light), so setting it costs a few copy passes on any tier, WebGL2 included. Without a map the sky lights the scene as before (og.Sky, a DayNight, or the built-in one). Read after each tick; it never feeds back into the simulation.
    */
@@ -21424,7 +22835,7 @@ export declare namespace og {
    * The post stack beyond RenderSettings' bloom, exposure and tone mapping, and camera shake. Every effect is off by default (its switch false or its amount 0) and then costs nothing: no pass is recorded. Read after each tick; it never feeds back into the simulation.
    * Screen-space ambient occlusion, outlines, depth of field, motion blur and god rays run a depth-normal prepass, turned on with them. Grading, vignette, aberration, grain and the flash apply to the display colour after tone mapping; the UI and screen-space sprites (the overlay) come after all of it.
    */
-  const PostEffects: ResourceType<{ readonly ao: FieldSpec<"bool">; readonly aoRadius: FieldSpec<"f32">; readonly aoIntensity: FieldSpec<"f32">; readonly aoMethod: FieldSpec<"AoMethod">; readonly outline: FieldSpec<"bool">; readonly outlineColor: FieldSpec<"Color">; readonly outlineWidth: FieldSpec<"f32">; readonly outlineDepthThreshold: FieldSpec<"f32">; readonly outlineNormalThreshold: FieldSpec<"f32">; readonly depthOfField: FieldSpec<"bool">; readonly dofFocusDistance: FieldSpec<"f32">; readonly dofFocusRange: FieldSpec<"f32">; readonly dofMaxBlur: FieldSpec<"f32">; readonly dofFalloff: FieldSpec<"f32">; readonly dofQuality: FieldSpec<"DofQuality">; readonly motionBlur: FieldSpec<"bool">; readonly motionBlurShutter: FieldSpec<"f32">; readonly motionBlurSamples: FieldSpec<"u32">; readonly motionBlurMaxPixels: FieldSpec<"f32">; readonly godRays: FieldSpec<"bool">; readonly godRaysIntensity: FieldSpec<"f32">; readonly godRaysDecay: FieldSpec<"f32">; readonly godRaysDensity: FieldSpec<"f32">; readonly godRaysTint: FieldSpec<"Color">; readonly godRaysSamples: FieldSpec<"u32">; readonly godRaysThreshold: FieldSpec<"f32">; readonly glow: FieldSpec<"bool">; readonly glowIntensity: FieldSpec<"f32">; readonly lut: FieldSpec<"Lut">; readonly lutIntensity: FieldSpec<"f32">; readonly vignette: FieldSpec<"bool">; readonly vignetteIntensity: FieldSpec<"f32">; readonly vignetteRadius: FieldSpec<"f32">; readonly vignetteSmoothness: FieldSpec<"f32">; readonly vignetteColor: FieldSpec<"Color">; readonly chromaticAberration: FieldSpec<"f32">; readonly filmGrain: FieldSpec<"f32">; readonly filmGrainSize: FieldSpec<"f32">; readonly flash: FieldSpec<"f32">; readonly flashColor: FieldSpec<"Color">; readonly shakeTrauma: FieldSpec<"f32">; readonly shakeMaxOffset: FieldSpec<"f32">; readonly shakeMaxRoll: FieldSpec<"f32">; readonly shakeFrequency: FieldSpec<"f32">; readonly shakeSeed: FieldSpec<"u32">; readonly ssr: FieldSpec<"bool">; readonly ssrMaxDistance: FieldSpec<"f32">; readonly ssrThickness: FieldSpec<"f32">; readonly ssrSteps: FieldSpec<"u32">; readonly ssrFade: FieldSpec<"f32">; readonly ssrIntensity: FieldSpec<"f32">; readonly custom1: FieldSpec<"Post">; readonly custom2: FieldSpec<"Post">; readonly custom3: FieldSpec<"Post">; readonly custom4: FieldSpec<"Post">; readonly custom5: FieldSpec<"Post">; readonly custom6: FieldSpec<"Post">; readonly custom7: FieldSpec<"Post">; readonly custom8: FieldSpec<"Post"> }, PostEffects>;
+  const PostEffects: ResourceType<{ readonly ao: FieldSpec<"bool">; readonly aoRadius: FieldSpec<"f32">; readonly aoIntensity: FieldSpec<"f32">; readonly aoMethod: FieldSpec<"AoMethod">; readonly outline: FieldSpec<"bool">; readonly outlineColor: FieldSpec<"Color">; readonly outlineWidth: FieldSpec<"f32">; readonly outlineDepthThreshold: FieldSpec<"f32">; readonly outlineNormalThreshold: FieldSpec<"f32">; readonly depthOfField: FieldSpec<"bool">; readonly dofFocusDistance: FieldSpec<"f32">; readonly dofFocusRange: FieldSpec<"f32">; readonly dofMaxBlur: FieldSpec<"f32">; readonly dofFalloff: FieldSpec<"f32">; readonly dofQuality: FieldSpec<"DofQuality">; readonly motionBlur: FieldSpec<"bool">; readonly motionBlurShutter: FieldSpec<"f32">; readonly motionBlurSamples: FieldSpec<"u32">; readonly motionBlurMaxPixels: FieldSpec<"f32">; readonly godRays: FieldSpec<"bool">; readonly godRaysIntensity: FieldSpec<"f32">; readonly godRaysDecay: FieldSpec<"f32">; readonly godRaysDensity: FieldSpec<"f32">; readonly godRaysTint: FieldSpec<"Color">; readonly godRaysSamples: FieldSpec<"u32">; readonly godRaysThreshold: FieldSpec<"f32">; readonly glow: FieldSpec<"bool">; readonly glowIntensity: FieldSpec<"f32">; readonly lut: FieldSpec<"Lut">; readonly lutIntensity: FieldSpec<"f32">; readonly vignette: FieldSpec<"bool">; readonly vignetteIntensity: FieldSpec<"f32">; readonly vignetteRadius: FieldSpec<"f32">; readonly vignetteSmoothness: FieldSpec<"f32">; readonly vignetteColor: FieldSpec<"Color">; readonly chromaticAberration: FieldSpec<"f32">; readonly filmGrain: FieldSpec<"f32">; readonly filmGrainSize: FieldSpec<"f32">; readonly flash: FieldSpec<"f32">; readonly flashColor: FieldSpec<"Color">; readonly shakeTrauma: FieldSpec<"f32">; readonly shakeMaxOffset: FieldSpec<"f32">; readonly shakeMaxRoll: FieldSpec<"f32">; readonly shakeFrequency: FieldSpec<"f32">; readonly shakeSeed: FieldSpec<"u32">; readonly ssr: FieldSpec<"bool">; readonly ssrMaxDistance: FieldSpec<"f32">; readonly ssrThickness: FieldSpec<"f32">; readonly ssrSteps: FieldSpec<"u32">; readonly ssrFade: FieldSpec<"f32">; readonly ssrIntensity: FieldSpec<"f32">; readonly custom: ListSpec<"Post"> }, PostEffects>;
   /**
    * Stylisation primitives that move the frame away from the photographic: a low-resolution pixel grid scaled up by whole numbers, fewer tones or a fixed palette through an ordered or blue-noise dither, halftone dots, cross-hatching, painterly smoothing over a canvas, ink lines on tonal edges, flat colour bands by depth, and the vertex snapping, affine textures and coarse depth of early 3D hardware. They compose: a look (og.load.look) sets this with PostEffects and RenderSettings, and the game's art direction is in that data, not in the engine. Every primitive is off at its zero value (0, false, none) and then costs nothing: no pass is recorded and no pipeline is built. RenderCapabilities.stylise names the primitives this renderer draws; a field it does not name is carried and read back but not drawn. Read after each tick; it never feeds back into the simulation.
    * Order in the frame: depth bands colour the lit scene with the fog, before tone mapping; after tone mapping and PostEffects' grading come paint, hatching, halftone and ink, then posterize and palette quantise through the dither, all at the logical resolution, and the pixel grid is scaled up last. The UI and screen-space sprites are drawn over the scaled frame at the output's resolution, unstylised.
@@ -21463,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).
    */
@@ -21611,6 +23022,25 @@ export declare namespace og {
      * @returns Refused for a look not loaded in this world, one in a streaming group that is not resident (the reason names it), or a resource the system did not declare.
      */
     function applyLook(world: World, look: Look): Result<void>;
+    /**
+     * Apply a graphics preset: write its row of RenderSettings' quality fields (the rest of RenderSettings keeps its values) and record it in RenderSettings.quality. The renderer reads those fields and nothing else, so what the probe and dump_world show of RenderSettings is what the next frame draws. The settings screen calls it when the player picks a preset (SettingsDesc.world); a game applies a saved preset itself at start. Inside a system, the system must declare RenderSettings among its writes. The rows:
+     * | Field | low | medium | high |
+     * |---|---|---|---|
+     * | rectShadows | false | true | true |
+     * | shadowedLights | 2 | 8 | 8 |
+     * | shadowMapScale | 0.5 | 1 | 2 |
+     * | volumetricFog | false | true | true |
+     * | softParticles | false | true | true |
+     * | screenSpaceReflections | false | true | true |
+     * | ambientOcclusion | false | true | true |
+     * | msaaSamples | 1 | 4 | 4 |
+     * Medium is every field's default, the frame drawn before any preset.
+     *
+     * @param world The world whose RenderSettings change.
+     * @param preset The preset.
+     * @returns Refused for a world that is not alive, or inside a system that did not declare RenderSettings among its writes.
+     */
+    function applyQuality(world: World, preset: GraphicsQuality): Result<void>;
     /**
      * The look last applied (by og.render.applyLook or GameDesc.look), as og.load.lookInfo describes it; null before any.
      *
@@ -21706,6 +23136,90 @@ export declare namespace og {
      * @returns Refused for fewer than two points or a point that is not finite (without a path), or a path that is not alive.
      */
     function tubeGeometry(world: World, desc?: TubeGeometryDesc): Result<Geometry>;
+    /**
+     * Make a flat shape for og.Mesh (one-sided, as circleGeometry): an og.Shape with holes, or a points array. Physics can use it as a triangle-mesh Collider.mesh.
+     *
+     * @param world The world whose renderer owns the geometry.
+     * @param desc The shapes and their tessellation.
+     * @returns Refused for a shape whose points are not finite or that triangulates to nothing.
+     */
+    function shapeGeometry(world: World, desc?: ShapeGeometryDesc): Result<Geometry>;
+    /**
+     * Make an extruded solid for og.Mesh: a three.js extrusion is a paste (`og.render.extrudeGeometry(world, { shapes: shape, depth: 0.2, bevelEnabled: true })`). Gears, signs, keys, logos, cookie cutters; along a path, a rail or a moulding.
+     *
+     * @param world The world whose renderer owns the geometry.
+     * @param desc The shapes, depth, bevel and path.
+     * @returns Refused for a shape whose points are not finite or that triangulates to nothing, or an extrudePath that is not alive.
+     */
+    function extrudeGeometry(world: World, desc?: ExtrudeGeometryDesc): Result<Geometry>;
+    /**
+     * Make a solid of revolution for og.Mesh: a profile turned round +Y.
+     *
+     * @param world The world whose renderer owns the geometry.
+     * @param desc The profile and the turn.
+     * @returns Refused for fewer than two points or one that is not finite.
+     */
+    function latheGeometry(world: World, desc?: LatheGeometryDesc): Result<Geometry>;
+    /**
+     * Make a polyhedron from vertices and faces for og.Mesh, subdivided onto a sphere.
+     *
+     * @param world The world whose renderer owns the geometry.
+     * @param desc The vertices, faces, radius and detail.
+     * @returns Refused for no faces, an index past the vertices, or a count that is not a multiple of three.
+     */
+    function polyhedronGeometry(world: World, desc?: PolyhedronGeometryDesc): Result<Geometry>;
+    /**
+     * Make an icosahedron (twenty faces) for og.Mesh; with detail, a geodesic sphere.
+     *
+     * @param world The world whose renderer owns the geometry.
+     * @param desc Its radius and detail.
+     */
+    function icosahedronGeometry(world: World, desc?: SolidGeometryDesc): Result<Geometry>;
+    /**
+     * Make a dodecahedron (twelve pentagons, thirty-six triangles) for og.Mesh.
+     *
+     * @param world The world whose renderer owns the geometry.
+     * @param desc Its radius and detail.
+     */
+    function dodecahedronGeometry(world: World, desc?: SolidGeometryDesc): Result<Geometry>;
+    /**
+     * Make an octahedron (eight faces) for og.Mesh.
+     *
+     * @param world The world whose renderer owns the geometry.
+     * @param desc Its radius and detail.
+     */
+    function octahedronGeometry(world: World, desc?: SolidGeometryDesc): Result<Geometry>;
+    /**
+     * Make a tetrahedron (four faces) for og.Mesh.
+     *
+     * @param world The world whose renderer owns the geometry.
+     * @param desc Its radius and detail.
+     */
+    function tetrahedronGeometry(world: World, desc?: SolidGeometryDesc): Result<Geometry>;
+    /**
+     * Make a section swept along a path for og.Mesh, tapered and twisted by keys.
+     *
+     * @param world The world whose renderer owns the geometry.
+     * @param desc The section, path, keys and caps.
+     * @returns Refused for a path that is not alive, a section of fewer than three points or of no area, or a value that is not finite.
+     */
+    function sweepGeometry(world: World, desc?: SweepGeometryDesc): Result<Geometry>;
+    /**
+     * Make the union, difference or intersection of two placed geometries for og.Mesh. Chain calls for more operands (a cube minus six spheres is six calls); each result is a geometry like any other.
+     *
+     * @param world The world whose renderer owns the geometry.
+     * @param desc The operation and its operands.
+     * @returns Refused for a dead geometry, a placement with a zero scale, or a position that is not finite.
+     */
+    function csgGeometry(world: World, desc?: CsgGeometryDesc): Result<Geometry>;
+    /**
+     * Make one geometry of several placed ones for og.Mesh: one draw instead of many, mirrored halves, arrays.
+     *
+     * @param world The world whose renderer owns the geometry.
+     * @param desc The parts and their placements.
+     * @returns Refused for no parts, a dead geometry, or a placement with a zero scale.
+     */
+    function mergeGeometries(world: World, desc?: MergeGeometriesDesc): Result<Geometry>;
     /**
      * Draw lines this frame. Systems and commands may call it; the list is cleared at every tick, so submit them every tick they should show (og.Lines keeps a static set).
      *
@@ -21750,7 +23264,7 @@ export declare namespace og {
      */
     function setPostParam(world: World, post: Post, name: string, value: readonly number[]): Result<void>;
     /**
-     * The custom post passes PostEffects.custom1 to custom8 name that failed to compile on this device, each skipped (the frame draws as without it). The cook validates every pass for each back end, so this is a device's own refusal.
+     * The custom post passes PostEffects.custom names that failed to compile on this device, each skipped (the frame draws as without it). The cook validates every pass for each back end, so this is a device's own refusal.
      *
      * @param world The world asked.
      */
@@ -21762,6 +23276,14 @@ export declare namespace og {
      */
     function bakedLighting(world: World): readonly BakedScene[];
   }
+  /**
+   * three.js's Path (named Path2 beside og.path's 3D paths): `new og.Path2().moveTo(0, 0).lineTo(1, 0)`.
+   */
+  const Path2: Path2Class;
+  /**
+   * three.js's Shape: `const s = new og.Shape(); s.moveTo(0, 0).lineTo(1, 0).lineTo(0, 1); s.holes.push(hole)`.
+   */
+  const Shape: ShapeClass;
   /**
    * Draws a loaded glTF's default scene at the entity's world transform: every mesh node with its glTF material. Scene entities with a `model` line get one; world.instantiate of a glTF asset spawns one.
    * The glTF's materials are shared by every instance of it; `tint` and `flash` are this instance's own, carried with its transform to the lit shaders (one draw for every instance, whatever each shows), so one of a crowd can flash when struck.
@@ -21802,7 +23324,7 @@ export declare namespace og {
     function defaultBundle(world: World): Result<Asset>;
     /**
      * Load a cooked glTF (.gltf or .glb), as three.js GLTFLoader.load: its meshes, materials and textures join the renderer once.
-     * A MagicaVoxel `.vox` cooks to a glTF and loads here too: greedy-meshed, flat-shaded, its palette as vertex colours, z-up turned y-up, each model about its centre (MagicaVoxel's pivot, with a scene graph or without). Its import settings (`models/hut.vox.ogt`, `type import`) size and place it: `model { voxScale 0.1 voxOrigin bottom }` is 0.1 m a voxel (default 1) and the lowest voxel on y = 0 (default `center`, the editor's origin). A `.vox` with frames (MagicaVoxel's animation) cooks to clips that swap the frames' models, played by og.AnimationPlayer as any skinned clip: `voxFps 8` (default 10) and `voxClip walk 0 3` (frames 0 to 3; default one clip `frames` of every frame).
+     * A MagicaVoxel `.vox` cooks to a glTF and loads here too: greedy-meshed, flat-shaded, its palette as vertex colours, z-up turned y-up, each model about its centre (MagicaVoxel's pivot, with a scene graph or without). Its import settings (`models/hut.vox.ogt`, `type import`) size and place it: `model { voxScale 0.1 voxOrigin bottom }` is 0.1 m a voxel (default 1) and the lowest voxel on y = 0 (default `center`, the editor's origin). A `.vox` with frames (MagicaVoxel's animation) cooks to clips that swap the frames' models, played by og.AnimationPlayer as any skinned clip: `voxFps 8` (default 10) and `voxClip walk 0 3` (frames 0 to 3; default one clip `frames` of the file's playback range, else of every frame); a node's `_loop` repeats its keys as the editor plays them.
      *
      * @param world The world that owns the asset.
      * @param path The asset id, such as `models/ship.glb`.
@@ -21873,7 +23395,7 @@ export declare namespace og {
      */
     function shader(world: World, path: string): Result<Shader>;
     /**
-     * A custom post pass for PostEffects.custom1 to custom8, from a cooked `.ogt` of `type post`: `code` or `source` (a `.wgsl` beside it) defining `fn post(f: PostInput, p: Params) -> vec4<f32>` and `param <name> float|vec2|vec3|vec4|color <default...>` lines (at most eight). The function reads previous(uv), scene_color(uv), depth(uv), normal(uv) and f.uv, f.pixel, f.size, f.time, and returns linear HDR colour (the og-game skill's Custom post passes section has the contract). The cook compiles it for every back end. Loaded once per path.
+     * A custom post pass for PostEffects.custom, from a cooked `.ogt` of `type post`: `code` or `source` (a `.wgsl` beside it) defining `fn post(f: PostInput, p: Params) -> vec4<f32>` and `param <name> float|vec2|vec3|vec4|color <default...>` lines (at most eight). The function reads previous(uv), scene_color(uv), depth(uv), normal(uv) and f.uv, f.pixel, f.size, f.time, and returns linear HDR colour (the og-game skill's Custom post passes section has the contract). The cook compiles it for every back end. Loaded once per path.
      *
      * @param world The world whose renderer owns it.
      * @param path The asset id, such as `post/crt.ogt`.
@@ -22043,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>;
@@ -22324,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.
    */
@@ -22341,9 +23885,9 @@ export declare namespace og {
    * Plays a clip of a 2D rig at the entity: the og.skeleton2d system advances it by scaled time (Time.scaledDt) after the game's systems and fires its events as og.Skeleton2DEvent; extraction draws its slots, in their order, as textured triangles of the sprite batch at `layer` (region attachments as quads, mesh attachments weighted to bones and deformed by the clip), lit by og.Lighting2D when the layer is in its range, as a sprite there is. The rig's pixels are `unit` to a world unit and +y is up; the entity's og.Transform places, turns (about z) and scales it.
    * Changing `clip` restarts at 0 (or at `time`, written in the same tick); writing a different time is a seek and fires no events. The pose is a function of these fields, the Transform and the og.IkTarget2D on it; the playback position is world state (the og.skeleton2d state block).
    */
-  const Skeleton2D: ComponentType<{ readonly rig: FieldSpec<"Rig2D">; readonly clip: FieldSpec<"u32">; readonly time: FieldSpec<"f32">; readonly speed: FieldSpec<"f32">; readonly loop: FieldSpec<"bool">; readonly flipX: FieldSpec<"bool">; readonly layer: FieldSpec<"i32">; readonly finished: FieldSpec<"bool"> }, Skeleton2D>;
+  const Skeleton2D: ComponentType<{ readonly rig: FieldSpec<"Rig2D">; readonly clip: FieldSpec<"u32">; readonly time: FieldSpec<"f32">; readonly speed: FieldSpec<"f32">; readonly loop: FieldSpec<"bool">; readonly flipX: FieldSpec<"bool">; readonly layer: FieldSpec<"i32">; readonly skin: FieldSpec<"u32">; readonly finished: FieldSpec<"bool"> }, Skeleton2D>;
   /**
-   * A 2D skeleton's clip passed one of its events (`event 0.2 "step"` in the rig) in the last tick: footsteps, the frame a swing lands. Read in the tick after, like every event; a clip started at 0 fires its events at 0, a looping clip fires each once per pass.
+   * A 2D skeleton's clip, or the clip a child armature in one of its slots plays, passed one of its events (`event 0.2 "step"` in the rig) in the last tick: footsteps, the frame a swing lands. Read in the tick after, like every event; a clip started at 0 fires its events at 0, a looping clip fires each once per pass.
    */
   const Skeleton2DEvent: EventType<Skeleton2DEvent>;
   /**
@@ -22373,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.
      *
@@ -22541,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.
@@ -22574,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 {
     /**
@@ -23800,7 +25353,7 @@ export declare namespace og {
   const TerrainScatter: ComponentType<{ readonly data: FieldSpec<"TerrainData">; readonly geometry: FieldSpec<"Geometry">; readonly material: FieldSpec<"Material">; readonly layer: FieldSpec<"u32">; readonly density: FieldSpec<"f32">; readonly distance: FieldSpec<"f32">; readonly fade: FieldSpec<"f32">; readonly minScale: FieldSpec<"f32">; readonly maxScale: FieldSpec<"f32">; readonly align: FieldSpec<"f32">; readonly seed: FieldSpec<"u32"> }, TerrainScatter>;
   /**
    * Terrain (phase 2): a height field over a rectangle, cooked by `og cook` from a `type terrain` .ogt (a 16-bit grey PNG or an EXR heightmap, an optional control map, up to four layered materials with slope and altitude rules, their maps separate textures or layers of two texture arrays: `layers` and `layerNormals` with each layer's `albedoLayer` and `normalLayer`, two sampled textures instead of up to eight) into tiles; drawn as a geometry clipmap around the camera (nested levels by distance, no cracks) that casts and receives shadows under the fog; collided with as a height field; baked into navmeshes by a navmesh file's `terrain` entry.
-   * Load it with og.terrain.load, then place it: an og.Terrain on an entity draws it placed by the entity's world transform (centred on its position, turned and scaled with it), and an og.Collider of shape SHAPE_HEIGHTFIELD naming the TerrainInfo's geometry makes it solid. og.TerrainScatter grows grass, flowers or stones over a layer near the camera. og.terrain.sample answers the surface's height and normal anywhere (pass it the entity's position, quaternion and scale); og.terrain.edit raises, lowers, flattens, smooths or paints it at runtime, and og.terrain.setLayer retunes a layer. Edits are world state: a snapshot keeps them, the world hash covers them, and a restore brings the ground back as it was (rebuilt from the cook with the restored edits replayed, for the renderer, physics and sample alike).
+   * Load it with og.terrain.load, then place it: an og.Terrain on an entity draws it placed by the entity's world transform (centred on its position, turned and scaled with it), and an og.Collider of shape SHAPE_HEIGHTFIELD naming the TerrainInfo's geometry makes it solid. og.TerrainScatter grows grass, flowers or stones over a layer near the camera. og.terrain.sample answers the surface's height and normal anywhere (pass it the entity's position, quaternion and scale); og.terrain.edit raises, lowers, flattens, smooths or paints it at runtime, and og.terrain.setLayer retunes a layer. Terrain is 3D: the 2D profile's publish and lanes modules leave it out (RenderCapabilities.world3d is false), where every call here answers a refusal naming that field. Edits are world state: a snapshot keeps them, the world hash covers them, and a restore brings the ground back as it was (rebuilt from the cook with the restored edits replayed, for the renderer, physics and sample alike).
    * Its tiles stream (phase 3): the cook stores the field as a pyramid of tiles, each compressed on its own, and every frame the renderer keeps on the GPU only the tiles the camera's clipmap wants, within each terrain's tile budget (16 MiB by default), decoded off the frame (a worker thread natively, the browser's DecompressionStream on the Web) a few at a time, the most needed first; until a tile arrives its area draws from the coarser level that holds it, then fades in. Nothing a tick reads depends on which tiles are resident (collision and og.terrain.sample read the whole field), so a run's world hash is the same streamed or not. The probe's `terrain_stream:resident` decodes every wanted tile before each frame instead (`terrain_stream:stream[:<MiB>]` streams again, within that budget), and `dump_stream`'s `terrain` gives the tiles resident, waiting, decoding and cached.
    */
   namespace terrain {