@origingame/engine 0.3.0 → 0.4.0

package/schema/api.schema.json

@@ -1614,7 +1614,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()`, `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.",
       "place": "top",
       "publish": true,
       "types": [
@@ -1629,7 +1629,8 @@
         "Quaternion",
         "Matrix4",
         "Color",
-        "str"
+        "str",
+        "list"
       ],
       "consts": [],
       "functions": [
@@ -2753,6 +2754,9 @@
         "SpotLight",
         "ToneMapping",
         "ToneMapping",
+        "GraphicsQuality",
+        "QualityPreset",
+        "QualityPreset",
         "RenderSettings",
         "Lut",
         "EnvironmentMap",
@@ -2814,6 +2818,19 @@
         "RingGeometryDesc",
         "CircleGeometryDesc",
         "TubeGeometryDesc",
+        "ShapePoints",
+        "ShapeGeometryDesc",
+        "ExtrudeGeometryDesc",
+        "LatheGeometryDesc",
+        "PolyhedronGeometryDesc",
+        "SolidGeometryDesc",
+        "SweepKey",
+        "SweepGeometryDesc",
+        "MirrorAxis",
+        "GeometryPart",
+        "CsgOp",
+        "CsgGeometryDesc",
+        "MergeGeometriesDesc",
         "LineMode",
         "LineMode",
         "LinesDesc",
@@ -3170,6 +3187,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 +3467,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 +3819,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 +3849,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.",
@@ -3670,7 +4447,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 +4639,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",
@@ -6969,7 +7746,6 @@
         "WipeSide",
         "ScreenTransitionDesc",
         "ScreenTransitionResult",
-        "GraphicsQuality",
         "MenuItem",
         "MenuResult",
         "MainMenuDesc",
@@ -9758,7 +10534,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 +15297,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 +15422,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 +15432,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
@@ -15107,45 +15972,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
@@ -17194,7 +18028,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 +18048,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 +18079,9 @@
         "volumetricFog",
         "volumetricLights",
         "maxLightCookies",
-        "gpuTimestamps"
+        "gpuTimestamps",
+        "spriteAnisotropy",
+        "world3d"
       ],
       "additionalProperties": false
     },
@@ -17431,149 +18277,718 @@
           "type": "integer",
           "minimum": 0,
           "maximum": 4294967295,
