@origingame/engine 0.3.0 → 0.5.0

package/schema/api.schema.json

@@ -17,6 +17,7 @@
     "bytes": "bytes",
     "kg": "kilograms",
     "newton": "newtons: the force that gives a kilogram one metre per second squared",
+    "newtonSecond": "newton-seconds: an impulse, the momentum that changes a kilogram's velocity by one metre per second",
     "mps": "metres per second",
     "mps2": "metres per second squared",
     "radps": "radians per second",
@@ -1614,7 +1615,7 @@
     },
     {
       "name": "reflect",
-      "doc": "Reflection: components and resources are declared once with their field layout and metadata, and registered by name.\nThe inspector, Tune, the probe, scene text and the wiki read this one schema. Each column factory below makes one field.\nA 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.\nA 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.",
+      "doc": "Reflection: components and resources are declared once with their field layout and metadata, and registered by name.\nThe inspector, Tune, the probe, scene text and the wiki read this one schema. Each column factory below makes one field.\nA 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.\nA 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.",
       "place": "top",
       "publish": true,
       "types": [
@@ -1629,7 +1630,8 @@
         "Quaternion",
         "Matrix4",
         "Color",
-        "str"
+        "str",
+        "list"
       ],
       "consts": [],
       "functions": [
@@ -2753,6 +2755,9 @@
         "SpotLight",
         "ToneMapping",
         "ToneMapping",
+        "GraphicsQuality",
+        "QualityPreset",
+        "QualityPreset",
         "RenderSettings",
         "Lut",
         "EnvironmentMap",
@@ -2768,12 +2773,15 @@
         "DofQuality",
         "SpriteBlend",
         "SpriteBlend",
+        "SpriteFacing",
+        "SpriteFacing",
         "StripBlend",
         "StripBlend",
         "PostEffects",
         "Palette",
         "Look",
         "Palette",
+        "Look",
         "DitherPattern",
         "DitherPattern",
         "StyliseSpace",
@@ -2805,6 +2813,7 @@
         "ReflectionProbeMode",
         "ReflectionProbe",
         "Shader",
+        "Shader",
         "BufferGeometryDesc",
         "GeometryInfo",
         "CylinderGeometryDesc",
@@ -2814,6 +2823,19 @@
         "RingGeometryDesc",
         "CircleGeometryDesc",
         "TubeGeometryDesc",
+        "ShapePoints",
+        "ShapeGeometryDesc",
+        "ExtrudeGeometryDesc",
+        "LatheGeometryDesc",
+        "PolyhedronGeometryDesc",
+        "SolidGeometryDesc",
+        "SweepKey",
+        "SweepGeometryDesc",
+        "MirrorAxis",
+        "GeometryPart",
+        "CsgOp",
+        "CsgGeometryDesc",
+        "MergeGeometriesDesc",
         "LineMode",
         "LineMode",
         "LinesDesc",
@@ -3170,6 +3192,27 @@
           "returnsDoc": "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.",
           "publish": true
         },
+        {
+          "name": "applyQuality",
+          "doc": "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:\n| Field | low | medium | high |\n|---|---|---|---|\n| rectShadows | false | true | true |\n| shadowedLights | 2 | 8 | 8 |\n| shadowMapScale | 0.5 | 1 | 2 |\n| volumetricFog | false | true | true |\n| softParticles | false | true | true |\n| screenSpaceReflections | false | true | true |\n| ambientOcclusion | false | true | true |\n| msaaSamples | 1 | 4 | 4 |\nMedium is every field's default, the frame drawn before any preset.",
+          "params": [
+            {
+              "name": "world",
+              "type": "World",
+              "optional": false,
+              "doc": "The world whose RenderSettings change."
+            },
+            {
+              "name": "preset",
+              "type": "GraphicsQuality",
+              "optional": false,
+              "doc": "The preset."
+            }
+          ],
+          "returns": "Result<Void>",
+          "returnsDoc": "Refused for a world that is not alive, or inside a system that did not declare RenderSettings among its writes.",
+          "publish": true
+        },
         {
           "name": "look",
           "doc": "The look last applied (by og.render.applyLook or GameDesc.look), as og.load.lookInfo describes it; null before any.",
@@ -3429,6 +3472,233 @@
           "returnsDoc": "Refused for fewer than two points or a point that is not finite (without a path), or a path that is not alive.",
           "publish": true
         },
+        {
+          "name": "shapeGeometry",
+          "doc": "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.",
+          "params": [
+            {
+              "name": "world",
+              "type": "World",
+              "optional": false,
+              "doc": "The world whose renderer owns the geometry."
+            },
+            {
+              "name": "desc",
+              "type": "ShapeGeometryDesc",
+              "optional": true,
+              "doc": "The shapes and their tessellation."
+            }
+          ],
+          "returns": "Result<Geometry>",
+          "returnsDoc": "Refused for a shape whose points are not finite or that triangulates to nothing.",
+          "publish": true
+        },
+        {
+          "name": "extrudeGeometry",
+          "doc": "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.",
+          "params": [
+            {
+              "name": "world",
+              "type": "World",
+              "optional": false,
+              "doc": "The world whose renderer owns the geometry."
+            },
+            {
+              "name": "desc",
+              "type": "ExtrudeGeometryDesc",
+              "optional": true,
+              "doc": "The shapes, depth, bevel and path."
+            }
+          ],
+          "returns": "Result<Geometry>",
+          "returnsDoc": "Refused for a shape whose points are not finite or that triangulates to nothing, or an extrudePath that is not alive.",
+          "publish": true
+        },
+        {
+          "name": "latheGeometry",
+          "doc": "Make a solid of revolution for og.Mesh: a profile turned round +Y.",
+          "params": [
+            {
+              "name": "world",
+              "type": "World",
+              "optional": false,
+              "doc": "The world whose renderer owns the geometry."
+            },
+            {
+              "name": "desc",
+              "type": "LatheGeometryDesc",
+              "optional": true,
+              "doc": "The profile and the turn."
+            }
+          ],
+          "returns": "Result<Geometry>",
+          "returnsDoc": "Refused for fewer than two points or one that is not finite.",
+          "publish": true
+        },
+        {
+          "name": "polyhedronGeometry",
+          "doc": "Make a polyhedron from vertices and faces for og.Mesh, subdivided onto a sphere.",
+          "params": [
+            {
+              "name": "world",
+              "type": "World",
+              "optional": false,
+              "doc": "The world whose renderer owns the geometry."
+            },
+            {
+              "name": "desc",
+              "type": "PolyhedronGeometryDesc",
+              "optional": true,
+              "doc": "The vertices, faces, radius and detail."
+            }
+          ],
+          "returns": "Result<Geometry>",
+          "returnsDoc": "Refused for no faces, an index past the vertices, or a count that is not a multiple of three.",
+          "publish": true
+        },
+        {
+          "name": "icosahedronGeometry",
+          "doc": "Make an icosahedron (twenty faces) for og.Mesh; with detail, a geodesic sphere.",
+          "params": [
+            {
+              "name": "world",
+              "type": "World",
+              "optional": false,
+              "doc": "The world whose renderer owns the geometry."
+            },
+            {
+              "name": "desc",
+              "type": "SolidGeometryDesc",
+              "optional": true,
+              "doc": "Its radius and detail."
+            }
+          ],
+          "returns": "Result<Geometry>",
+          "publish": true
+        },
+        {
+          "name": "dodecahedronGeometry",
+          "doc": "Make a dodecahedron (twelve pentagons, thirty-six triangles) for og.Mesh.",
+          "params": [
+            {
+              "name": "world",
+              "type": "World",
+              "optional": false,
+              "doc": "The world whose renderer owns the geometry."
+            },
+            {
+              "name": "desc",
+              "type": "SolidGeometryDesc",
+              "optional": true,
+              "doc": "Its radius and detail."
+            }
+          ],
+          "returns": "Result<Geometry>",
+          "publish": true
+        },
+        {
+          "name": "octahedronGeometry",
+          "doc": "Make an octahedron (eight faces) for og.Mesh.",
+          "params": [
+            {
+              "name": "world",
+              "type": "World",
+              "optional": false,
+              "doc": "The world whose renderer owns the geometry."
+            },
+            {
+              "name": "desc",
+              "type": "SolidGeometryDesc",
+              "optional": true,
+              "doc": "Its radius and detail."
+            }
+          ],
+          "returns": "Result<Geometry>",
+          "publish": true
+        },
+        {
+          "name": "tetrahedronGeometry",
+          "doc": "Make a tetrahedron (four faces) for og.Mesh.",
+          "params": [
+            {
+              "name": "world",
+              "type": "World",
+              "optional": false,
+              "doc": "The world whose renderer owns the geometry."
+            },
+            {
+              "name": "desc",
+              "type": "SolidGeometryDesc",
+              "optional": true,
+              "doc": "Its radius and detail."
+            }
+          ],
+          "returns": "Result<Geometry>",
+          "publish": true
+        },
+        {
+          "name": "sweepGeometry",
+          "doc": "Make a section swept along a path for og.Mesh, tapered and twisted by keys.",
+          "params": [
+            {
+              "name": "world",
+              "type": "World",
+              "optional": false,
+              "doc": "The world whose renderer owns the geometry."
+            },
+            {
+              "name": "desc",
+              "type": "SweepGeometryDesc",
+              "optional": true,
+              "doc": "The section, path, keys and caps."
+            }
+          ],
+          "returns": "Result<Geometry>",
+          "returnsDoc": "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.",
+          "publish": true
+        },
+        {
+          "name": "csgGeometry",
+          "doc": "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.",
+          "params": [
+            {
+              "name": "world",
+              "type": "World",
+              "optional": false,
+              "doc": "The world whose renderer owns the geometry."
+            },
+            {
+              "name": "desc",
+              "type": "CsgGeometryDesc",
+              "optional": true,
+              "doc": "The operation and its operands."
+            }
+          ],
+          "returns": "Result<Geometry>",
+          "returnsDoc": "Refused for a dead geometry, a placement with a zero scale, or a position that is not finite.",
+          "publish": true
+        },
+        {
+          "name": "mergeGeometries",
+          "doc": "Make one geometry of several placed ones for og.Mesh: one draw instead of many, mirrored halves, arrays.",
+          "params": [
+            {
+              "name": "world",
+              "type": "World",
+              "optional": false,
+              "doc": "The world whose renderer owns the geometry."
+            },
+            {
+              "name": "desc",
+              "type": "MergeGeometriesDesc",
+              "optional": true,
+              "doc": "The parts and their placements."
+            }
+          ],
+          "returns": "Result<Geometry>",
+          "returnsDoc": "Refused for no parts, a dead geometry, or a placement with a zero scale.",
+          "publish": true
+        },
         {
           "name": "lines",
           "doc": "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).",
@@ -3554,7 +3824,7 @@
         },
         {
           "name": "postErrors",
-          "doc": "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.",
+          "doc": "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.",
           "params": [
             {
               "name": "world",
@@ -3584,6 +3854,518 @@
       "interfaces": [],
       "callbacks": []
     },
+    {
+      "name": "shapes",
+      "doc": "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.\nThey 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.\nA 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.",
+      "place": "root",
+      "publish": true,
+      "types": [],
+      "consts": [],
+      "values": [
+        {
+          "name": "Path2",
+          "type": "Path2Class",
+          "doc": "three.js's Path (named Path2 beside og.path's 3D paths): `new og.Path2().moveTo(0, 0).lineTo(1, 0)`."
+        },
+        {
+          "name": "Shape",
+          "type": "ShapeClass",
+          "doc": "three.js's Shape: `const s = new og.Shape(); s.moveTo(0, 0).lineTo(1, 0).lineTo(0, 1); s.holes.push(hole)`."
+        }
+      ],
+      "functions": [],
+      "interfaces": [
+        {
+          "name": "PathList",
+          "doc": "A shape's holes, as three.js Shape.holes: an array; push a path to add a hole.",
+          "members": [
+            {
+              "name": "length",
+              "prop": "u32",
+              "doc": "How many holes.",
+              "publish": true
+            },
+            {
+              "name": "push",
+              "doc": "Add a hole (Array.push).",
+              "params": [
+                {
+                  "name": "path",
+                  "type": "Path2",
+                  "optional": false,
+                  "doc": "The hole's outline, either winding."
+                }
+              ],
+              "returns": "u32",
+              "publish": true,
+              "host": false
+            }
+          ]
+        },
+        {
+          "name": "Path2",
+          "doc": "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.",
+          "members": [
+            {
+              "name": "moveTo",
+              "doc": "Move the current point without drawing, as three.js Path.moveTo.",
+              "params": [
+                {
+                  "name": "x",
+                  "type": "f32",
+                  "optional": false,
+                  "doc": "x."
+                },
+                {
+                  "name": "y",
+                  "type": "f32",
+                  "optional": false,
+                  "doc": "y."
+                }
+              ],
+              "returns": "This",
+              "publish": true,
+              "host": false
+            },
+            {
+              "name": "lineTo",
+              "doc": "A straight line to (x, y), as three.js Path.lineTo.",
+              "params": [
+                {
+                  "name": "x",
+                  "type": "f32",
+                  "optional": false,
+                  "doc": "x."
+                },
+                {
+                  "name": "y",
+                  "type": "f32",
+                  "optional": false,
+                  "doc": "y."
+                }
+              ],
+              "returns": "This",
+              "publish": true,
+              "host": false
+            },
+            {
+              "name": "quadraticCurveTo",
+              "doc": "A quadratic Bézier curve through one control point to (x, y), as three.js Path.quadraticCurveTo.",
+              "params": [
+                {
+                  "name": "cpX",
+                  "type": "f32",
+                  "optional": false,
+                  "doc": "The control point's x."
+                },
+                {
+                  "name": "cpY",
+                  "type": "f32",
+                  "optional": false,
+                  "doc": "The control point's y."
+                },
+                {
+                  "name": "x",
+                  "type": "f32",
+                  "optional": false,
+                  "doc": "The end's x."
+                },
+                {
+                  "name": "y",
+                  "type": "f32",
+                  "optional": false,
+                  "doc": "The end's y."
+                }
+              ],
+              "returns": "This",
+              "publish": true,
+              "host": false
+            },
+            {
+              "name": "bezierCurveTo",
+              "doc": "A cubic Bézier curve through two control points to (x, y), as three.js Path.bezierCurveTo.",
+              "params": [
+                {
+                  "name": "cp1X",
+                  "type": "f32",
+                  "optional": false,
+                  "doc": "The first control point's x."
+                },
+                {
+                  "name": "cp1Y",
+                  "type": "f32",
+                  "optional": false,
+                  "doc": "The first control point's y."
+                },
+                {
+                  "name": "cp2X",
+                  "type": "f32",
+                  "optional": false,
+                  "doc": "The second control point's x."
+                },
+                {
+                  "name": "cp2Y",
+                  "type": "f32",
+                  "optional": false,
+                  "doc": "The second control point's y."
+                },
+                {
+                  "name": "x",
+                  "type": "f32",
+                  "optional": false,
+                  "doc": "The end's x."
+                },
+                {
+                  "name": "y",
+                  "type": "f32",
+                  "optional": false,
+                  "doc": "The end's y."
+                }
+              ],
+              "returns": "This",
+              "publish": true,
+              "host": false
+            },
+            {
+              "name": "splineThru",
+              "doc": "A Catmull-Rom spline from the current point through the points, as three.js Path.splineThru (a SplineCurve).",
+              "params": [
+                {
+                  "name": "points",
+                  "type": "List<Vector2>",
+                  "optional": false,
+                  "doc": "The points it passes through, in order."
+                }
+              ],
+              "returns": "This",
+              "publish": true,
+              "host": false
+            },
+            {
+              "name": "arc",
+              "doc": "A circular arc centred at (x, y) from the current point, as three.js Path.arc.",
+              "params": [
+                {
+                  "name": "x",
+                  "type": "f32",
+                  "optional": false,
+                  "doc": "The centre's x, from the current point."
+                },
+                {
+                  "name": "y",
+                  "type": "f32",
+                  "optional": false,
+                  "doc": "The centre's y, from the current point."
+                },
+                {
+                  "name": "radius",
+                  "type": "f32",
+                  "optional": false,
+                  "doc": "The radius."
+                },
+                {
+                  "name": "startAngle",
+                  "type": "f32",
+                  "optional": false,
+                  "doc": "Where it starts, from +x towards +y."
+                },
+                {
+                  "name": "endAngle",
+                  "type": "f32",
+                  "optional": false,
+                  "doc": "Where it ends."
+                },
+                {
+                  "name": "clockwise",
+                  "type": "bool",
+                  "optional": true,
+                  "default": false,
+                  "doc": "Go clockwise."
+                }
+              ],
+              "returns": "This",
+              "publish": true,
+              "host": false
+            },
+            {
+              "name": "absarc",
+              "doc": "A circular arc centred at (x, y), as three.js Path.absarc: a line joins it to the current point when they differ.",
+              "params": [
+                {
+                  "name": "x",
+                  "type": "f32",
+                  "optional": false,
+                  "doc": "The centre's x."
+                },
+                {
+                  "name": "y",
+                  "type": "f32",
+                  "optional": false,
+                  "doc": "The centre's y."
+                },
+                {
+                  "name": "radius",
+                  "type": "f32",
+                  "optional": false,
+                  "doc": "The radius."
+                },
+                {
+                  "name": "startAngle",
+                  "type": "f32",
+                  "optional": false,
+                  "doc": "Where it starts, from +x towards +y."
+                },
+                {
+                  "name": "endAngle",
+                  "type": "f32",
+                  "optional": false,
+                  "doc": "Where it ends."
+                },
+                {
+                  "name": "clockwise",
+                  "type": "bool",
+                  "optional": true,
+                  "default": false,
+                  "doc": "Go clockwise."
+                }
+              ],
+              "returns": "This",
+              "publish": true,
+              "host": false
+            },
+            {
+              "name": "ellipse",
+              "doc": "An elliptic arc centred at (x, y) from the current point, as three.js Path.ellipse.",
+              "params": [
+                {
+                  "name": "x",
+                  "type": "f32",
+                  "optional": false,
+                  "doc": "The centre's x, from the current point."
+                },
+                {
+                  "name": "y",
+                  "type": "f32",
+                  "optional": false,
+                  "doc": "The centre's y, from the current point."
+                },
+                {
+                  "name": "xRadius",
+                  "type": "f32",
+                  "optional": false,
+                  "doc": "The radius along x."
+                },
+                {
+                  "name": "yRadius",
+                  "type": "f32",
+                  "optional": false,
+                  "doc": "The radius along y."
+                },
+                {
+                  "name": "startAngle",
+                  "type": "f32",
+                  "optional": false,
+                  "doc": "Where it starts."
+                },
+                {
+                  "name": "endAngle",
+                  "type": "f32",
+                  "optional": false,
+                  "doc": "Where it ends."
+                },
+                {
+                  "name": "clockwise",
+                  "type": "bool",
+                  "optional": true,
+                  "default": false,
+                  "doc": "Go clockwise."
+                },
+                {
+                  "name": "rotation",
+                  "type": "f32",
+                  "optional": true,
+                  "default": 0,
+                  "doc": "The ellipse's turn round its centre."
+                }
+              ],
+              "returns": "This",
+              "publish": true,
+              "host": false
+            },
+            {
+              "name": "absellipse",
+              "doc": "An elliptic arc centred at (x, y), as three.js Path.absellipse.",
+              "params": [
+                {
+                  "name": "x",
+                  "type": "f32",
+                  "optional": false,
+                  "doc": "The centre's x."
+                },
+                {
+                  "name": "y",
+                  "type": "f32",
+                  "optional": false,
+                  "doc": "The centre's y."
+                },
+                {
+                  "name": "xRadius",
+                  "type": "f32",
+                  "optional": false,
+                  "doc": "The radius along x."
+                },
+                {
+                  "name": "yRadius",
+                  "type": "f32",
+                  "optional": false,
+                  "doc": "The radius along y."
+                },
+                {
+                  "name": "startAngle",
+                  "type": "f32",
+                  "optional": false,
+                  "doc": "Where it starts."
+                },
+                {
+                  "name": "endAngle",
+                  "type": "f32",
+                  "optional": false,
+                  "doc": "Where it ends."
+                },
+                {
+                  "name": "clockwise",
+                  "type": "bool",
+                  "optional": true,
+                  "default": false,
+                  "doc": "Go clockwise."
+                },
+                {
+                  "name": "rotation",
+                  "type": "f32",
+                  "optional": true,
+                  "default": 0,
+                  "doc": "The ellipse's turn round its centre."
+                }
+              ],
+              "returns": "This",
+              "publish": true,
+              "host": false
+            },
+            {
+              "name": "setFromPoints",
+              "doc": "Start at the first point and draw lines through the rest, as three.js Path.setFromPoints.",
+              "params": [
+                {
+                  "name": "points",
+                  "type": "List<Vector2>",
+                  "optional": false,
+                  "doc": "The points."
+                }
+              ],
+              "returns": "This",
+              "publish": true,
+              "host": false
+            },
+            {
+              "name": "closePath",
+              "doc": "A line back to the first point when the outline does not end there, as three.js CurvePath.closePath.",
+              "params": [],
+              "returns": "This",
+              "publish": true,
+              "host": false
+            },
+            {
+              "name": "getPoints",
+              "doc": "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.",
+              "params": [
+                {
+                  "name": "divisions",
+                  "type": "u32",
+                  "optional": true,
+                  "default": 12,
+                  "doc": "Divisions per curve."
+                }
+              ],
+              "returns": "List<Vector2>",
+              "publish": true,
+              "host": false
+            }
+          ]
+        },
+        {
+          "name": "Shape",
+          "doc": "An outline with holes, as three.js Shape.",
+          "extends": "Path2",
+          "members": [
+            {
+              "name": "holes",
+              "prop": "PathList",
+              "doc": "The holes: `shape.holes.push(hole)`.",
+              "publish": true
+            },
+            {
+              "name": "extractPoints",
+              "doc": "The outline's and the holes' points, as three.js Shape.extractPoints.",
+              "params": [
+                {
+                  "name": "divisions",
+                  "type": "u32",
+                  "optional": true,
+                  "default": 12,
+                  "doc": "Divisions per curve."
+                }
+              ],
+              "returns": "ShapePoints",
+              "publish": true,
+              "host": false
+            }
+          ]
+        },
+        {
+          "name": "Path2Class",
+          "doc": "og.Path2: `new og.Path2(points?)`.",
+          "members": [
+            {
+              "name": "new",
+              "doc": "A path, through the points when given (setFromPoints).",
+              "params": [
+                {
+                  "name": "points",
+                  "type": "Option<List<Vector2>>",
+                  "optional": true,
+                  "doc": "Points to start from."
+                }
+              ],
+              "returns": "Path2",
+              "publish": true,
+              "host": false
+            }
+          ]
+        },
+        {
+          "name": "ShapeClass",
+          "doc": "og.Shape: `new og.Shape(points?)`.",
+          "members": [
+            {
+              "name": "new",
+              "doc": "A shape, through the points when given (setFromPoints).",
+              "params": [
+                {
+                  "name": "points",
+                  "type": "Option<List<Vector2>>",
+                  "optional": true,
+                  "doc": "Points to start from."
+                }
+              ],
+              "returns": "Shape",
+              "publish": true,
+              "host": false
+            }
+          ]
+        }
+      ],
+      "callbacks": []
+    },
     {
       "name": "load",
       "doc": "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/.\nPaths 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.\nThe game's bundle (`cooked`) is opened before the first tick and GameDesc.scene is spawned then. Loads from an open bundle complete at once on both hosts (the web host fetches the bundle's files before the engine starts); only og.load.bundle of another bundle can be pending, and it completes at a tick boundary.",
@@ -3598,6 +4380,8 @@
         "TextureArray",
         "Asset",
         "Sound",
+        "Font",
+        "Style",
         "LoadStatus",
         "GltfDesc",
         "GltfInfo",
@@ -3670,7 +4454,7 @@
         },
         {
           "name": "gltf",
-          "doc": "Load a cooked glTF (.gltf or .glb), as three.js GLTFLoader.load: its meshes, materials and textures join the renderer once.\nA 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).",
+          "doc": "Load a cooked glTF (.gltf or .glb), as three.js GLTFLoader.load: its meshes, materials and textures join the renderer once.\nA 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.",
           "params": [
             {
               "name": "world",
@@ -3862,7 +4646,7 @@
         },
         {
           "name": "post",
-          "doc": "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.",
+          "doc": "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.",
           "params": [
             {
               "name": "world",
@@ -5071,15 +5855,26 @@
         "AnimationGraph",
         "Blendshapes",
         "IkChain",
+        "LookAt",
+        "JointLimit",
+        "FootLock",
+        "SpringSpace",
+        "SpringSpace",
+        "SpringBone",
+        "SpringColliderShape",
+        "SpringColliderShape",
+        "SpringCollider",
         "AnimationEvent",
         "ClipInfo",
         "Animation",
         "GraphDesc",
         "Rig",
+        "Rig",
         "HumanBone",
         "Humanoid",
         "HumanoidDesc",
         "RetargetDesc",
+        "MirrorDesc",
         "FlipbookSheet",
         "FlipbookSheet",
         "FlipMode",
@@ -5142,7 +5937,7 @@
         },
         {
           "name": "retarget",
-          "doc": "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.",
+          "doc": "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.",
           "params": [
             {
               "name": "world",
@@ -5161,6 +5956,27 @@
           "returnsDoc": "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.",
           "publish": true
         },
+        {
+          "name": "mirror",
+          "doc": "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.",
+          "params": [
+            {
+              "name": "world",
+              "type": "World",
+              "optional": false,
+              "doc": "The world whose animation owns the skeleton and the clip."
+            },
+            {
+              "name": "desc",
+              "type": "MirrorDesc",
+              "optional": true,
+              "doc": "The clip and its skeleton."
+            }
+          ],
+          "returns": "Result<ClipInfo>",
+          "returnsDoc": "The new clip (what AnimationPlayer.clip takes). Refused for an unregistered clip or skeleton.",
+          "publish": true
+        },
         {
           "name": "clip",
           "doc": "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.",
@@ -5608,12 +6424,16 @@
     },
     {
       "name": "audio",
-      "doc": "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).\nThe 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.\nSpatial 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.",
+      "doc": "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).\nThe 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.\nSpatial 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.\nPropagation, 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.",
       "place": "namespace",
       "publish": true,
       "types": [
         "AudioBus",
         "AudioBus",
+        "PanningModel",
+        "AudioResampler",
+        "AudioResampler",
+        "PanningModel",
         "AudioSource",
         "AudioListener",
         "Audio",
@@ -5654,6 +6474,12 @@
           "type": "u32",
           "value": 4,
           "doc": "SoundEnded.reason: more sources played than Audio.maxVoices and this one stood lowest (priority, then volume, then age)."
+        },
+        {
+          "name": "SOUND_RETRIGGERED",
+          "type": "u32",
+          "value": 5,
+          "doc": "SoundEnded.reason: AudioSource.retrigger started the sound again from the top; a new voice plays it."
         }
       ],
       "functions": [
@@ -6969,7 +7795,6 @@
         "WipeSide",
         "ScreenTransitionDesc",
         "ScreenTransitionResult",
-        "GraphicsQuality",
         "MenuItem",
         "MenuResult",
         "MainMenuDesc",
@@ -9758,7 +10583,7 @@
     },
     {
       "name": "terrain",
-      "doc": "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.\nLoad 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).\nIts 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.",
+      "doc": "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.\nLoad 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).\nIts 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.",
       "place": "namespace",
       "publish": true,
       "types": [
@@ -14521,10 +15346,44 @@
         "none": "No curve: the exposed linear colour is clamped to 0..1, so 2D colours come out exactly as authored at exposure 1 (the same as toneMapped false)."
       }
     },
+    "GraphicsQuality": {
+      "x-og-kind": "enum",
+      "x-og-module": "render",
+      "description": "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.",
+      "type": "string",
+      "enum": [
+        "medium",
+        "low",
+        "high"
+      ],
+      "x-og-variants": {
+        "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."
+      }
+    },
+    "QualityPreset": {
+      "x-og-kind": "enum",
+      "x-og-module": "render",
+      "description": "The preset RenderSettings' quality fields were last written with (RenderSettings.quality).",
+      "type": "string",
+      "enum": [
+        "none",
+        "low",
+        "medium",
+        "high"
+      ],
+      "x-og-variants": {
+        "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\")."
+      }
+    },
     "RenderSettings": {
       "x-og-kind": "resource",
       "x-og-module": "render",
-      "description": "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.",
+      "description": "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.",
       "type": "object",
       "properties": {
         "environmentIntensity": {
@@ -14612,7 +15471,7 @@
         },
         "lodBias": {
           "type": "number",
-          "description": "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.",
+          "description": "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,
           "minimum": 0,
           "maximum": 16,
@@ -14622,6 +15481,61 @@
           "type": "boolean",
           "description": "Draw the baked lighting of the scenes that have it (og bake lightmaps): static models with their lightmaps, everything else inside a LightVolume with its probes. False draws every scene as if unbaked, its ambient light from the sky or the environment map: to compare, or to see the realtime lights alone.",
           "default": true
+        },
+        "quality": {
+          "$ref": "#/$defs/QualityPreset",
+          "description": "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.",
+          "default": "none"
+        },
+        "rectShadows": {
+          "type": "boolean",
+          "description": "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
+        },
+        "shadowedLights": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "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,
+          "minimum": 0,
+          "maximum": 8
+        },
+        "shadowMapScale": {
+          "type": "number",
+          "description": "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,
+          "minimum": 0.125,
+          "maximum": 4
+        },
+        "volumetricFog": {
+          "type": "boolean",
+          "description": "An og.VolumetricFog is drawn lit, with its light shafts; false draws the same medium as plain distance and height fog.",
+          "default": true
+        },
+        "softParticles": {
+          "type": "boolean",
+          "description": "Particles with a softDistance fade against the scene behind them; false draws them hard-edged and asks no depth prepass for them.",
+          "default": true
+        },
+        "screenSpaceReflections": {
+          "type": "boolean",
+          "description": "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
+        },
+        "ambientOcclusion": {
+          "type": "boolean",
+          "description": "PostEffects.ao darkens creases; false draws none. PostEffects keeps its settings either way.",
+          "default": true
+        },
+        "msaaSamples": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "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,
+          "minimum": 1,
+          "maximum": 4
         }
       },
       "additionalProperties": false
@@ -14731,6 +15645,22 @@
         "additive": "Added (light, fire, magic): order-independent within a layer."
       }
     },
+    "SpriteFacing": {
+      "x-og-kind": "enum",
+      "x-og-module": "render",
+      "description": "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.",
+      "type": "string",
+      "enum": [
+        "none",
+        "camera",
+        "cameraY"
+      ],
+      "x-og-variants": {
+        "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."
+      }
+    },
     "StripBlend": {
       "x-og-kind": "enum",
       "x-og-module": "render",
@@ -15107,45 +16037,14 @@
           "maximum": 1,
           "x-og-tunable": true
         },
-        "custom1": {
-          "$ref": "#/$defs/Post",
-          "description": "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.",
-          "default": 0
-        },
-        "custom2": {
-          "$ref": "#/$defs/Post",
-          "description": "The second custom post pass, over the first's output (0 skips the slot).",
-          "default": 0
-        },
-        "custom3": {
-          "$ref": "#/$defs/Post",
-          "description": "The third custom post pass.",
-          "default": 0
-        },
-        "custom4": {
-          "$ref": "#/$defs/Post",
-          "description": "The fourth custom post pass.",
-          "default": 0
-        },
-        "custom5": {
-          "$ref": "#/$defs/Post",
-          "description": "The fifth custom post pass.",
-          "default": 0
-        },
-        "custom6": {
-          "$ref": "#/$defs/Post",
-          "description": "The sixth custom post pass.",
-          "default": 0
-        },
-        "custom7": {
-          "$ref": "#/$defs/Post",
-          "description": "The seventh custom post pass.",
-          "default": 0
-        },
-        "custom8": {
-          "$ref": "#/$defs/Post",
-          "description": "The eighth and last custom post pass, over every one before it.",
-          "default": 0
+        "custom": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/Post"
+          },
+          "maxItems": 8,
+          "description": "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.",
+          "default": []
         }
       },
       "additionalProperties": false
@@ -16391,7 +17290,7 @@
     "SpriteDesc": {
       "x-og-kind": "desc",
       "x-og-module": "render",
-      "description": "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.",
+      "description": "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.",
       "type": "object",
       "properties": {
         "texture": {
@@ -16553,6 +17452,11 @@
           "description": "As three.js Material.toneMapped: true draws the sprite into the lit scene, carried by exposure (auto exposure included), bloom and the tone curve like any surface. false keeps its colours as given: still placed in the world, depth tested and sorted with the other sprites, but shown unexposed and uncurved (clamped to 0 to 1), outside bloom and fog; the grade, vignette, grain and screen flash still apply. For world UI that must read the same at noon and at dusk: speech bubbles, name tags, markers. Alpha blending only: an additive sprite adds light and is always tone mapped.",
           "default": true
         },
+        "facing": {
+          "$ref": "#/$defs/SpriteFacing",
+          "description": "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"
+        },
         "flipX": {
           "type": "boolean",
           "description": "Mirror the region left to right.",
@@ -16619,7 +17523,7 @@
     "Sprite": {
       "x-og-kind": "component",
       "x-og-module": "render",
-      "description": "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.\nSorted 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.",
+      "description": "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.\nSorted 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.",
       "type": "object",
       "properties": {
         "texture": {
@@ -16708,6 +17612,11 @@
           "description": "Within its layer, lower y draws in front: top-down characters, props and trees overlap by their feet.",
           "default": false
         },
+        "facing": {
+          "$ref": "#/$defs/SpriteFacing",
+          "description": "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.",
+          "default": "none"
+        },
         "flipX": {
           "type": "boolean",
           "description": "Mirror left to right (a character facing left).",
@@ -17194,7 +18103,7 @@
           "type": "integer",
           "minimum": 0,
           "maximum": 4294967295,
-          "description": "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)."
+          "description": "The most custom post passes a frame runs: 8 on every tier, PostEffects.custom's capacity."
         },
         "volumetricFog": {
           "$ref": "#/$defs/VolumetricFog",
@@ -17214,7 +18123,17 @@
         },
         "gpuTimestamps": {
           "type": "boolean",
-          "description": "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."
+          "description": "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."
+        },
+        "spriteAnisotropy": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "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."
+        },
+        "world3d": {
+          "type": "boolean",
+          "description": "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."
         }
       },
       "required": [
@@ -17235,7 +18154,9 @@
         "volumetricFog",
         "volumetricLights",
         "maxLightCookies",
-        "gpuTimestamps"
+        "gpuTimestamps",
+        "spriteAnisotropy",
+        "world3d"
       ],
       "additionalProperties": false
     },
@@ -17800,6 +18721,659 @@
       },
       "additionalProperties": false
     },
+    "ShapePoints": {
+      "x-og-kind": "struct",
+      "x-og-module": "render",
+      "description": "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.",
+      "type": "object",
+      "properties": {
+        "shape": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/Vector2"
+          },
+          "description": "The outline's points, in order."
+        },
+        "holes": {
+          "type": "array",
+          "items": {
+            "type": "array",
+            "items": {
+              "$ref": "#/$defs/Vector2"
+            }
+          },
+          "description": "Each hole's points, in order."
+        }
+      },
+      "required": [
+        "shape",
+        "holes"
+      ],
+      "additionalProperties": false
+    },
+    "ShapeGeometryDesc": {
+      "x-og-kind": "desc",
+      "x-og-module": "render",
+      "description": "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).",
+      "type": "object",
+      "properties": {
+        "shapes": {
+          "anyOf": [
+            {
+              "anyOf": [
+                {
+                  "x-og-type": "Path2"
+                },
+                {
+                  "anyOf": [
+                    {
+                      "type": "array",
+                      "items": {
+                        "x-og-type": "Path2"
+                      }
+                    },
+                    {
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/$defs/Vector2"
+                      }
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "description": "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
+        },
+        "curveSegments": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "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,
+          "minimum": 1
+        },
+        "uvRepeat": {
+          "$ref": "#/$defs/Vector2",
+          "description": "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
+          }
+        },
+        "physics": {
+          "type": "boolean",
+          "description": "Register it as a physics mesh too (BufferGeometryDesc.physics).",
+          "default": true
+        },
+        "dynamic": {
+          "type": "boolean",
+          "description": "Whether og.render.updateGeometry may rewrite it later (BufferGeometryDesc.dynamic).",
+          "default": false
+        }
+      },
+      "additionalProperties": false
+    },
+    "ExtrudeGeometryDesc": {
+      "x-og-kind": "desc",
+      "x-og-module": "render",
+      "description": "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).",
+      "type": "object",
+      "properties": {
+        "shapes": {
+          "anyOf": [
+            {
+              "anyOf": [
+                {
+                  "x-og-type": "Path2"
+                },
+                {
+                  "anyOf": [
+                    {
+                      "type": "array",
+                      "items": {
+                        "x-og-type": "Path2"
+                      }
+                    },
+                    {
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/$defs/Vector2"
+                      }
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "description": "One og.Shape, a list of them, or the outline's points. Without it, three.js's default square of side 1.",
+          "default": null
+        },
+        "depth": {
+          "type": "number",
+          "description": "How far the shape is pushed along +Z (without extrudePath).",
+          "default": 1,
+          "minimum": 0,
+          "x-og-unit": "m"
+        },
+        "steps": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "Rings along the depth or the path.",
+          "default": 1,
+          "minimum": 1
+        },
+        "bevelEnabled": {
+          "type": "boolean",
+          "description": "Round the edges of both faces.",
+          "default": true
+        },
+        "bevelThickness": {
+          "type": "number",
+          "description": "How far the bevel reaches beyond each face, along z.",
+          "default": 0.2,
+          "minimum": 0,
+          "x-og-unit": "m"
+        },
+        "bevelSize": {
+          "anyOf": [
+            {
+              "type": "number"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "description": "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": null,
+          "x-og-unit": "m"
+        },
+        "bevelOffset": {
+          "type": "number",
+          "description": "How far the bevel starts out from the outline.",
+          "default": 0,
+          "x-og-unit": "m"
+        },
+        "bevelSegments": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "Rings in each bevel.",
+          "default": 3,
+          "minimum": 1
+        },
+        "curveSegments": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "Points per curve when an og.Shape's curves are flattened.",
+          "default": 12,
+          "minimum": 1
+        },
+        "extrudePath": {
+          "$ref": "#/$defs/Path",
+          "description": "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": 0
+        },
+        "uvRepeat": {
+          "$ref": "#/$defs/Vector2",
+          "description": "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
+          }
+        },
+        "physics": {
+          "type": "boolean",
+          "description": "Register it as a physics mesh too.",
+          "default": true
+        },
+        "dynamic": {
+          "type": "boolean",
+          "description": "Whether og.render.updateGeometry may rewrite it later.",
+          "default": false
+        }
+      },
+      "additionalProperties": false
+    },
+    "LatheGeometryDesc": {
+      "x-og-kind": "desc",
+      "x-og-module": "render",
+      "description": "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.",
+      "type": "object",
+      "properties": {
+        "points": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/Vector2"
+          },
+          "description": "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": [],
+          "x-og-unit": "m"
+        },
+        "segments": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "Segments round the axis.",
+          "default": 12,
+          "minimum": 1
+        },
+        "phiStart": {
+          "type": "number",
+          "description": "Where the turn starts, from +Z towards +X.",
+          "default": 0,
+          "x-og-unit": "rad"
+        },
+        "phiLength": {
+          "type": "number",
+          "description": "How far it turns; 2 pi is whole (clamped to it).",
+          "default": 6.283185307179586,
+          "x-og-unit": "rad"
+        },
+        "uvRepeat": {
+          "$ref": "#/$defs/Vector2",
+          "description": "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
+          }
+        },
+        "physics": {
+          "type": "boolean",
+          "description": "Register it as a physics mesh too.",
+          "default": true
+        },
+        "dynamic": {
+          "type": "boolean",
+          "description": "Whether og.render.updateGeometry may rewrite it later.",
+          "default": false
+        }
+      },
+      "additionalProperties": false
+    },
+    "PolyhedronGeometryDesc": {
+      "x-og-kind": "desc",
+      "x-og-module": "render",
+      "description": "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.",
+      "type": "object",
+      "properties": {
+        "vertices": {
+          "type": "array",
+          "items": {
+            "type": "number"
+          },
+          "description": "The corners, x y z each (three.js's flat array).",
+          "default": []
+        },
+        "indices": {
+          "type": "array",
+          "items": {
+            "type": "integer",
+            "minimum": 0,
+            "maximum": 4294967295
+          },
+          "description": "The faces, three corner indices each, counter-clockwise seen from outside.",
+          "default": []
+        },
+        "radius": {
+          "type": "number",
+          "description": "The sphere the vertices are pushed onto.",
+          "default": 1,
+          "minimum": 0,
+          "x-og-unit": "m"
+        },
+        "detail": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "Subdivisions of each face: (detail + 1)² triangles a face.",
+          "default": 0,
+          "maximum": 64
+        },
+        "uvRepeat": {
+          "$ref": "#/$defs/Vector2",
+          "description": "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
+          }
+        },
+        "physics": {
+          "type": "boolean",
+          "description": "Register it as a physics mesh too.",
+          "default": true
+        },
+        "dynamic": {
+          "type": "boolean",
+          "description": "Whether og.render.updateGeometry may rewrite it later.",
+          "default": false
+        }
+      },
+      "additionalProperties": false
+    },
+    "SolidGeometryDesc": {
+      "x-og-kind": "desc",
+      "x-og-module": "render",
+      "description": "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.",
+      "type": "object",
+      "properties": {
+        "radius": {
+          "type": "number",
+          "description": "The radius.",
+          "default": 1,
+          "minimum": 0,
+          "x-og-unit": "m"
+        },
+        "detail": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "Subdivisions of each face.",
+          "default": 0,
+          "maximum": 64
+        },
+        "uvRepeat": {
+          "$ref": "#/$defs/Vector2",
+          "description": "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
+          }
+        },
+        "physics": {
+          "type": "boolean",
+          "description": "Register it as a physics mesh too.",
+          "default": true
+        },
+        "dynamic": {
+          "type": "boolean",
+          "description": "Whether og.render.updateGeometry may rewrite it later.",
+          "default": false
+        }
+      },
+      "additionalProperties": false
+    },
+    "SweepKey": {
+      "x-og-kind": "struct",
+      "x-og-module": "render",
+      "description": "A value at a fraction of a sweep's path: linear between keys, held before the first and past the last.",
+      "type": "object",
+      "properties": {
+        "t": {
+          "type": "number",
+          "description": "The fraction of the path's length, 0 to 1.",
+          "x-og-unit": "ratio"
+        },
+        "value": {
+          "type": "number",
+          "description": "The value there."
+        }
+      },
+      "required": [
+        "t",
+        "value"
+      ],
+      "additionalProperties": false
+    },
+    "SweepGeometryDesc": {
+      "x-og-kind": "desc",
+      "x-og-module": "render",
+      "description": "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.",
+      "type": "object",
+      "properties": {
+        "section": {
+          "anyOf": [
+            {
+              "anyOf": [
+                {
+                  "x-og-type": "Path2"
+                },
+                {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/$defs/Vector2"
+                  }
+                }
+              ]
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "description": "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
+        },
+        "path": {
+          "$ref": "#/$defs/Path",
+          "description": "The path (og.path.create or og.path.find).",
+          "default": 0
+        },
+        "steps": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "Rings along the path, less one.",
+          "default": 64,
+          "minimum": 1
+        },
+        "scale": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/SweepKey"
+          },
+          "description": "The section's scale over the path (none: 1 throughout). A horn: [{ t: 0, value: 1 }, { t: 1, value: 0.05 }].",
+          "default": []
+        },
+        "twist": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/SweepKey"
+          },
+          "description": "The section's turn round the path over its length, in radians (none: 0).",
+          "default": []
+        },
+        "caps": {
+          "type": "boolean",
+          "description": "Close the ends of an open path.",
+          "default": true
+        },
+        "curveSegments": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "Points per curve when an og.Shape section is flattened.",
+          "default": 12,
+          "minimum": 1
+        },
+        "uvRepeat": {
+          "$ref": "#/$defs/Vector2",
+          "description": "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
+          }
+        },
+        "physics": {
+          "type": "boolean",
+          "description": "Register it as a physics mesh too.",
+          "default": true
+        },
+        "dynamic": {
+          "type": "boolean",
+          "description": "Whether og.render.updateGeometry may rewrite it later.",
+          "default": false
+        }
+      },
+      "additionalProperties": false
+    },
+    "MirrorAxis": {
+      "x-og-kind": "enum",
+      "x-og-module": "render",
+      "description": "The world axis a part is mirrored along, after its placement.",
+      "type": "string",
+      "enum": [
+        "none",
+        "x",
+        "y",
+        "z"
+      ],
+      "x-og-variants": {
+        "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."
+      }
+    },
+    "GeometryPart": {
+      "x-og-kind": "desc",
+      "x-og-module": "render",
+      "description": "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.",
+      "type": "object",
+      "properties": {
+        "geometry": {
+          "$ref": "#/$defs/Geometry",
+          "description": "Any geometry: made, a primitive or a loaded glTF's.",
+          "default": 0
+        },
+        "position": {
+          "$ref": "#/$defs/Vector3",
+          "description": "Where it goes.",
+          "default": {
+            "x": 0,
+            "y": 0,
+            "z": 0
+          },
+          "x-og-unit": "m"
+        },
+        "quaternion": {
+          "$ref": "#/$defs/Quaternion",
+          "description": "How it turns.",
+          "default": {
+            "x": 0,
+            "y": 0,
+            "z": 0,
+            "w": 1
+          }
+        },
+        "scale": {
+          "$ref": "#/$defs/Vector3",
+          "description": "Its scale (a negative component mirrors it as `mirror` does).",
+          "default": {
+            "x": 1,
+            "y": 1,
+            "z": 1
+          }
+        },
+        "mirror": {
+          "$ref": "#/$defs/MirrorAxis",
+          "description": "Mirror it along a world axis after placing it: a symmetric prop is one half twice, the second mirrored.",
+          "default": "none"
+        }
+      },
+      "additionalProperties": false
+    },
+    "CsgOp": {
+      "x-og-kind": "enum",
+      "x-og-module": "render",
+      "description": "A boolean operation on two solids.",
+      "type": "string",
+      "enum": [
+        "union",
+        "subtract",
+        "intersect"
+      ],
+      "x-og-variants": {
+        "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."
+      }
+    },
+    "CsgGeometryDesc": {
+      "x-og-kind": "desc",
+      "x-og-module": "render",
+      "description": "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.",
+      "type": "object",
+      "properties": {
+        "op": {
+          "$ref": "#/$defs/CsgOp",
+          "description": "The operation.",
+          "default": "union"
+        },
+        "a": {
+          "$ref": "#/$defs/GeometryPart",
+          "description": "The first operand.",
+          "default": {}
+        },
+        "b": {
+          "$ref": "#/$defs/GeometryPart",
+          "description": "The second operand.",
+          "default": {}
+        },
+        "uvRepeat": {
+          "$ref": "#/$defs/Vector2",
+          "description": "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
+          }
+        },
+        "physics": {
+          "type": "boolean",
+          "description": "Register it as a physics mesh too.",
+          "default": true
+        },
+        "dynamic": {
+          "type": "boolean",
+          "description": "Whether og.render.updateGeometry may rewrite it later.",
+          "default": false
+        }
+      },
+      "additionalProperties": false
+    },
+    "MergeGeometriesDesc": {
+      "x-og-kind": "desc",
+      "x-og-module": "render",
+      "description": "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.",
+      "type": "object",
+      "properties": {
+        "parts": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/GeometryPart"
+          },
+          "description": "The parts, in order (at least one).",
+          "default": []
+        },
+        "uvRepeat": {
+          "$ref": "#/$defs/Vector2",
+          "description": "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
+          }
+        },
+        "physics": {
+          "type": "boolean",
+          "description": "Register it as a physics mesh too.",
+          "default": true
+        },
+        "dynamic": {
+          "type": "boolean",
+          "description": "Whether og.render.updateGeometry may rewrite it later.",
+          "default": false
+        }
+      },
+      "additionalProperties": false
+    },
     "LineMode": {
       "x-og-kind": "enum",
       "x-og-module": "render",
@@ -19002,7 +20576,7 @@
         },
         "lodBias": {
           "type": "number",
-          "description": "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.",
+          "description": "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,
           "minimum": 0,
           "maximum": 16,
@@ -19364,7 +20938,7 @@
     "CollisionStarted": {
       "x-og-kind": "event",
       "x-og-module": "physics",
-      "description": "Two solid colliders started touching during the tick.",
+      "description": "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.",
       "type": "object",
       "properties": {
         "a": {
@@ -19377,18 +20951,32 @@
         },
         "point": {
           "$ref": "#/$defs/Vector3",
-          "description": "The deepest contact point in world space (z is 0 in 2D)."
+          "description": "The deepest contact point in world space (z is 0 in 2D).",
+          "x-og-unit": "m"
         },
         "normal": {
           "$ref": "#/$defs/Vector3",
           "description": "The contact normal, from a towards b."
+        },
+        "impulse": {
+          "type": "number",
+          "description": "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.",
+          "minimum": 0,
+          "x-og-unit": "newtonSecond"
+        },
+        "relativeVelocity": {
+          "$ref": "#/$defs/Vector3",
+          "description": "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.",
+          "x-og-unit": "mps"
         }
       },
       "required": [
         "a",
         "b",
         "point",
-        "normal"
+        "normal",
+        "impulse",
+        "relativeVelocity"
       ],
       "additionalProperties": false
     },
@@ -22869,6 +24457,427 @@
       },
       "additionalProperties": false
     },
+    "LookAt": {
+      "x-og-kind": "component",
+      "x-og-module": "anim",
+      "description": "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.",
+      "type": "object",
+      "properties": {
+        "skeleton": {
+          "$ref": "#/$defs/Entity",
+          "description": "The entity with the og.Skeleton this constraint turns.",
+          "default": 0
+        },
+        "joint": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "The joint that aims (an index into the skin's joints): the head, an eye.",
+          "default": 0,
+          "minimum": 0
+        },
+        "bones": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "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,
+          "minimum": 1,
+          "maximum": 8
+        },
+        "target": {
+          "$ref": "#/$defs/Vector3",
+          "description": "The point to look at, in `space`.",
+          "default": {
+            "x": 0,
+            "y": 0,
+            "z": 0
+          },
+          "x-og-unit": "m"
+        },
+        "space": {
+          "$ref": "#/$defs/IkSpace",
+          "description": "What `target` and `up` are relative to: world (the frame the skeleton entity's og.Transform is in) or model.",
+          "default": "world"
+        },
+        "axis": {
+          "$ref": "#/$defs/Vector3",
+          "description": "The joint's forward, in its own frame: the axis turned onto the target.",
+          "default": {
+            "x": 0,
+            "y": 0,
+            "z": 1
+          }
+        },
+        "upAxis": {
+          "$ref": "#/$defs/Vector3",
+          "description": "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
+          }
+        },
+        "up": {
+          "$ref": "#/$defs/Vector3",
+          "description": "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
+          }
+        },
+        "maxYaw": {
+          "type": "number",
+          "description": "The largest turn about `upAxis`, left or right of the animated forward.",
+          "default": 3.1416,
+          "minimum": 0,
+          "maximum": 3.1416,
+          "x-og-unit": "rad",
+          "x-og-tunable": true
+        },
+        "maxPitch": {
+          "type": "number",
+          "description": "The largest turn towards or away from `upAxis`, from the animated forward.",
+          "default": 1.5708,
+          "minimum": 0,
+          "maximum": 1.5708,
+          "x-og-unit": "rad",
+          "x-og-tunable": true
+        },
+        "weight": {
+          "type": "number",
+          "description": "How much of the turn is applied (0 = the animated pose, 1 = aimed).",
+          "default": 1,
+          "minimum": 0,
+          "maximum": 1,
+          "x-og-tunable": true
+        },
+        "clamped": {
+          "type": "boolean",
+          "description": "Written: the target lay outside maxYaw or maxPitch, so the joint aims at the nearest direction inside them.",
+          "default": false,
+          "readOnly": true
+        }
+      },
+      "additionalProperties": false
+    },
+    "JointLimit": {
+      "x-og-kind": "component",
+      "x-og-module": "anim",
+      "description": "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.",
+      "type": "object",
+      "properties": {
+        "skeleton": {
+          "$ref": "#/$defs/Entity",
+          "description": "The entity with the og.Skeleton whose joint this limits.",
+          "default": 0
+        },
+        "joint": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "The limited joint (an index into the skin's joints).",
+          "default": 0,
+          "minimum": 0
+        },
+        "axis": {
+          "$ref": "#/$defs/Vector3",
+          "description": "The twist axis in the joint's rest frame: along the bone for a ball joint, along the hinge for a hinge.",
+          "default": {
+            "x": 0,
+            "y": 1,
+            "z": 0
+          }
+        },
+        "swing": {
+          "type": "number",
+          "description": "The cone half-angle the axis may swing away from its rest direction (0 locks it: a hinge; pi is free).",
+          "default": 3.1416,
+          "minimum": 0,
+          "maximum": 3.1416,
+          "x-og-unit": "rad",
+          "x-og-tunable": true
+        },
+        "twistMin": {
+          "type": "number",
+          "description": "The least twist about `axis` from rest (a hinge's bend one way).",
+          "default": -3.1416,
+          "minimum": -3.1416,
+          "maximum": 3.1416,
+          "x-og-unit": "rad",
+          "x-og-tunable": true
+        },
+        "twistMax": {
+          "type": "number",
+          "description": "The most twist about `axis` from rest (a hinge's bend the other way).",
+          "default": 3.1416,
+          "minimum": -3.1416,
+          "maximum": 3.1416,
+          "x-og-unit": "rad",
+          "x-og-tunable": true
+        }
+      },
+      "additionalProperties": false
+    },
+    "FootLock": {
+      "x-og-kind": "component",
+      "x-og-module": "anim",
+      "description": "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).",
+      "type": "object",
+      "properties": {
+        "skeleton": {
+          "$ref": "#/$defs/Entity",
+          "description": "The entity with the og.Skeleton whose foot this holds.",
+          "default": 0
+        },
+        "foot": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "The foot joint (an index into the skin's joints); the two bones above it are the leg that bends.",
+          "default": 0,
+          "minimum": 0
+        },
+        "weight": {
+          "type": "number",
+          "description": "How much of the lock is applied (0 = the animated foot, 1 = held).",
+          "default": 1,
+          "minimum": 0,
+          "maximum": 1,
+          "x-og-tunable": true
+        },
+        "release": {
+          "type": "number",
+          "description": "Seconds the foot takes to rejoin its animation once lifted (0: at once).",
+          "default": 0.15,
+          "minimum": 0,
+          "maximum": 2,
+          "x-og-unit": "s",
+          "x-og-tunable": true
+        },
+        "maxDistance": {
+          "type": "number",
+          "description": "Farther than this from where the animation puts the foot, the lock lets go (a leg cannot stretch).",
+          "default": 0.5,
+          "minimum": 0,
+          "x-og-unit": "m",
+          "x-og-tunable": true
+        },
+        "planted": {
+          "type": "boolean",
+          "description": "Written: the playing clips plant the foot this tick.",
+          "default": false,
+          "readOnly": true
+        },
+        "locked": {
+          "type": "boolean",
+          "description": "Written: the foot is held at its lock this tick.",
+          "default": false,
+          "readOnly": true
+        }
+      },
+      "additionalProperties": false
+    },
+    "SpringSpace": {
+      "x-og-kind": "enum",
+      "x-og-module": "anim",
+      "description": "Where a spring bone's tails move.",
+      "type": "string",
+      "enum": [
+        "world",
+        "model"
+      ],
+      "x-og-variants": {
+        "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)."
+      }
+    },
+    "SpringBone": {
+      "x-og-kind": "component",
+      "x-og-module": "anim",
+      "description": "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.",
+      "type": "object",
+      "properties": {
+        "skeleton": {
+          "$ref": "#/$defs/Entity",
+          "description": "The entity with the og.Skeleton whose joints this swings.",
+          "default": 0
+        },
+        "joint": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "The chain's last joint (an index into the skin's joints): the tip of a tail, an ear.",
+          "default": 0,
+          "minimum": 0
+        },
+        "bones": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "How many joints swing: `joint` and its parents (1 is the joint alone).",
+          "default": 1,
+          "minimum": 1,
+          "maximum": 16
+        },
+        "frequency": {
+          "type": "number",
+          "description": "How fast a tail springs back to its animated place: the spring's natural frequency (0: no spring, it only hangs and swings).",
+          "default": 3,
+          "minimum": 0,
+          "maximum": 30,
+          "x-og-unit": "hz",
+          "x-og-tunable": true
+        },
+        "damping": {
+          "type": "number",
+          "description": "The damping ratio: 0 swings on, 1 settles without overshooting (critical damping).",
+          "default": 0.3,
+          "minimum": 0,
+          "maximum": 2,
+          "x-og-tunable": true
+        },
+        "tipFrequency": {
+          "type": "number",
+          "description": "The last joint's frequency as a multiple of `frequency`, the joints between in proportion along the chain (1: every joint alike; 0.25: the tip springs back four times slower than the top, a soft strand on a stiff root).",
+          "default": 1,
+          "minimum": 0,
+          "maximum": 4,
+          "x-og-tunable": true
+        },
+        "tipDamping": {
+          "type": "number",
+          "description": "The last joint's damping ratio as a multiple of `damping`, the joints between in proportion along the chain (1: every joint alike).",
+          "default": 1,
+          "minimum": 0,
+          "maximum": 4,
+          "x-og-tunable": true
+        },
+        "gravity": {
+          "$ref": "#/$defs/Vector3",
+          "description": "An acceleration on every tail, in `space` (three-vrm's gravityDir times gravityPower): (0, -9.8, 0) makes a chain droop.",
+          "default": {
+            "x": 0,
+            "y": 0,
+            "z": 0
+          },
+          "x-og-unit": "mps2"
+        },
+        "space": {
+          "$ref": "#/$defs/SpringSpace",
+          "description": "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).",
+          "default": "world"
+        },
+        "weight": {
+          "type": "number",
+          "description": "How much of the swing is applied (0 = the animated pose, 1 = the spring's).",
+          "default": 1,
+          "minimum": 0,
+          "maximum": 1,
+          "x-og-tunable": true
+        },
+        "radius": {
+          "type": "number",
+          "description": "The tails' radius against og.SpringCollider (three-vrm's hitRadius): a tail stays this far outside every collider it meets (0: a point).",
+          "default": 0,
+          "minimum": 0,
+          "x-og-unit": "m",
+          "x-og-tunable": true
+        },
+        "colliders": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "The og.SpringCollider layers the tails are pushed out of, as bits: a collider on the same skeleton counts when its `layers` meet these.",
+          "default": 4294967295
+        },
+        "lag": {
+          "type": "number",
+          "description": "Written: the farthest a tail is from its animated place this tick.",
+          "default": 0,
+          "x-og-unit": "m",
+          "readOnly": true
+        }
+      },
+      "additionalProperties": false
+    },
+    "SpringColliderShape": {
+      "x-og-kind": "enum",
+      "x-og-module": "anim",
+      "description": "The shape of a spring collider.",
+      "type": "string",
+      "enum": [
+        "sphere",
+        "capsule"
+      ],
+      "x-og-variants": {
+        "sphere": "A ball of `radius` about `offset`.",
+        "capsule": "A capsule of `radius` about the segment from `offset` to `tail`."
+      }
+    },
+    "SpringCollider": {
+      "x-og-kind": "component",
+      "x-og-module": "anim",
+      "description": "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.",
+      "type": "object",
+      "properties": {
+        "skeleton": {
+          "$ref": "#/$defs/Entity",
+          "description": "The entity with the og.Skeleton whose spring bones this keeps out.",
+          "default": 0
+        },
+        "joint": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "The joint the collider rides on (an index into the skin's joints).",
+          "default": 0,
+          "minimum": 0
+        },
+        "shape": {
+          "$ref": "#/$defs/SpringColliderShape",
+          "description": "A sphere about `offset`, or a capsule from `offset` to `tail`.",
+          "default": "sphere"
+        },
+        "offset": {
+          "$ref": "#/$defs/Vector3",
+          "description": "The sphere's centre, or the capsule's first end, in the joint's frame.",
+          "default": {
+            "x": 0,
+            "y": 0,
+            "z": 0
+          },
+          "x-og-unit": "m"
+        },
+        "tail": {
+          "$ref": "#/$defs/Vector3",
+          "description": "The capsule's other end, in the joint's frame (a sphere ignores it).",
+          "default": {
+            "x": 0,
+            "y": 0,
+            "z": 0
+          },
+          "x-og-unit": "m"
+        },
+        "radius": {
+          "type": "number",
+          "description": "The radius, in metres of the skeleton's model space (the joint's own scale does not apply).",
+          "default": 0.1,
+          "minimum": 0,
+          "x-og-unit": "m",
+          "x-og-tunable": true
+        },
+        "layers": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "The layers this collider is on, as bits (a spring bone's `colliders` picks them).",
+          "default": 1
+        }
+      },
+      "additionalProperties": false
+    },
     "AnimationEvent": {
       "x-og-kind": "event",
       "x-og-module": "anim",
@@ -23015,7 +25024,7 @@
     "Rig": {
       "x-og-kind": "handle",
       "x-og-module": "anim",
-      "description": "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.",
+      "description": "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.",
       "type": "integer",
       "minimum": 0
     },
@@ -23027,7 +25036,7 @@
       "properties": {
         "bone": {
           "type": "string",
-          "description": "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."
+          "description": "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."
         },
         "node": {
           "type": "string",
@@ -23122,6 +25131,25 @@
       },
       "additionalProperties": false
     },
+    "MirrorDesc": {
+      "x-og-kind": "desc",
+      "x-og-module": "anim",
+      "description": "A clip to play on the other side of the skeleton it was made for.",
+      "type": "object",
+      "properties": {
+        "clip": {
+          "$ref": "#/$defs/ClipAsset",
+          "description": "The clip, made for `skeleton`.",
+          "default": 0
+        },
+        "skeleton": {
+          "$ref": "#/$defs/SkeletonAsset",
+          "description": "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
+        }
+      },
+      "additionalProperties": false
+    },
     "FlipbookSheet": {
       "x-og-kind": "handle",
       "x-og-module": "anim",
@@ -23406,6 +25434,14 @@
           "description": "The sprite layer it draws in, sorted with the sprites there (after them when they share the layer).",
           "default": 0
         },
+        "skin": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "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.",
+          "default": 0,
+          "minimum": 0
+        },
         "finished": {
           "type": "boolean",
           "description": "Written: a clip that does not loop reached its end (or its start, played backwards).",
@@ -23418,7 +25454,7 @@
     "Skeleton2DEvent": {
       "x-og-kind": "event",
       "x-og-module": "anim",
-      "description": "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.",
+      "description": "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.",
       "type": "object",
       "properties": {
         "entity": {
@@ -23439,13 +25475,18 @@
           "type": "number",
           "description": "The event's time in the clip.",
           "x-og-unit": "s"
+        },
+        "armature": {
+          "type": "string",
+          "description": "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)."
         }
       },
       "required": [
         "entity",
         "clip",
         "name",
-        "time"
+        "time",
+        "armature"
       ],
       "additionalProperties": false
     },
@@ -23589,6 +25630,13 @@
           },
           "description": "The IK constraints' names: an index here is IkTarget2D.constraint."
         },