-          "description": "Vertices."
+          "description": "Vertices."
+        },
+        "triangles": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "Triangles."
+        },
+        "min": {
+          "$ref": "#/$defs/Vector3",
+          "description": "The bounds' least corner in the geometry's own space, as three.js boundingBox.min.",
+          "x-og-unit": "m"
+        },
+        "max": {
+          "$ref": "#/$defs/Vector3",
+          "description": "The bounds' greatest corner.",
+          "x-og-unit": "m"
+        },
+        "dynamic": {
+          "type": "boolean",
+          "description": "Whether og.render.updateGeometry may rewrite it."
+        }
+      },
+      "required": [
+        "vertices",
+        "triangles",
+        "min",
+        "max",
+        "dynamic"
+      ],
+      "additionalProperties": false
+    },
+    "CylinderGeometryDesc": {
+      "x-og-kind": "desc",
+      "x-og-module": "render",
+      "description": "A cylinder (or a truncated cone) along +Y centred at the origin, as three.js CylinderGeometry(radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength).",
+      "type": "object",
+      "properties": {
+        "radiusTop": {
+          "type": "number",
+          "description": "The radius at the top.",
+          "default": 1,
+          "minimum": 0,
+          "x-og-unit": "m"
+        },
+        "radiusBottom": {
+          "type": "number",
+          "description": "The radius at the bottom.",
+          "default": 1,
+          "minimum": 0,
+          "x-og-unit": "m"
+        },
+        "height": {
+          "type": "number",
+          "description": "Its extent along y.",
+          "default": 1,
+          "minimum": 0,
+          "x-og-unit": "m"
+        },
+        "radialSegments": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "Segments around.",
+          "default": 32,
+          "minimum": 3
+        },
+        "heightSegments": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "Rows along the height.",
+          "default": 1,
+          "minimum": 1
+        },
+        "openEnded": {
+          "type": "boolean",
+          "description": "Leave the ends open (no caps).",
+          "default": false
+        },
+        "thetaStart": {
+          "type": "number",
+          "description": "Where the side starts around y, from +Z towards +X.",
+          "default": 0,
+          "x-og-unit": "rad"
+        },
+        "thetaLength": {
+          "type": "number",
+          "description": "How far around the side goes; 2 pi is whole.",
+          "default": 6.283185307179586,
+          "x-og-unit": "rad"
+        }
+      },
+      "additionalProperties": false
+    },
+    "ConeGeometryDesc": {
+      "x-og-kind": "desc",
+      "x-og-module": "render",
+      "description": "A cone along +Y centred at the origin, its tip up, as three.js ConeGeometry(radius, height, radialSegments, heightSegments, openEnded).",
+      "type": "object",
+      "properties": {
+        "radius": {
+          "type": "number",
+          "description": "The base's radius.",
+          "default": 1,
+          "minimum": 0,
+          "x-og-unit": "m"
+        },
+        "height": {
+          "type": "number",
+          "description": "Its extent along y.",
+          "default": 1,
+          "minimum": 0,
+          "x-og-unit": "m"
+        },
+        "radialSegments": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "Segments around.",
+          "default": 32,
+          "minimum": 3
+        },
+        "heightSegments": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "Rows along the height.",
+          "default": 1,
+          "minimum": 1
+        },
+        "openEnded": {
+          "type": "boolean",
+          "description": "Leave the base open.",
+          "default": false
+        }
+      },
+      "additionalProperties": false
+    },
+    "CapsuleGeometryDesc": {
+      "x-og-kind": "desc",
+      "x-og-module": "render",
+      "description": "A capsule along +Y centred at the origin, as three.js CapsuleGeometry(radius, height, capSegments, radialSegments, heightSegments): a cylinder of `height` between two hemispheres, `height + 2 radius` long in all (an og.Collider capsule of halfHeight height / 2 and that radius matches it).",
+      "type": "object",
+      "properties": {
+        "radius": {
+          "type": "number",
+          "description": "The radius.",
+          "default": 1,
+          "minimum": 0,
+          "x-og-unit": "m"
+        },
+        "height": {
+          "type": "number",
+          "description": "The straight middle's length.",
+          "default": 1,
+          "minimum": 0,
+          "x-og-unit": "m"
+        },
+        "capSegments": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "Rows in each hemisphere.",
+          "default": 4,
+          "minimum": 1
+        },
+        "radialSegments": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "Segments around.",
+          "default": 8,
+          "minimum": 3
+        },
+        "heightSegments": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "Rows along the middle.",
+          "default": 1,
+          "minimum": 1
+        }
+      },
+      "additionalProperties": false
+    },
+    "TorusGeometryDesc": {
+      "x-og-kind": "desc",
+      "x-og-module": "render",
+      "description": "A torus in the xy plane around +Z, as three.js TorusGeometry(radius, tube, radialSegments, tubularSegments, arc).",
+      "type": "object",
+      "properties": {
+        "radius": {
+          "type": "number",
+          "description": "From the centre to the tube's centre.",
+          "default": 1,
+          "minimum": 0,
+          "x-og-unit": "m"
+        },
+        "tube": {
+          "type": "number",
+          "description": "The tube's radius.",
+          "default": 0.4,
+          "minimum": 0,
+          "x-og-unit": "m"
+        },
+        "radialSegments": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "Segments around the tube.",
+          "default": 12,
+          "minimum": 2
+        },
+        "tubularSegments": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "Segments around the ring.",
+          "default": 48,
+          "minimum": 3
+        },
+        "arc": {
+          "type": "number",
+          "description": "How far around the ring goes.",
+          "default": 6.283185307179586,
+          "x-og-unit": "rad"
+        }
+      },
+      "additionalProperties": false
+    },
+    "RingGeometryDesc": {
+      "x-og-kind": "desc",
+      "x-og-module": "render",
+      "description": "A flat ring in the xy plane facing +Z, as three.js RingGeometry(innerRadius, outerRadius, thetaSegments, phiSegments, thetaStart, thetaLength).",
+      "type": "object",
+      "properties": {
+        "innerRadius": {
+          "type": "number",
+          "description": "The hole's radius.",
+          "default": 0.5,
+          "minimum": 0,
+          "x-og-unit": "m"
+        },
+        "outerRadius": {
+          "type": "number",
+          "description": "The ring's radius.",
+          "default": 1,
+          "minimum": 0,
+          "x-og-unit": "m"
+        },
+        "thetaSegments": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "Segments around.",
+          "default": 32,
+          "minimum": 3
+        },
+        "phiSegments": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "Rings from the inside out.",
+          "default": 1,
+          "minimum": 1
+        },
+        "thetaStart": {
+          "type": "number",
+          "description": "Where it starts, from +X towards +Y.",
+          "default": 0,
+          "x-og-unit": "rad"
+        },
+        "thetaLength": {
+          "type": "number",
+          "description": "How far around it goes.",
+          "default": 6.283185307179586,
+          "x-og-unit": "rad"
+        }
+      },
+      "additionalProperties": false
+    },
+    "CircleGeometryDesc": {
+      "x-og-kind": "desc",
+      "x-og-module": "render",
+      "description": "A disc (or a sector) in the xy plane facing +Z, as three.js CircleGeometry(radius, segments, thetaStart, thetaLength): a 2D polygon's simplest shape.",
+      "type": "object",
+      "properties": {
+        "radius": {
+          "type": "number",
+          "description": "The radius.",
+          "default": 1,
+          "minimum": 0,
+          "x-og-unit": "m"
+        },
+        "segments": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "Segments around.",
+          "default": 32,
+          "minimum": 3
+        },
+        "thetaStart": {
+          "type": "number",
+          "description": "Where it starts, from +X towards +Y.",
+          "default": 0,
+          "x-og-unit": "rad"
+        },
+        "thetaLength": {
+          "type": "number",
+          "description": "How far around it goes.",
+          "default": 6.283185307179586,
+          "x-og-unit": "rad"
+        }
+      },
+      "additionalProperties": false
+    },
+    "TubeGeometryDesc": {
+      "x-og-kind": "desc",
+      "x-og-module": "render",
+      "description": "A tube along a curve, as three.js TubeGeometry(curve, tubularSegments, radius, radialSegments, closed): its rings are evenly spaced along the curve's length (three.js getPointAt), u runs along it, v around. The curve is `path` when set (an og.path, whatever its kind, followed exactly: a scene's or a timeline's path becomes a tube), otherwise new CatmullRomCurve3(points, closed, 'centripetal') through `points`, which may come from anywhere: a rope's points, a spline a tool made.",
+      "type": "object",
+      "properties": {
+        "points": {
+          "type": "array",
+          "items": {
+            "$ref": "#/$defs/Vector3"
+          },
+          "description": "The points the curve passes through, in order (at least two), when `path` is 0.",
+          "default": [],
+          "x-og-unit": "m"
+        },
+        "path": {
+          "$ref": "#/$defs/Path",
+          "description": "A path (og.path.create, or a scene's `path` by og.path.find) the tube follows instead of the points: its own curve, kind and closed flag (`closed` is the path's then). 0 uses the points.",
+          "default": 0
+        },
+        "tubularSegments": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "Segments along the tube.",
+          "default": 64,
+          "minimum": 1
+        },
+        "radius": {
+          "type": "number",
+          "description": "The tube's radius.",
+          "default": 1,
+          "minimum": 0,
+          "x-og-unit": "m"
+        },
+        "radialSegments": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 4294967295,
+          "description": "Segments around it.",
+          "default": 8,
+          "minimum": 3
+        },
+        "closed": {
+          "type": "boolean",
+          "description": "Join the last point back to the first.",
+          "default": false
+        }
+      },
+      "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
         },
-        "triangles": {
+        "curveSegments": {
           "type": "integer",
           "minimum": 0,
           "maximum": 4294967295,
-          "description": "Triangles."
+          "description": "Points per curve when an og.Shape's curves are flattened.",
+          "default": 12,
+          "minimum": 1
         },
-        "min": {
-          "$ref": "#/$defs/Vector3",
-          "description": "The bounds' least corner in the geometry's own space, as three.js boundingBox.min.",
-          "x-og-unit": "m"
+        "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
         },
-        "max": {
-          "$ref": "#/$defs/Vector3",
-          "description": "The bounds' greatest corner.",
-          "x-og-unit": "m"
+        "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."
+          "description": "Whether og.render.updateGeometry may rewrite it later.",
+          "default": false
         }
       },
-      "required": [
-        "vertices",
-        "triangles",
-        "min",
-        "max",
-        "dynamic"
-      ],
       "additionalProperties": false
     },
-    "CylinderGeometryDesc": {
+    "LatheGeometryDesc": {
       "x-og-kind": "desc",
       "x-og-module": "render",
-      "description": "A cylinder (or a truncated cone) along +Y centred at the origin, as three.js CylinderGeometry(radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength).",
+      "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": {
-        "radiusTop": {
-          "type": "number",
-          "description": "The radius at the top.",
-          "default": 1,
-          "minimum": 0,
-          "x-og-unit": "m"
-        },
-        "radiusBottom": {
-          "type": "number",
-          "description": "The radius at the bottom.",
-          "default": 1,
-          "minimum": 0,
-          "x-og-unit": "m"
-        },
-        "height": {
-          "type": "number",
-          "description": "Its extent along y.",
-          "default": 1,
-          "minimum": 0,
+        "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"
         },
-        "radialSegments": {
-          "type": "integer",
-          "minimum": 0,
-          "maximum": 4294967295,
-          "description": "Segments around.",
-          "default": 32,
-          "minimum": 3
-        },
-        "heightSegments": {
+        "segments": {
           "type": "integer",
           "minimum": 0,
           "maximum": 4294967295,
-          "description": "Rows along the height.",
-          "default": 1,
+          "description": "Segments round the axis.",
+          "default": 12,
           "minimum": 1
         },
-        "openEnded": {
-          "type": "boolean",
-          "description": "Leave the ends open (no caps).",
-          "default": false
-        },
-        "thetaStart": {
+        "phiStart": {
           "type": "number",
-          "description": "Where the side starts around y, from +Z towards +X.",
+          "description": "Where the turn starts, from +Z towards +X.",
           "default": 0,
           "x-og-unit": "rad"
         },
-        "thetaLength": {
+        "phiLength": {
           "type": "number",
-          "description": "How far around the side goes; 2 pi is whole.",
+          "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
     },
-    "ConeGeometryDesc": {
+    "PolyhedronGeometryDesc": {
       "x-og-kind": "desc",
       "x-og-module": "render",
-      "description": "A cone along +Y centred at the origin, its tip up, as three.js ConeGeometry(radius, height, radialSegments, heightSegments, openEnded).",
+      "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": {
-        "radius": {
-          "type": "number",
-          "description": "The base's radius.",
-          "default": 1,
-          "minimum": 0,
-          "x-og-unit": "m"
+        "vertices": {
+          "type": "array",
+          "items": {
+            "type": "number"
+          },
+          "description": "The corners, x y z each (three.js's flat array).",
+          "default": []
         },
-        "height": {
+        "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": "Its extent along y.",
+          "description": "The sphere the vertices are pushed onto.",
           "default": 1,
           "minimum": 0,
           "x-og-unit": "m"
         },
-        "radialSegments": {
+        "detail": {
           "type": "integer",
           "minimum": 0,
           "maximum": 4294967295,
-          "description": "Segments around.",
-          "default": 32,
-          "minimum": 3
+          "description": "Subdivisions of each face: (detail + 1)² triangles a face.",
+          "default": 0,
+          "maximum": 64
         },
-        "heightSegments": {
-          "type": "integer",
-          "minimum": 0,
-          "maximum": 4294967295,
-          "description": "Rows along the height.",
-          "default": 1,
-          "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
+          }
         },
-        "openEnded": {
+        "physics": {
           "type": "boolean",
-          "description": "Leave the base open.",
+          "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
     },
-    "CapsuleGeometryDesc": {
+    "SolidGeometryDesc": {
       "x-og-kind": "desc",
       "x-og-module": "render",
-      "description": "A capsule along +Y centred at the origin, as three.js CapsuleGeometry(radius, height, capSegments, radialSegments, heightSegments): a cylinder of `height` between two hemispheres, `height + 2 radius` long in all (an og.Collider capsule of halfHeight height / 2 and that radius matches it).",
+      "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": {
@@ -17583,218 +18998,302 @@
           "minimum": 0,
           "x-og-unit": "m"
         },
-        "height": {
-          "type": "number",
-          "description": "The straight middle's length.",
-          "default": 1,
-          "minimum": 0,
-          "x-og-unit": "m"
-        },
-        "capSegments": {
+        "detail": {
           "type": "integer",
           "minimum": 0,
           "maximum": 4294967295,
-          "description": "Rows in each hemisphere.",
-          "default": 4,
-          "minimum": 1
+          "description": "Subdivisions of each face.",
+          "default": 0,
+          "maximum": 64
         },
-        "radialSegments": {
-          "type": "integer",
-          "minimum": 0,
-          "maximum": 4294967295,
-          "description": "Segments around.",
-          "default": 8,
-          "minimum": 3
+        "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
+          }
         },
-        "heightSegments": {
-          "type": "integer",
-          "minimum": 0,
-          "maximum": 4294967295,
-          "description": "Rows along the middle.",
-          "default": 1,
-          "minimum": 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
     },
-    "TorusGeometryDesc": {
-      "x-og-kind": "desc",
+    "SweepKey": {
+      "x-og-kind": "struct",
       "x-og-module": "render",
-      "description": "A torus in the xy plane around +Z, as three.js TorusGeometry(radius, tube, radialSegments, tubularSegments, arc).",
+      "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": {
-        "radius": {
+        "t": {
           "type": "number",
-          "description": "From the centre to the tube's centre.",
-          "default": 1,
-          "minimum": 0,
-          "x-og-unit": "m"
+          "description": "The fraction of the path's length, 0 to 1.",
+          "x-og-unit": "ratio"
         },
-        "tube": {
+        "value": {
           "type": "number",
-          "description": "The tube's radius.",
-          "default": 0.4,
-          "minimum": 0,
-          "x-og-unit": "m"
+          "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
         },
-        "radialSegments": {
+        "path": {
+          "$ref": "#/$defs/Path",
+          "description": "The path (og.path.create or og.path.find).",
+          "default": 0
+        },
+        "steps": {
           "type": "integer",
           "minimum": 0,
           "maximum": 4294967295,
-          "description": "Segments around the tube.",
-          "default": 12,
-          "minimum": 2
+          "description": "Rings along the path, less one.",
+          "default": 64,
+          "minimum": 1
         },
-        "tubularSegments": {
+        "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": "Segments around the ring.",
-          "default": 48,
-          "minimum": 3
+          "description": "Points per curve when an og.Shape section is flattened.",
+          "default": 12,
+          "minimum": 1
         },
-        "arc": {
-          "type": "number",
-          "description": "How far around the ring goes.",
-          "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
     },
-    "RingGeometryDesc": {
+    "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 flat ring in the xy plane facing +Z, as three.js RingGeometry(innerRadius, outerRadius, thetaSegments, phiSegments, thetaStart, thetaLength).",
+      "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": {
-        "innerRadius": {
-          "type": "number",
-          "description": "The hole's radius.",
-          "default": 0.5,
-          "minimum": 0,
-          "x-og-unit": "m"
+        "geometry": {
+          "$ref": "#/$defs/Geometry",
+          "description": "Any geometry: made, a primitive or a loaded glTF's.",
+          "default": 0
         },
-        "outerRadius": {
-          "type": "number",
-          "description": "The ring's radius.",
-          "default": 1,
-          "minimum": 0,
+        "position": {
+          "$ref": "#/$defs/Vector3",
+          "description": "Where it goes.",
+          "default": {
+            "x": 0,
+            "y": 0,
+            "z": 0
+          },
           "x-og-unit": "m"
         },
-        "thetaSegments": {
-          "type": "integer",
-          "minimum": 0,
-          "maximum": 4294967295,
-          "description": "Segments around.",
-          "default": 32,
-          "minimum": 3
-        },
-        "phiSegments": {
-          "type": "integer",
-          "minimum": 0,
-          "maximum": 4294967295,
-          "description": "Rings from the inside out.",
-          "default": 1,
-          "minimum": 1
+        "quaternion": {
+          "$ref": "#/$defs/Quaternion",
+          "description": "How it turns.",
+          "default": {
+            "x": 0,
+            "y": 0,
+            "z": 0,
+            "w": 1
+          }
         },
-        "thetaStart": {
-          "type": "number",
-          "description": "Where it starts, from +X towards +Y.",
-          "default": 0,
-          "x-og-unit": "rad"
+        "scale": {
+          "$ref": "#/$defs/Vector3",
+          "description": "Its scale (a negative component mirrors it as `mirror` does).",
+          "default": {
+            "x": 1,
+            "y": 1,
+            "z": 1
+          }
         },
-        "thetaLength": {
-          "type": "number",
-          "description": "How far around it goes.",
-          "default": 6.283185307179586,
-          "x-og-unit": "rad"
+        "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
     },
-    "CircleGeometryDesc": {
+    "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": "A disc (or a sector) in the xy plane facing +Z, as three.js CircleGeometry(radius, segments, thetaStart, thetaLength): a 2D polygon's simplest shape.",
+      "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": {
-        "radius": {
-          "type": "number",
-          "description": "The radius.",
-          "default": 1,
-          "minimum": 0,
-          "x-og-unit": "m"
+        "op": {
+          "$ref": "#/$defs/CsgOp",
+          "description": "The operation.",
+          "default": "union"
         },
-        "segments": {
-          "type": "integer",
-          "minimum": 0,
-          "maximum": 4294967295,
-          "description": "Segments around.",
-          "default": 32,
-          "minimum": 3
+        "a": {
+          "$ref": "#/$defs/GeometryPart",
+          "description": "The first operand.",
+          "default": {}
         },
-        "thetaStart": {
-          "type": "number",
-          "description": "Where it starts, from +X towards +Y.",
-          "default": 0,
-          "x-og-unit": "rad"
+        "b": {
+          "$ref": "#/$defs/GeometryPart",
+          "description": "The second operand.",
+          "default": {}
         },
-        "thetaLength": {
-          "type": "number",
-          "description": "How far around it goes.",
-          "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
     },
-    "TubeGeometryDesc": {
+    "MergeGeometriesDesc": {
       "x-og-kind": "desc",
       "x-og-module": "render",
-      "description": "A tube along a curve, as three.js TubeGeometry(curve, tubularSegments, radius, radialSegments, closed): its rings are evenly spaced along the curve's length (three.js getPointAt), u runs along it, v around. The curve is `path` when set (an og.path, whatever its kind, followed exactly: a scene's or a timeline's path becomes a tube), otherwise new CatmullRomCurve3(points, closed, 'centripetal') through `points`, which may come from anywhere: a rope's points, a spline a tool made.",
+      "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": {
-        "points": {
+        "parts": {
           "type": "array",
           "items": {
-            "$ref": "#/$defs/Vector3"
+            "$ref": "#/$defs/GeometryPart"
           },
-          "description": "The points the curve passes through, in order (at least two), when `path` is 0.",
-          "default": [],
-          "x-og-unit": "m"
-        },
-        "path": {
-          "$ref": "#/$defs/Path",
-          "description": "A path (og.path.create, or a scene's `path` by og.path.find) the tube follows instead of the points: its own curve, kind and closed flag (`closed` is the path's then). 0 uses the points.",
-          "default": 0
-        },
-        "tubularSegments": {
-          "type": "integer",
-          "minimum": 0,
-          "maximum": 4294967295,
-          "description": "Segments along the tube.",
-          "default": 64,
-          "minimum": 1
+          "description": "The parts, in order (at least one).",
+          "default": []
         },
-        "radius": {
-          "type": "number",
-          "description": "The tube's radius.",
-          "default": 1,
-          "minimum": 0,
-          "x-og-unit": "m"
+        "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
+          }
         },
-        "radialSegments": {
-          "type": "integer",
-          "minimum": 0,
-          "maximum": 4294967295,
-          "description": "Segments around it.",
-          "default": 8,
-          "minimum": 3
+        "physics": {
+          "type": "boolean",
+          "description": "Register it as a physics mesh too.",
+          "default": true
         },
-        "closed": {
+        "dynamic": {
           "type": "boolean",
-          "description": "Join the last point back to the first.",
+          "description": "Whether og.render.updateGeometry may rewrite it later.",
           "default": false
         }
       },
@@ -19002,7 +20501,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,
@@ -23406,6 +24905,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 +24925,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 +24946,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 +25101,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 +25123,7 @@
         "bones",
         "slots",
         "constraints",
+        "skins",
         "clips"
       ],
       "additionalProperties": false
@@ -30525,22 +32045,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 +32364,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 +36903,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 +36927,8 @@
         "maxHeight",
         "layers",
         "collision",
-        "castShadows"
+        "castShadows",
+        "seaLevel"
       ],
       "additionalProperties": false
     },