+        "skins": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "Its skins' names, `default` (the rig's own attachments) first: an index here is Skeleton2D.skin."
+        },
         "clips": {
           "type": "array",
           "items": {
@@ -23604,6 +25652,7 @@
         "bones",
         "slots",
         "constraints",
+        "skins",
         "clips"
       ],
       "additionalProperties": false
@@ -24271,6 +26320,34 @@
         "ui": "Interface sounds."
       }
     },
+    "PanningModel": {
+      "x-og-kind": "enum",
+      "x-og-module": "audio",
+      "description": "How an AudioListener places spatial sources between the ears, as Web Audio's PannerNode.panningModel.",
+      "type": "string",
+      "enum": [
+        "equalpower",
+        "hrtf"
+      ],
+      "x-og-variants": {
+        "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)."
+      }
+    },
+    "AudioResampler": {
+      "x-og-kind": "enum",
+      "x-og-module": "audio",
+      "description": "How the mixer resamples a voice whose pitch or sound rate differs from the output's.",
+      "type": "string",
+      "enum": [
+        "linear",
+        "sinc"
+      ],
+      "x-og-variants": {
+        "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."
+      }
+    },
     "AudioSource": {
       "x-og-kind": "component",
       "x-og-module": "audio",
@@ -24417,6 +26494,50 @@
           "maximum": 30,
           "x-og-unit": "s",
           "x-og-tunable": true
+        },
+        "dopplerFactor": {
+          "type": "number",
+          "description": "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,
+          "minimum": 0,
+          "maximum": 10,
+          "x-og-tunable": true
+        },
+        "coneInnerAngle": {
+          "type": "number",
+          "description": "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,
+          "minimum": 0,
+          "maximum": 360,
+          "x-og-unit": "deg",
+          "x-og-tunable": true
+        },
+        "coneOuterAngle": {
+          "type": "number",
+          "description": "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,
+          "minimum": 0,
+          "maximum": 360,
+          "x-og-unit": "deg",
+          "x-og-tunable": true
+        },
+        "coneOuterGain": {
+          "type": "number",
+          "description": "The gain outside coneOuterAngle.",
+          "default": 0,
+          "minimum": 0,
+          "maximum": 1,
+          "x-og-tunable": true
+        },
+        "virtualize": {
+          "type": "boolean",
+          "description": "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).",
+          "default": false
+        },
+        "retrigger": {
+          "type": "boolean",
+          "description": "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.",
+          "default": false
         }
       },
       "additionalProperties": false
@@ -24434,6 +26555,19 @@
           "minimum": 0,
           "maximum": 4,
           "x-og-tunable": true
+        },
+        "dopplerFactor": {
+          "type": "number",
+          "description": "Scales every spatial source's Doppler shift (AudioSource.dopplerFactor); 0 turns Doppler off for this listener.",
+          "default": 1,
+          "minimum": 0,
+          "maximum": 10,
+          "x-og-tunable": true
+        },
+        "panningModel": {
+          "$ref": "#/$defs/PanningModel",
+          "description": "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"
         }
       },
       "additionalProperties": false
@@ -24525,6 +26659,20 @@
           "minimum": 0,
           "x-og-unit": "s",
           "readOnly": true
+        },
+        "speedOfSound": {
+          "type": "number",
+          "description": "The speed of sound Doppler shifts are computed against (AudioSource.dopplerFactor).",
+          "default": 343.3,
+          "minimum": 1,
+          "maximum": 10000,
+          "x-og-unit": "mps",
+          "x-og-tunable": true
+        },
+        "resampler": {
+          "$ref": "#/$defs/AudioResampler",
+          "description": "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"
         }
       },
       "additionalProperties": false
@@ -24882,7 +27030,7 @@
           "type": "integer",
           "minimum": 0,
           "maximum": 4294967295,
-          "description": "Why: SOUND_FINISHED (0), SOUND_STOPPED (1), SOUND_REMOVED (2), SOUND_REPLACED (3) or SOUND_CULLED (4)."
+          "description": "Why: SOUND_FINISHED (0), SOUND_STOPPED (1), SOUND_REMOVED (2), SOUND_REPLACED (3), SOUND_CULLED (4) or SOUND_RETRIGGERED (5)."
         }
       },
       "required": [
@@ -30525,22 +32673,6 @@
       ],
       "additionalProperties": false
     },
-    "GraphicsQuality": {
-      "x-og-kind": "enum",
-      "x-og-module": "ui",
-      "description": "A graphics quality preset.",
-      "type": "string",
-      "enum": [
-        "medium",
-        "low",
-        "high"
-      ],
-      "x-og-variants": {
-        "medium": "Medium.",
-        "low": "Low: the fewest effects.",
-        "high": "High: every effect."
-      }
-    },
     "MenuItem": {
       "x-og-kind": "desc",
       "x-og-module": "ui",
@@ -30860,6 +32992,18 @@
           "description": "Called when the screen closes after changes (persist here).",
           "default": null
         },
+        "world": {
+          "anyOf": [
+            {
+              "x-og-type": "World"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "description": "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
+        },
         "title": {
           "type": "string",
           "description": "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).",
@@ -35387,6 +37531,18 @@
         "castShadows": {
           "type": "boolean",
           "description": "Its terrain file's `castShadows`."
+        },
+        "seaLevel": {
+          "anyOf": [
+            {
+              "type": "number"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "description": "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.",
+          "x-og-unit": "m"
         }
       },
       "required": [
@@ -35399,7 +37555,8 @@
         "maxHeight",
         "layers",
         "collision",
-        "castShadows"
+        "castShadows",
+        "seaLevel"
       ],
       "additionalProperties": false
     },