@woosh/meep-engine 3.60.4 → 3.60.6

package/CHANGELOG.md

@@ -0,0 +1,2621 @@
+# Changelog
+
+## Unreleased
+
+### Probe clipmap GI: virtual geometry has cards, through a proxy
+
+- **Added:** `VirtualGeometry.get_proxy()`: an ordinary geometry standing in for a virtual one, cut from its
+  container (`vgeo_to_proxy_mesh`) at `vgeo_proxy_triangle_limit(source_triangles)`, clamp(1%, 128, 64,000), through
+  a reader of its own. A container is expected to be delivered with its proxy, baked offline; until then the proxy is
+  cut at load.
+- **Changed:** a virtual geometry's geometry cache and cards are its proxy's. The GI's rays now see virtual geometry's
+  materials instead of black: on Zorah, cards serve 82% of front-face hits (none before) and the frame's mean luma
+  goes 50.83 → 58.14. The proxy's detail is its own, so the field and the cards are coarser than the asset. Zorah's
+  1,012 proxies are 3.18M triangles and take the geometry manager's device memory from 406 MB to 743–780 MB.
+- **Changed:** `GPUGeometrySDFManager.alias(clone, source)` moves the clone's holders to the source and sends
+  `onBaked` with the clone when the source's cache turns resident; card sets of an aliased geometry capture its
+  source's layout (`GPUMeshCardSets.alias` / `unalias`). New `GPUGeometrySDFManager.onForgotten`.
+- **Breaking:** `GPUGeometrySDFManager.adopt`, `add_source`, `remove_source` and the `MeshSDFSource` typedef are
+  gone, as are the GPU extraction (`shader_vgeo_sdf_collect`, `shader_vgeo_sdf_traverse`, `shader_vgeo_sdf_decode`,
+  `VGEO_SDF.js`). `VGeoSDFProxies` takes `{ geometries }` alone; its `cut`, `job_count`, `requested_count`,
+  `extracted_count`, `adopted_count`, `triangles_extracted` and `cluster_capacity` are replaced by `pending_count`,
+  `applied_count`, `failed_count` and `proxy_of(record)`.
+
+### Virtual geometry: proxy meshes, offline
+
+- **Added:** `vgeo_to_proxy_mesh(reader, triangle_limit)` (`geometry/virtual/proxy/`) turns an open
+  `VGeoContainerReader` into an ordinary `MeshletGeometry` of at most `triangle_limit` triangles, with no device, for
+  systems that want a plain mesh of a VGEO asset, such as card capture. Nothing is simplified: it cuts the
+  DAG from its roots, always refining the group whose parents carry the largest error, and stops at the
+  first refinement over the limit. Error stays uniform and the cut is watertight. The cut's clusters are
+  the meshlets, as stored, with the mesh path's BVH. Pages install as the descent reaches them. On Zorah's
+  `SM_Courtyard_Ceiling_A1_1` (17.6M triangles, 689 MiB), 100,000 triangles took 0.44 s and read 27 MiB,
+  and 1,000 took 23 ms. A limit below the roots' triangle count gets the roots.
+- **Changed:** `vgeo_runtime_meshlet_batch` writes its metadata rows through the new
+  `vgeo_meshlet_metadata_write`, which the proxy shares.
+
+### Probe clipmap GI: no resident materials for a raster capture; a hit no card sees is black
+
+- **Fixed:** the probe clipmap GI made every material of the scene resident each frame, and a scene past
+  the resident table's 819 material ids (ids are never reused) threw "material id … exceeds material
+  limit" from `GPUProbeClipmapGI.graph_update` every frame. The raster card capture, the default, reads
+  the scene's own material table and now makes nothing resident. A traced capture
+  (`MeshCardCaptureMode.Trace`, and templates with no raster surface) makes resident only the materials
+  it traces, just before it traces them; the 819 limit still bounds those, the path tracer and the
+  bakers.
+- **Changed:** a probe ray's hit that no card sees, or on a row with no card set (virtual geometry, a
+  pair still capturing), brings back no light, as in UE. It took the material's colour factor × its
+  textures' means. The colour factor alone, from the scene's table, was measured first and made Sponza's
+  bounce-lit gallery 60% brighter on screen; black makes it 27% darker than the means (mean luma 29.3 →
+  21.5) and the sunlit nave 1% darker. Virtual geometry has no cards yet, so its surfaces bounce no light.
+- **Breaking:** `GPUResidentMaterialContext.buffer_texture_means`, `onMaterialRepacked` and
+  `shader_resident_texture_means.js` are gone. Card recapture listens to the new
+  `GPUMaterialManager.onMaterialRestaged`. `GPUResidentMaterialContext.commit()` writes what
+  `obtain_material` made resident without taking every material the manager holds, as `update()` does.
+  `GPUProbeClipmap.graph_update` takes no `materials`.
+
+### HZB mip 0: a footprint fixed per axis, and shadow cascades the HZB halves exactly
+
+- **Faster:** the HZB's first reduction reads a footprint of a constant 2 or 3 source texels per axis,
+  picked when the viewport changes (`hzb footprint x` / `hzb footprint y`, four variants), instead of
+  looping over bounds computed per thread. Output is unchanged. In `water-bodies`, against the old loop
+  at the same sizes in one process: the shadow cascades' 6 reductions 2.45 → 1.24 ms a frame on an AMD
+  RDNA 2 iGPU (0.505×) and 0.78× on an RTX 4090; the main view's 0.36× and 0.75×.
+- **Changed:** directional cascades default to 1536 each (were 1740, then 1440). Half of 1536 is a mip 0
+  the HZB takes unpadded, so cascades reduce 2×2 and their pyramid is two 4-mip SPD passes and one
+  single-mip pass, where 1740 and 1440 took 3×3 and five single-mip passes. About the same texels in
+  all (7.08M against 7.17M): the first cascade 12% coarser across, the others 7% finer. With both
+  changes the HZB chain in `water-bodies` went ~5.2 → ~1.85 ms a frame on the iGPU, 0.142 → 0.086 ms on
+  the 4090.
+- **Breaking:** one mip 0 shader reduces a region of its source for a camera (the whole viewport) and for
+  an atlas slot: `shader_hzb_reduce_mip0` moved from `shader_hzb_reduce_any.js` to
+  `shader_hzb_reduce_mip0.js` and takes a clip region; `shader_hzb_reduce_mip0_clip.js` is gone, and so
+  is its span label, `HZB / reduce mip0 with clip`. `HierarchicalZBuffer.setViewportSize` refuses a side
+  of 0.
+
+### One orbital camera: the harness, the editor and Shade's playgrounds share a rig
+
+- **Changed:** every orbital camera is now an `OrbitalCameraRig` (`src/engine/graphics/camera/orbital/`) moving a
+  `TopDownCameraController`: a drag moves the camera as it happens, letting go throws it on with the drag's recent
+  velocity (half life 0.1 s, the same distance at any frame rate), grabbing again stops every throw, and a wheel notch
+  zooms by a fixed proportion. The rig keeps velocities, not a pose, so a writer that adds to the controller composes
+  with a throw and one that sets it outright wins. It subscribes to nothing: `makeOrbitalCameraController`,
+  `EditorCameraNavigation` and Shade's `OrbitalCameraController` each feed it their own pointer.
+- **Fixed:** the harness camera (`makeOrbitalCameraController`) zoomed by one world unit a notch, so 0.5% at distance
+  200 and 50% at distance 2; it now zooms by the same proportion at any distance. Its pitch had no limit, so a long
+  drag turned the camera over and under the ground; it stops at straight down and straight up.
+- **Fixed:** `KeyboardCameraController` moved the target along the camera's own forward, so at the harness's default
+  pitch of 1.4 W sent it 98.5% into the ground, and a diagonal travelled √2 too far. It now moves the target across
+  the ground along the view's heading (`top_down_truck_on_ground`), at full speed at any pitch.
+- **Fixed:** the harness registers `ScriptSystem` when it builds the orbital camera. Nothing registered it before, so
+  `KeyboardCameraController`'s script never ran in a harness scene and W/A/S/D did nothing. Every `Script` in a
+  harness scene now runs, `Tween`'s and `playAnimationTrack`'s included.
+- **Fixed:** `TopDownCameraController.setFromEyeAndTarget` reported about half of all views turned over: pitch past
+  the vertical, rolled half a turn. Same rotation, but an orbit clamped it, so the first drag snapped the camera to
+  straight down. It now always reports pitch within ±π/2, and no roll for an up of +Y.
+- **Changed:** the harness orbits on the primary button (and touch) and pans on the secondary, the other way round
+  from before. The editor's orbit turns the world with the hand, the opposite horizontal direction from before.
+  Shade's `OrbitalCameraController` zooms on the vertical wheel only; a sideways swipe no longer zooms.
+- **Added:** `top_down_truck_in_view` and `top_down_truck_on_ground` beside `TopDownCameraController.pan`, and
+  `MouseEventButtons`, the bits of `MouseEvent.buttons`.
+- **Breaking:** removed `rotate_from_view` and `TopDownCameraController.rotate`; Shade's `OrbitalCameraRig`,
+  `OrbitalCameraInput`, `MomentumAxis`, `OrbitalCameraConfig` (`ORBITAL_CAMERA_FEEL_DEFAULTS`,
+  `createOrbitalCameraConfig`, `createPrecisionProfile`) and the `camera/orbital/index.js` barrel; Shade's
+  `OrbitalCameraController` lost its third constructor argument, `flyTo` and `pan`. `MomentumAxis` and
+  `OrbitalCameraRig` live on in `src/engine/graphics/camera/orbital/` with new interfaces.
+  `EngineHarness.buildOrbitalCameraController` and `makeOrbitalCameraController` no longer take `sensitivity`.
+  `computeTopDownTransform` moved from `TopDownCameraControllerSystem.js` to `TopDownCameraController.js`.
+
+### Water: cheaper optics, and how to author a body's area
+
+- **Changed:** the water optics pass takes transmission and radiance away from water from its clear, not from a
+  full-screen draw; its background copy writes only the background. Output is bit-identical; on an integrated GPU
+  the pass is about 0.22 ms cheaper at 1280 × 720.
+- **Changed:** the optics pass no longer evaluates the pixel surface the receivers pass already shaded. The receivers
+  leave it in `Water trace metadata`, which is now `rgba32uint` (control path, octahedral normal, slope variance and
+  coverage, body). Water is about 1.35 ms cheaper a frame on an integrated GPU at 1280 × 720. The normal carries
+  16-bit octahedral precision, so output is not bit-identical.
+- **Removed:** water debug view 6 (Newton residual), and the residual the pixel probe returned as `radiance[3]`.
+- **Documented:** a body's geometry is its area. Author it with the fewest triangles that cover it: every internal
+  edge splits the lattice cells it crosses and keeps 8 × 8 patches from spanning it. Subdividing a flat area adds
+  nothing to the waves, which the renderer tessellates itself; see `Water`.
+
+### `Trail3D`: the fade is seen as authored, and each trail can shape it
+
+- **Fixed:** a trail's alpha is the opacity of the tube as seen. The tube is drawn from both sides, so every line of
+  sight crosses two faces, and both used to carry the full alpha: `color.a = 0.5` covered 0.75, and the linear fade
+  held near solid for most of the trail's life before collapsing at its tail. Each face now carries half the optical
+  depth (`1 - √(1 - α)`), so the two cover exactly `α`. Trails authored against the old look will read thinner.
+- **Added:** `Trail3D.fade`, an `AnimationCurve` of opacity over a knot's age relative to `maxAge`, multiplied into
+  `color.a`. Every trail starts on `TRAIL3D_FADE_LINEAR`, one shared, frozen, linear curve; assign your own to
+  reshape a trail's fade (`TRAIL3D_FADE_LINEAR.clone()` is an editable copy). It round-trips through
+  `toJSON`/`fromJSON` and takes part in `equals`.
+- **Changed:** `TubeXFixedPhysicsSimulator.update(tube, max_age, timeDelta, alpha, fade)` takes the curve, and
+  `alpha` has no default any more.
+
+### `SegmentedResourceBarView`: crisp notches with fixed meanings, stacked values, a ghost that trails, and cells
+
+- **Changed:** notches are DOM elements on whole device pixels at any `devicePixelRatio` and under a CSS scale, not
+  canvas strokes. Each carries its tier's `class_name`; `segmented-resource-bar.css` (beside the view, import it from
+  a style entry point) styles them through `--segmented-bar-*` custom properties.
+- **Changed:** notch tiers have fixed meanings. `tiers` takes `SegmentTier`s (`unit`, `class_name`, `width_px`,
+  `min_spacing_px`); a notch belongs to the coarsest tier whose unit divides it, and a tier too tight on screen drops
+  out, finest first. Without `tiers`, `SEGMENT_TIERS_DEFAULT` marks every 10, 100 and 1000.
+- **Fixed:** `values` stack end to end, their total clamped to `max`; each fill used to start at the left edge.
+- **Fixed:** the ghost trails a drop: it holds for `ghost_delay_ms` (450), then eases down over `ghost_duration_ms`
+  (350), and jumps up on a rise. Under `prefers-reduced-motion` it holds, then snaps. The model is `GhostTrail`.
+- **Added:** `cells: { count, group }` draws separate cells with identical gaps, one partly filled cell allowed.
+- **Added:** the layout as pure functions: `segment_tick_positions`, `segment_notch_place`, `segment_cell_layout`.
+- **Deprecated:** `RESOURCE_BAR_SEGMENTS` and `SegmentDefinition`; the view no longer reads them.
+
+### The daily driver: graph trees draw their species' shoot prototypes, and are the default
+
+- **Changed:** `generate_tree` grows by the generator graph unless asked otherwise (`growth`), a preset's name
+  included. Ask for `TreeGrowth.Botanical` for trees seen up close. A graph tree draws its species' shoot prototypes on
+  its carriers (`tree_shoot_instances`):
+  - each is scaled to its carrier by a step of the error ladder (√2), and turned about the vertical;
+  - the wood any LOD draws is grafted onto the carrier, which takes the prototype's girth, growth and units;
+  - every leaf and twig is the prototype's cuts, the instance's steps finer than the tree's error, from the species'
+    atlas.
+
+  It fits the cost ceiling at 0.2-3.6 s a tree once its species is cached (botanical 1.4-11.9 s, same run), at the
+  botanical tree's crown density within -0.03 to +0.12 (TWO_FRONT_ENDS_BRIEF_2026_10_28.md, G3).
+- **Changed:** without a `cache`, every call shares `TREE_SPECIES_CACHE`. A species' materials and prototypes are
+  made once in a program; `clear()` lets them go. A caller's own species goes through `generate_tree({ species,
+  growth })`; a `TreeSpeciesConfig` passed alone is grown by the generator graph.
+- **Added:** three skeleton records:
+  - `TreeSkeleton.branch_instance`: the leaf collector leaves an instance's branches to its prototype;
+  - `segment_carried_leaf_area` and `segment_carried_reach`: what a segment carries without holding it, which the
+    wind's mechanics load it with.
+
+  `TreeAsset.side_area`, `shoot_prototypes` and `shoot_instances` record what a tree grew and what draws it.
+  `tree_lod_plan` takes `cards` and `tree_grown_side_area` takes `carried`, for leaves a tree draws but doesn't
+  hold.
+- **Added:**
+  - `tree_skeleton_floor_girth`: no branch is thinner than what grows from it.
+  - `tree_skeleton_copy_branch` copies one branch through a placement, its girth scaled with it.
+  - `tree_skeleton_extend_branch` is the shoot simulation's carrier extension, now shared.
+  - `tree_cluster_hang` is `tree_clusters`' hang and skin, now shared.
+- **Changed:** `tree_render_cost` reads `TreeAsset.side_area`.
+- **Changed:** `tree_skeleton_compute_segment_mechanics` reports each segment's `leaf_area`.
+- **Removed:** the plan to space graph carriers by their prototypes' sleeves (G2). The graph tree already has the
+  botanical tree's framework and density.
+
+### Shoot prototypes: a species' shoot systems grown once, cut and baked into one atlas
+
+- **Added:** `tree_shoot_prototypes`, cached by `TreeSpeciesCache.prototypes` (TWO_FRONT_ENDS_BRIEF_2026_10_28.md,
+  G1). Each prototype is a shoot system grown in place on a carrier of the species' graph framework, and kept where it
+  grew, under the framework's crown frame. There are as few as reach every carrier length, without a gap, within the
+  leaves' own size spread: 6 to 27 per species. All of them are cut at every error from 1 cm to where they draw no
+  wood, and drawn with a few tiles of one atlas.
+- **Added:** `tree_skeleton_grow_shoots_on` grows the shoot systems of chosen carriers only.
+  `tree_skeleton_copy_branches` copies branches with their nodes, segments, units, scars and dead flags into another
+  skeleton. `tree_cluster_atlas` is the cut, representatives and bake that `generate_tree` ran inline, now shared.
+  `foliage_scale_spread` and `TREE_LOD_ERROR_STEP` are the representatives' and the LOD plan's own, now shared.
+- **Fixed:** `tree_clusters` hung every whole-tree cut from branch 0's root. A skeleton holding several trees now
+  hangs each one's cut from its own root.
+- **Performance:** `tree_cluster_representatives` scored every candidate against every cut at every pick. It now
+  counts in each candidate's size window with a Fenwick tree a LOD, and sums unlikeness only for tied candidates. The
+  picks are bit-identical. The pine's representatives went from 46.4 s to 6.3 s.
+
+### Two growth front ends: a tree grown by its generator graph alone
+
+- **Added:** `generate_tree`'s `growth` (`TreeGrowth.Graph` or `TreeGrowth.Botanical`, the default). A graph tree is
+  the framework of the generator graph alone (`tree_skeleton_grow_framework`, new). A botanical tree is that framework
+  with every shoot system grown on it (`tree_skeleton_grow`, as before). Both are drawn by the same pipeline and fit
+  the same cost gate. Graph trees are sparse, carrying only their framework's leaves (side density 0.21-0.38 against
+  the botanical trees' 0.25-0.71), until their cards come from a botanical prototype
+  (`TWO_FRONT_ENDS_BRIEF_2026_10_28.md`, G1-G3).
+- **Added:** `make_tree_species_preset`'s third argument `growth`. The pine grown by its graph has a framework of its
+  own (stem, whorl boughs, inter-whorl branches, twigs), as the botanical pine grows from its seed.
+- **Added:** `TreeSpeciesCache`: passed to `generate_tree` as `cache`, it makes a bark material once per
+  `bark_material` and a leaf atlas once per `foliage` and `foliage_material`, when a tree first asks for one, and shares
+  them between the trees that do. Each tree clones the leaf material and tints its own. A tree drawn with the caller's
+  own materials makes none.
+- **Changed:** both front ends end on one crown frame law (`tree_skeleton_fit_crown_frame`): the box of every living
+  branch a shoot rule grows on or grows. The botanical tree's frame now includes its last season's growth.
+- **Changed:** a tree's bark texture is its species' and no longer changes with its seed: every bark has the same
+  noise (`make_bark_material`'s own seed). The leaf atlas never did.
+
+### No cluster card draws its tile at a size the tree's leaves do not grow to
+
+- **Fixed:** `tree_cluster_representatives` drew a cut with any tile, magnified without bound, when the texture
+  ceiling could not hold a cover within the leaves' spread at `FoliageTileLayout.legible_texel`. A tile's twigs then
+  drew as boughs: the pine's LOD0 cuts were magnified up to 10.8x (seed 60557), the spruce's 15.6x, and shrunk down
+  to 0.02x on the shrub. LOD0's texel now keeps halving past the legible texel until every cut of every LOD is drawn
+  within the spread: pine 6.4 mm, spruce 4.0, shrub 4.8-9.6, oak 2.83 (was 1.41, with 2-8 cuts past the spread). Trees
+  whose cover fitted at or before the legible texel (willow, birch, maple, palm, fern) are drawn as before. Crown
+  density holds within .03 at every LOD; the atlases shrink (pine 1038 x 1005 to 625 x 650).
+
+### Bark moves with its rig: no step at a joint in the wind
+
+- **Fixed:** a bark ring is weighted to the joint whose span it is in, alone; a child's first ring, and its wood before
+  its own first joint, are carried as its parent's bark carries its base. The weights blended a ring's joint with the
+  joint above by `t_norm` along the whole branch, so the rings either side of a pivot carried different shares of the
+  joint above: in the wind the bark stepped there (the palm's trunk at 5.85 m: [0.70 J1, 0.30 J0] below,
+  [0.70 J2, 0.30 J1] above, 7.6 cm apart in the reference wind). The rig placed its joints as turning whole spans
+  about their pivots (`tree_skeleton_assign_skin_joints`); the bark now moves as it was placed. Leaves and cluster
+  cards, which take the bark's weights where they hang, follow it.
+
+### A cluster card lies where what it draws spreads, as sharp as the texture ceiling affords
+
+- **Changed:** `tree_cluster_cards(skeleton, attachments, leaves, clusters)` fits each card's plane to what it draws,
+  its leaves' cards and its twigs' bands each by their area, not to where its leaves attach. A palm's leaves attach
+  along a rachis arching in a vertical plane while they spread to either side of it: its cards stood upright, and its
+  crown seen from below was .37 dense against .70 drawn leaf by leaf; now .69.
+- **Changed:** `tree_cluster_representatives(skeleton, attachments, leaves, lods, fine_texel, legible_texel, budget)`
+  draws LOD0 at the finest texel the texture ceiling affords for its whole cover: the leaf material's own
+  (`FoliageTileLayout.texel`), coarsened by halves while the cover does not fit, never past
+  `FoliageTileLayout.legible_texel` (was `cluster_texel`). The palm's fronds are drawn at 13.2 mm where they were at
+  49.6 mm, the maple's leaves at 2.1 mm where they were at 8.5.
+- **Changed:** `tree_lod_plan` counts a cluster card per cluster without building the cards.
+
+### A few cluster tiles draw every cut, sharp, in one atlas per tree
+
+- **Added:** `mesh/tree_cluster_representatives.js`: the fewest cuts whose tiles draw every cut of every LOD at a
+  size the tree's own leaves grow to (a cut magnifies its representative's leaves by their size ratio, held within
+  the 10th to 90th percentile of `attachments.scales` about the median), the least unlike each cut (leaf coverage,
+  where it hangs) where several do, no more than the tree's texture ceiling holds. A cut draws its representative on
+  its own plane, as large as it draws (its leaves' and twigs' area, so the crown keeps its leaf area), hanging where it
+  hangs, turned to run out its way.
+- **Added:** `FoliageTileLayout.cluster_texel`, the texel a cluster card draws the leaf at: its outline's finest
+  feature four texels across, its margin's teeth aside (`LeafGeometry.outline`, `FoliageTileLayout.outline`), a
+  needle two texels across its width. A coarser LOD's representative is baked where the LOD before it is drawn to a
+  pixel, its error, or the leaf's texel if finer.
+- **Added:** `TREE_RENDER_COST_CEILING.texture_density`, 240,667 bytes of foliage texture per m^2 (the shrub's leaf
+  atlas at 6aff5265e, the 640 KiB every preset's was); `tree_render_cost`'s `texture_bytes` and `texture_density`
+  count each map of every LOD's foliage material once. Every preset fits it.
+- **Added:** `material/tree_cluster_press.js`, `material/tree_cluster_tiles.js` and
+  `material/tree_cluster_atlas_pack.js`, the bake's pressing, tile layout and packing, which the choice measures too.
+  Every card presses its own copy of its leaves, so a leaf on cuts of two LODs lies flat on each.
+- **Changed:** every LOD of a tree draws its foliage with one atlas (`TreeLODAsset.foliage_material` is the same
+  material on all of them). `tree_cluster_bake` takes a texel per card; `tree_mesh_build_clusters` takes each
+  card's placement `{rep, frames}` and draws the representative's tile through it.
+
+### The nested clipmap placement is shared
+
+- **Added:** `ClipmapCascadePlacement` (`core/geom/clipmap/`): the windows of a stack of nested cascades around one
+  anchor, placed coarsest first by the hysteretic rule, re-placed whole on a jump, each child clamped inside its parent.
+  The corner step, the hysteresis and the nesting margin are options, and `clipmap_cascade_nest_resolution_min(step,
+  margin)` is the smallest side that nests. The fluid's placement, generalised for the probe clipmap's cascades.
+- **Changed:** `FluidCascadePlacement` is a `ClipmapCascadePlacement` with the fluid's step, hysteresis and margin. Its
+  placement is unchanged.
+- **Breaking:** `FluidCascadePlacementResult` is `ClipmapCascadePlacementResult`. `FLUID_CASCADE_NEST_RESOLUTION_MIN` is
+  gone: the floor is `clipmap_cascade_nest_resolution_min`.
+
+### Each LOD carries its own rig, on the wood it draws
+
+- **Added:** `tree_skeleton_assign_skin_joints(skeleton, species, options)`: `options.tolerance` in place of
+  `deflection_tolerance`; `options.rings`, the wood an LOD draws, puts joints only on it, no further out than its
+  bark; `options.within`, a finer rig's joints, places joints only where it has one, so a coarser LOD's joints are a
+  subset of the finer's. Its result carries `joint_rotation` and `node_joints`, the binding it wrote.
+- **Added:** `tree_skeleton_bind_skin_joints(skeleton, skin_info)` binds a derived rig back onto its skeleton.
+- **Added:** `asset/tree_lod_plan.js`: each LOD's error and rig, the finest error at which the tree fits its ceiling
+  in triangles and in joints; the rig's tolerance is the larger of `deflection_tolerance` and the error. A tree that
+  fits no ceiling at any error is drawn without wood.
+- **Changed:** each `TreeLODAsset` has its own `skin_info` and `wind_rig`, and its bark and cluster cards are
+  skinned to them. `TreeAsset.skin_info` is the rig of all the wood as grown, which `attachments` are bound to;
+  `TreeAsset.wind_rig` is LOD0's.
+- **Changed:** `tree_render_cost`'s `joints` and `joint_density` are per LOD; every LOD's rig is held to
+  `TREE_RENDER_COST_CEILING.joint_density`, and every preset fits it.
+- **Removed:** `asset/tree_lod_errors.js`: `tree_lod_errors` is `tree_lod_plan`, whose LODs carry their rig;
+  `tree_triangles_at_error` moves with it.
+
+### Each LOD's leaves are cluster cards baked from what the tree grew
+
+- **Added:** each LOD draws the twigs and leaves its wood leaves out as cluster cards, one per cut
+  (`mesh/tree_clusters.js`): an undrawn branch on drawn wood with all it carries, or a drawn branch's undrawn tip; a
+  leaf on drawn wood joins its branch's nearest cut. A card lies in the plane its leaves and twigs spread in, facing
+  away from the crown (`mesh/tree_cluster_cards.js`), and is a 6-triangle hull skinned as its cut hangs
+  (`mesh/tree_mesh_build_clusters.js`).
+- **Added:** `material/tree_cluster_bake.js`: each card's tile drawn orthographically from the leaves and twigs the
+  tree grew, at a texel equal to the LOD's error. Each leaf is pressed onto its card, turned about where it attaches,
+  so it covers there what it covers facing it; twigs are bands their length by their diameter. Albedo, normal (in the
+  card's frame) and ORM, one atlas per LOD, each card cut to its tile's alpha.
+- **Added:** `asset/tree_lod_errors.js`: each LOD's error, the finest a half-octave apart from
+  `TREE_LOD_ERROR_FINEST` (1 cm, never finer) at which the tree's bark and cards fit `TREE_RENDER_COST_CEILING`'s
+  triangles at that LOD, never finer than the LOD before. `generate_tree` draws each LOD to it.
+- **Added:** `tree_grown_side_area(skeleton, leaves)`: the side area of what the tree grew, its wood's nodes and every
+  leaf's card, whatever an LOD draws; `tree_render_cost` measures against it. `TREE_RENDER_COST_CEILING` is
+  re-derived under it at 6aff5265e: 761.2, 412.3 and 96.2 triangles and 16.89 joints per m^2.
+- **Added:** `tri2_rasterize_barycentric` (`core/geom/2d/triangle`): the texels a triangle covers, with their
+  barycentric weights, by the top-left rule. The crown opacity measure draws with it.
+- **Added:** `foliage_material_from_samplers(albedo, normal, orm, name)`, the foliage material over given maps.
+- **Changed:** `TreeLODAsset.foliage_material` is the LOD's own, its cluster atlas, built with its geometry;
+  `TreeAsset.foliage_material` stays the leaf material the bakes draw from. `configure_lazy_geometries`'s foliage
+  builder returns `{geometry, material}` or `null`. `TreeLODAsset.config` is the LOD's config, at its error.
+- **Changed:** `tree_mesh_build_foliage(skeleton, attachments, config, cutout, out)` draws every leaf and takes no
+  LOD: it is the leaf reference the bakes and measures draw from.
+- **Changed:** `FoliageAttachmentSet.ranks` is `attach_t`, where along its carrier each card attaches.
+- **Changed:** `foliage_atlas_cutout_fit_tile` and `foliage_atlas_cutout_fit_alpha` take a tile's height apart from its
+  width.
+- **Removed:** `TreeLODConfig.foliage_keep_ratio`, `foliage_area_compensation_exponent` and `simplify_cards`: no LOD
+  thins its leaves.
+
+### Each LOD's bark is the tree at a geometric error
+
+- **Added:** `TreeLODConfig.error`, metres: wood thinner than it is not drawn as a tube, nor anything it carries, and
+  its spine ends where it thins to it; the bark's rings, and each ring's sides, are as few as keep the surface it draws
+  (spine, radius, lobes, flutes, ovalization, collar bosses, knots and the weld's flare) within it, half along the
+  branch and half around it. `TreeLODConfig.createDefaultChain(count, error)` doubles it per level from
+  `TREE_LOD_ERROR_FINEST` (1 cm, chosen until each tree derives its own).
+- **Added:** `polyline_simplify_by_error` (`core/geom/polyline`): Douglas-Peucker over any sequence, the caller
+  measuring the error.
+- **Added:** `tree_mesh_compute_branch_rings`'s rings carry `start`, the vertex their ring begins at.
+- **Changed:** a foliage card finds the bark rings it sits between by where it attaches along its carrier, and sits
+  exactly there; a card on wood the LOD does not draw stands on its skeleton.
+- **Removed:** `TreeLODConfig.radial_scale`, `longitudinal_scale`, `max_branch_level`, `min_branch_radius`;
+  `BranchGeneratorConfig.radial_segments_min`, `radial_segments_max`.
+
+### What a tree costs to draw
+
+- **Added:** `analysis/tree_render_cost.js`: a generated tree's triangles at every LOD and its wind joints, per square
+  metre it shows from the side (`tree_envelope_side_area`, the mean side area of its drawn envelope), and
+  `TREE_RENDER_COST_CEILING`, the densest of the presets at 6aff5265e, the last real-time generator.
+
+### The pine grows from its seed, and every shoot keeps out of older wood
+
+- **Added:** `ShootGrowthConfig.age`, `leader_onset`, `leader_height_scale` and `leader_unit(height)`: a tree
+  grows for its age, and a carrier that stops before then grows on from its tip, written onto it. The stem grows by
+  height (Kellomäki & Kurttio 1991, Eq. 6).
+- **Added:** `ShootGrowthConfig.apical_control`: Borchert-Honda sharing of the light the shoots receive (Palubicki et
+  al. 2009), scaling each new unit's length. 0.5 changes nothing.
+- **Added:** `ShootWoodHash`: no shoot grows through older shoot wood it does not join, and a shoot whose line thicker
+  wood has grown into dies, as does a lateral whose tip the wood its mother grew since has closed over. No shoot grows
+  into the ground. A framework branch its parent's thickening has grown over is dead.
+- **Added:** `shoot_survival(growth, light, gross)`, a new shoot's chance in its light.
+- **Changed:** a lateral of a generator that bears no leaves (no foliage rule) does not grow: a shoot pays for its
+  offspring with its leaves.
+- **Added:** `analysis/tree_leaf_area_targets.js`: measured whole-tree leaf area against DBH per preset species
+  (Forrester et al. 2017, Martin et al. 1998, Gómez-García & Pérez-Rodríguez 2015, Repola 2009) and FIA crown ratings.
+- **Changed:** the pine preset grows from a seed leader: the generator graph lays the seed and the roots, and one shoot
+  rule grows the stem and everything on it from Kellomäki & Kurttio's (1991) shoot demography, 30 seasons.
+- **Changed:** in full light every shoot the buds grow is kept: Rb at saturation is the gross yield of the unit a shoot
+  grew on. `ShootGrowthConfig.vigour` is removed.
+- **Changed:** shoots turn towards where the light field grows brighter, not away from the crown's centre; zigzag kinks
+  a unit off its axis's course instead of turning the course; plagiotropism and straightness turn shoots as they turn
+  the graph's spines, the stem excepted.
+- **Changed:** `ShootSystemRule.target` is a generator per mother order and `mean_unit_length` a length per order;
+  `shoot_expected_yield(rule, order, length)` takes the unit's order and length.
+- **Removed:** `ShootGrowthConfig.vigour`; `shoot_outward3`.
+
+### Deprecated re-exports are gone
+
+- **Breaking:** every re-export kept only so an old name or an old import path would keep working is removed: 209
+  modules that did nothing but re-export, and 13 re-exports inside modules that stay. Import each binding from
+  where it is defined; the table below lists every one. Nothing behaves differently: each removed name was the same
+  object as its replacement, except `fabsf`, which was `Math.abs`.
+  - **Untagged ones too:** fifteen of them never carried `@deprecated` but said in a comment that they were kept for an
+    old import path (`engine/graphics/FrameThrottle.js`, `shade/renderer/camera/OrbitalCameraController.js`, the
+    GTAO constants on `fragment_shader_gtao.js`, …). They went with the rest.
+  - **Kept:** aliases that name a default implementation (`seededRandom`, `mix`, `fresnel_Schlick`,
+    `string_compute_similarity`, `v3_morton_encode`, `Queue`) and re-exports a module offers by design
+    (`DOF2_PRESETS`, `ParticleConstants`' `PARTICLE_VM_INSTRUCTION_WORDS`, `PhysicsSystem`'s `BodyKind` and
+    `RigidBodyFlags`) are not compatibility shims and stay. So does `hsv2rgb_float`, a deprecated wrapper with its own
+    return shape rather than a re-export, and the deprecated method aliases on classes (`Vector3#readFromArray`,
+    `EntityManager#attachDataSet`, …), which are not module exports.
+- **Specs:** the three specs that only pinned alias identity are deleted, and so is `lsb_32.spec.js`, whose cases
+  `ctz32.spec.js` already makes. Specs written against an old name are renamed
+  to the binding they test, and the cases that only re-ran an existing case under the old name are dropped. The
+  colour cases that pinned a behaviour through the old paths now sit in each function's own spec.
+
+<details><summary>Every removed re-export and its replacement</summary>
+
+| Removed | Import instead |
+|---|---|
+| `aabb_build_frustum` from `src/core/geom/3d/aabb/aabb3_build_frustum.js` | `aabb3_build_frustum` from `src/core/geom/3d/aabb/aabb3_build_frustum.js` |
+| `aabb2_array_combine` from `src/core/geom/2d/aabb/aabb2_array_combine.js` | `aabb2_union_array` from `src/core/geom/2d/aabb/aabb2_union_array.js` |
+| `aabb2_compute_area` from `src/core/geom/2d/aabb/aabb2_compute_area.js` | `aabb2_area` from `src/core/geom/2d/aabb/aabb2_area.js` |
+| `aabb2_compute_center_from_multiple` from `src/core/geom/2d/aabb/aabb2_compute_center_from_multiple.js` | `aabb2_center_from_aabb2_buffer` from `src/core/geom/2d/aabb/aabb2_center_from_aabb2_buffer.js` |
+| `aabb2_compute_overlap` from `src/core/geom/2d/aabb/aabb2_compute_overlap.js` | `aabb2_compute_intersection` from `src/core/geom/2d/aabb/aabb2_compute_intersection.js` |
+| `aabb2_from_v2_array` from `src/core/geom/2d/aabb/aabb2_from_v2_array.js` | `aabb2_from_v2_buffer` from `src/core/geom/2d/aabb/aabb2_from_v2_buffer.js` |
+| `aabb2_intersects_point` from `src/core/geom/2d/aabb/aabb2_intersects_point.js` | `aabb2_contains_point` from `src/core/geom/2d/aabb/aabb2_contains_point.js` |
+| `aabb2_overlap_exists` from `src/core/geom/2d/aabb/aabb2_overlap_exists.js` | `aabb2_intersects_aabb2` from `src/core/geom/2d/aabb/aabb2_intersects_aabb2.js` |
+| `aabb3_array_intersects_frustum_degree` from `src/core/geom/3d/aabb/aabb3_array_intersects_frustum_degree.js` | `aabb3_classify_against_frustum_array` from `src/core/geom/3d/aabb/aabb3_classify_against_frustum_array.js` |
+| `aabb3_box_surface_area_2` from `src/core/geom/3d/aabb/aabb3_box_surface_area_2.js` | `aabb3_half_surface_area` from `src/core/geom/3d/aabb/aabb3_half_surface_area.js` |
+| `aabb3_combined_surface_area` from `src/core/geom/3d/aabb/aabb3_combined_surface_area.js` | `aabb3_union_half_surface_area` from `src/core/geom/3d/aabb/aabb3_union_half_surface_area.js` |
+| `aabb3_compute_half_surface_area` from `src/core/geom/3d/aabb/aabb3_compute_half_surface_area.js` | `aabb3_half_surface_area_extents` from `src/core/geom/3d/aabb/aabb3_half_surface_area_extents.js` |
+| `aabb3_compute_surface_area` from `src/core/geom/3d/aabb/aabb3_compute_surface_area.js` | `aabb3_surface_area` from `src/core/geom/3d/aabb/aabb3_surface_area.js` |
+| `aabb3_detailed_volume_intersection` from `src/core/geom/3d/aabb/aabb3_detailed_volume_intersection.js` | `aabb3_compute_clipping_volume_intersection` from `src/core/geom/3d/aabb/aabb3_compute_clipping_volume_intersection.js` |
+| `aabb3_estimate_projected_area2` from `src/core/geom/3d/aabb/aabb3_estimate_projected_area2.js` | `aabb3_estimate_projected_area` from `src/core/geom/3d/aabb/aabb3_estimate_projected_area.js` |
+| `aabb3_intersects_frustum_degree` from `src/core/geom/3d/aabb/aabb3_intersects_frustum_degree.js` | `aabb3_classify_against_frustum` from `src/core/geom/3d/aabb/aabb3_classify_against_frustum.js` |
+| `aabb3_intersects_line_segment` from `src/core/geom/3d/aabb/aabb3_intersects_line_segment.js` | `aabb3_intersects_segment3` from `src/core/geom/3d/aabb/aabb3_intersects_segment3.js` |
+| `aabb3_near_distance_to_intersection_ray_segment` from `src/core/geom/3d/aabb/aabb3_near_distance_to_intersection_ray_segment.js` | `aabb3_ray_segment_entry_distance` from `src/core/geom/3d/aabb/aabb3_ray_segment_entry_distance.js` |
+| `aabb3_nearest_point_on_surface` from `src/core/geom/3d/aabb/aabb3_nearest_point_on_surface.js` | `aabb3_closest_point_on_surface` from `src/core/geom/3d/aabb/aabb3_closest_point_on_surface.js` |
+| `aabb3_project_to_2d` from `src/core/geom/3d/aabb/aabb3_compute_projected_area.js` | `aabb3_projected_area` from `src/core/geom/3d/aabb/aabb3_projected_area.js` |
+| `aabb3_raycast` from `src/core/geom/3d/aabb/aabb3_raycast.js` | `aabb3_raycast_hit_point` from `src/core/geom/3d/aabb/aabb3_raycast_hit_point.js` |
+| `allocate_m4` from `src/core/geom/3d/mat4/allocate_m4.js` | `m4_allocate` from `src/core/geom/3d/mat4/m4_allocate.js` |
+| `AnimationGraphSystem3` from `src/engine/graphics3/AnimationGraphSystem3.js` | `AnimationGraphSystem` from `src/engine/graphics3/AnimationGraphSystem.js` |
+| `AnimationSystem3` from `src/engine/graphics3/AnimationSystem3.js` | `AnimationSystem` from `src/engine/graphics3/AnimationSystem.js` |
+| `apply_mat4_transform_to_direction_v3_array` from `src/core/geom/3d/mat4/apply_mat4_transform_to_direction_v3_array.js` | `m4_transform_direction_v3_buffer` from `src/core/geom/3d/mat4/m4_transform_direction_v3_buffer.js` |
+| `apply_mat4_transform_to_v3_array` from `src/core/geom/3d/mat4/apply_mat4_transform_to_v3_array.js` | `m4_transform_v3_buffer` from `src/core/geom/3d/mat4/m4_transform_v3_buffer.js` |
+| `bt_face_get_attached_faces` from `src/core/geom/3d/topology/struct/binary/query/bt_face_get_attached_faces.js` | `bt_face_get_vertex_adjacent_faces` from `src/core/geom/3d/topology/struct/binary/query/bt_face_get_vertex_adjacent_faces.js` |
+| `bt_face_get_neighbour_faces` from `src/core/geom/3d/topology/struct/binary/query/bt_face_get_neighbour_faces.js` | `bt_face_get_edge_adjacent_faces` from `src/core/geom/3d/topology/struct/binary/query/bt_face_get_edge_adjacent_faces.js` |
+| `bt_faces_shared_loop` from `src/core/geom/3d/topology/struct/binary/query/bt_faces_shared_loop.js` | `bt_face_get_shared_loop` from `src/core/geom/3d/topology/struct/binary/query/bt_face_get_shared_loop.js` |
+| `bt_kill_only_vert` from `src/core/geom/3d/topology/struct/binary/io/vertex/bt_kill_only_vert.js` | `bt_vertex_kill_only` from `src/core/geom/3d/topology/struct/binary/io/vertex/bt_vertex_kill_only.js` |
+| `bt_merge_verts_by_distance` from `src/core/geom/3d/topology/struct/binary/io/vertex/bt_merge_verts_by_distance.js` | `bt_merge_vertices_by_distance` from `src/core/geom/3d/topology/struct/binary/io/vertex/bt_merge_vertices_by_distance.js` |
+| `bt_mesh_build_surface_triangle_bvh` from `src/core/geom/3d/topology/struct/binary/query/bt_mesh_surface_ray_parity.js` | `bt_mesh_build_face_bvh` from `src/core/geom/3d/topology/struct/binary/query/bt_mesh_build_face_bvh.js` |
+| `bt_mesh_compute_vertex_quadratics` from `src/core/geom/3d/topology/struct/binary/io/bt_mesh_compute_vertex_quadratics.js` | `bt_mesh_compute_vertex_quadrics` from `src/core/geom/3d/topology/struct/binary/io/bt_mesh_compute_vertex_quadrics.js` |
+| `bt_mesh_count_edge_faces` from `src/core/geom/3d/topology/struct/binary/query/bt_mesh_count_edge_faces.js` | `bt_edge_count_faces` from `src/core/geom/3d/topology/struct/binary/query/bt_edge_count_faces.js` |
+| `bt_mesh_face_poke` from `src/core/geom/3d/topology/struct/binary/io/face/bt_face_poke.js` | `bt_face_poke` from `src/core/geom/3d/topology/struct/binary/io/face/bt_face_poke.js` |
+| `bt_query_edge_is_boundary` from `src/core/geom/3d/topology/struct/binary/query/bt_query_edge_is_boundary.js` | `bt_edge_is_boundary` from `src/core/geom/3d/topology/struct/binary/query/bt_edge_is_boundary.js` |
+| `bt_vert_fuse_duplicate_edges` from `src/core/geom/3d/topology/struct/binary/io/vertex/bt_vert_fuse_duplicate_edges.js` | `bt_vertex_fuse_duplicate_edges` from `src/core/geom/3d/topology/struct/binary/io/vertex/bt_vertex_fuse_duplicate_edges.js` |
+| `bt_vert_kill` from `src/core/geom/3d/topology/struct/binary/io/vertex/bt_vert_kill.js` | `bt_vertex_kill` from `src/core/geom/3d/topology/struct/binary/io/vertex/bt_vertex_kill.js` |
+| `CameraSystem3` from `src/engine/graphics3/CameraSystem3.js` | `CameraSystem` from `src/engine/graphics3/CameraSystem.js` |
+| `chunk_sample_shadowmap_atlas_for_light` from `src/shade/renderer/shadow/map/shader/chunk_shadowmap_get_light_visibility.js` | `chunk_sample_shadowmap_atlas_for_light` from `src/shade/renderer/shadow/map/shader/chunk_sample_shadowmap_atlas_for_light.js` |
+| `chunk_shade_standard_material_direct_heavy` from `src/shade/renderer/deferred/chunk_shade_standard_material_direct_heavy.js` | `chunk_shade_standard_material_direct` from `src/shade/renderer/deferred/chunk_shade_standard_material_direct.js` |
+| `circle_compute_circle_intersection` from `src/core/geom/2d/circle/circle_compute_circle_intersection.js` | `circle_compute_intersection` from `src/core/geom/2d/circle/circle_compute_intersection.js` |
+| `circle_compute_circle_penetration` from `src/core/geom/2d/circle/circle_compute_circle_penetration.js` | `circle_compute_penetration` from `src/core/geom/2d/circle/circle_compute_penetration.js` |
+| `circle_intersects_point` from `src/core/geom/2d/circle/circle_intersects_point.js` | `circle_contains_point` from `src/core/geom/2d/circle/circle_contains_point.js` |
+| `clipping_volume_matrix4_project` from `src/core/geom/3d/frustum/clipping_volume_matrix4_project.js` | `frustum3_matrix4_project_n` from `src/core/geom/3d/frustum/frustum3_matrix4_project_n.js` |
+| `compose_matrix4_array` from `src/core/geom/3d/mat4/compose_matrix4_array.js` | `m4_compose` from `src/core/geom/3d/mat4/m4_compose.js` |
+| `compute_aabb_from_points` from `src/core/geom/3d/aabb/compute_aabb_from_points.js` | `aabb_nd_from_points` from `src/core/geom/3d/aabb/aabb_nd_from_points.js` |
+| `compute_bounding_cone_of_2_cones` from `src/core/geom/3d/cone/compute_bounding_cone_of_2_cones.js` | `cone_compute_bounding_of_2_cones` from `src/core/geom/3d/cone/cone_compute_bounding_of_2_cones.js` |
+| `compute_bounding_sphere_of_2_spheres` from `src/core/geom/3d/sphere/compute_bounding_sphere_of_2_spheres.js` | `sphere_compute_bounding_of_2_spheres` from `src/core/geom/3d/sphere/sphere_compute_bounding_of_2_spheres.js` |
+| `compute_circle_bounding_box` from `src/core/geom/3d/compute_circle_bounding_box.js` | `circle3_compute_bounding_box` from `src/core/geom/3d/circle3_compute_bounding_box.js` |
+| `compute_polygon_area_2d` from `src/core/geom/2d/compute_polygon_area_2d.js` | `polygon2_signed_area` from `src/core/geom/2d/polygon/polygon2_signed_area.js` |
+| `compute_tetrahedron_quality` from `src/core/geom/3d/tetrahedra/compute_tetrahedron_quality.js` | `tetrahedral_mesh_compute_tet_quality` from `src/core/geom/3d/tetrahedra/tetrahedral_mesh_compute_tet_quality.js` |
+| `compute_tetrahedron_volume` from `src/core/geom/3d/tetrahedra/compute_tetrahedron_volume.js` | `tetrahedral_mesh_compute_tet_volume` from `src/core/geom/3d/tetrahedra/tetrahedral_mesh_compute_tet_volume.js` |
+| `compute_triangle_area_3d` from `src/core/geom/3d/triangle/compute_triangle_area_3d.js` | `tri3_area` from `src/core/geom/3d/triangle/tri3_area.js` |
+| `compute_triangle_group_aabb3` from `src/core/geom/3d/aabb/compute_triangle_group_aabb3.js` | `aabb3_from_triangle_group` from `src/core/geom/3d/aabb/aabb3_from_triangle_group.js` |
+| `compute_triangle_group_aabb3` from `src/engine/graphics/sh3/path_tracer/geometry/compute_triangle_group_aabb3.js` | `aabb3_from_triangle_group` from `src/core/geom/3d/aabb/aabb3_from_triangle_group.js` |
+| `compute_triangle_normal` from `src/core/geom/3d/triangle/compute_triangle_normal.js` | `tri3_compute_normal_v3_objects` from `src/core/geom/3d/triangle/tri3_compute_normal_v3_objects.js` |
+| `computeBoundingSphereOfSpheres` from `src/core/geom/packing/computeBoundingSphereOfSpheres.js` | `sphere_compute_bounding_of_spheres` from `src/core/geom/packing/sphere_compute_bounding_of_spheres.js` |
+| `computeConeBoundingBox` from `src/core/geom/3d/cone/computeConeBoundingBox.js` | `cone_compute_bounding_box` from `src/core/geom/3d/cone/cone_compute_bounding_box.js` |
+| `computeConePlaneSide` from `src/core/geom/3d/cone/computeConePlaneSide.js` | `cone_compute_plane_side` from `src/core/geom/3d/cone/cone_compute_plane_side.js` |
+| `computeTriangleClosestPointToPointBarycentric` from `src/core/geom/3d/triangle/computeTriangleClosestPointToPointBarycentric.js` | `tri3_closest_point_barycentric` from `src/core/geom/3d/triangle/tri3_closest_point_barycentric.js` |
+| `computeTriangleRayIntersection` from `src/core/geom/3d/triangle/computeTriangleRayIntersection.js` | `tri3_ray_intersection` from `src/core/geom/3d/triangle/tri3_ray_intersection.js` |
+| `computeTriangleRayIntersectionBarycentric` from `src/core/geom/3d/triangle/computeTriangleRayIntersectionBarycentric.js` | `tri3_ray_intersection_barycentric` from `src/core/geom/3d/triangle/tri3_ray_intersection_barycentric.js` |
+| `computeTriangleRayIntersectionBarycentricEdge` from `src/core/geom/3d/triangle/computeTriangleRayIntersectionBarycentricEdge.js` | `tri3_ray_intersection_barycentric_edge` from `src/core/geom/3d/triangle/tri3_ray_intersection_barycentric_edge.js` |
+| `computeTriangleRayIntersectionBarycentricGeometry` from `src/core/geom/3d/triangle/computeTriangleRayIntersectionBarycentricGeometry.js` | `tri3_ray_intersection_indexed` from `src/core/geom/3d/triangle/tri3_ray_intersection_indexed.js` |
+| `convertPathToURL` from `src/engine/network/convertPathToURL.js` | `convertPathToURL` from `src/core/path/convertPathToURL.js` |
+| `costByBestShortSide` from `src/core/geom/packing/max-rect/cost/costByBestShortSide.js` | `cost_by_best_short_side` from `src/core/geom/packing/max-rect/cost/cost_by_best_short_side.js` |
+| `costByRemainingArea` from `src/core/geom/packing/max-rect/cost/costByRemainingArea.js` | `cost_by_remaining_area` from `src/core/geom/packing/max-rect/cost/cost_by_remaining_area.js` |
+| `crc32` from `src/core/binary/hash/crc32.js` | `crc32` from `src/core/math/hash/crc32.js` |
+| `crc32` from `src/format/image/png/crc32.js` | `crc32` from `src/core/math/hash/crc32.js` |
+| `cutArea` from `src/core/geom/packing/max-rect/cutArea.js` | `cut_area` from `src/core/geom/packing/max-rect/cut_area.js` |
+| `DebugDrawSystem3` from `src/engine/graphics3/DebugDrawSystem3.js` | `DebugDrawSystem` from `src/engine/graphics3/DebugDrawSystem.js` |
+| `DecalSystem3` from `src/engine/graphics3/DecalSystem3.js` | `DecalSystem` from `src/engine/graphics3/DecalSystem.js` |
+| `decompose_matrix_4_array` from `src/core/geom/3d/mat4/decompose_matrix_4_array.js` | `m4_decompose` from `src/core/geom/3d/mat4/m4_decompose.js` |
+| `editor/view/ecs/components/DatGuiController.js` (default) | `src/view/controller/dat/DatGuiController.js` (default) |
+| `encode_unit_to_hemioct` from `src/core/geom/3d/normal/hemioct/encode_unit3_hemioct.js` | `encode_unit_to_hemioct` from `src/core/geom/3d/normal/hemioct/encode_unit_to_hemioct.js` |
+| `eulerAnglesFromMatrix` from `src/core/geom/3d/mat4/eulerAnglesFromMatrix.js` | `m4_euler_angles` from `src/core/geom/3d/mat4/m4_euler_angles.js` |
+| `fabsf` from `src/core/math/fabsf.js` | `Math.abs` |
+| `fill_in_a_cavity` from `src/core/geom/3d/tetrahedra/delaunay/fill_in_a_cavity.js` | `tetrahedral_mesh_fill_cavity` from `src/core/geom/3d/tetrahedra/delaunay/tetrahedral_mesh_fill_cavity.js` |
+| `findBestContainer` from `src/core/geom/packing/max-rect/findBestContainer.js` | `find_best_container` from `src/core/geom/packing/max-rect/find_best_container.js` |
+| `fixed_convex_hull_humus` from `src/core/geom/2d/convex-hull/fixed_convex_hull_humus.js` | `convex_hull_fixed_count_2d_bruteforce` from `src/core/geom/2d/convex-hull/convex_hull_fixed_count_2d_bruteforce.js` |
+| `fixed_convex_hull_relaxation` from `src/core/geom/2d/convex-hull/fixed_convex_hull_relaxation.js` | `convex_hull_fixed_count_2d_relaxation` from `src/core/geom/2d/convex-hull/convex_hull_fixed_count_2d_relaxation.js` |
+| `FogOfWarSystem3` from `src/engine/graphics3/FogOfWarSystem3.js` | `FogOfWarSystem` from `src/engine/graphics3/FogOfWarSystem.js` |
+| `frameThrottle` from `src/engine/graphics/FrameThrottle.js` | `frameThrottle` from `src/core/function/frameThrottle.js` |
+| `frustum_matrix4_project` from `src/core/geom/3d/frustum/frustum_matrix4_project.js` | `frustum3_matrix4_project` from `src/core/geom/3d/frustum/frustum3_matrix4_project.js` |
+| `frustum3_computeNearestPointToPoint` from `src/core/geom/3d/frustum/frustum3_computeNearestPointToPoint.js` | `frustum3_compute_closest_point` from `src/core/geom/3d/frustum/frustum3_compute_closest_point.js` |
+| `GraphicsEngine3` from `src/engine/graphics3/GraphicsEngine3.js` | `GraphicsEngine` from `src/engine/graphics3/GraphicsEngine.js` |
+| `GTAO_DEPTH_MIP_LEVELS, GTAO_DEPTH_MIP_SAMPLING_OFFSET, GTAO_EFFECT_FALLOFF_RANGE, GTAO_EFFECT_RADIUS` from `src/shade/renderer/postprocess/gtao/fragment_shader_gtao.js` | the same names from `src/shade/renderer/postprocess/gtao/GTAO_CONSTANTS.js` |
+| `hex2rgb` from `src/core/color/hex/hex2rgb.js` | `hex_to_rgb` from `src/core/color/hex/hex_to_rgb.js` |
+| `hexahedron_from_aabb` from `src/core/geom/3d/frustum/hexahedron_from_aabb.js` | `frustum3_from_aabb` from `src/core/geom/3d/frustum/frustum3_from_aabb.js` |
+| `HighlightExtension` from `src/engine/graphics3/HighlightSystem.js` | `HighlightExtension` from `src/engine/graphics3/HighlightOutlineSystem.js` |
+| `HighlightSystem` from `src/engine/graphics3/HighlightSystem.js` | `SGMeshHighlightSystem` from `src/engine/graphics/ecs/mesh-v2/aggregate/SGMeshHighlightSystem.js` |
+| `HighlightSystem3` from `src/engine/graphics3/HighlightSystem3.js` | `SGMeshHighlightSystem` from `src/engine/graphics/ecs/mesh-v2/aggregate/SGMeshHighlightSystem.js` |
+| `hpe_to_xyz` from `src/core/color/hunt/hpe_to_xyz.js` | `hpe_to_xyz` from `src/core/color/xyz/hpe_to_xyz.js` |
+| `hsv2rgb` from `src/core/color/hsv/hsv2rgb.js` | `hsv_to_rgb_uint8` from `src/core/color/hsv/hsv_to_rgb_uint8.js` |
+| `int2rgb` from `src/core/color/int2rgb.js` | `int_to_rgb` from `src/core/color/int_to_rgb.js` |
+| `intersect_ray_2d` from `src/core/geom/2d/intersect_ray_2d.js` | `ray2_ray2_compute_intersection_array_2d` from `src/core/geom/2d/line/ray2_ray2_compute_intersection_array_2d.js` |
+| `is_point_within_planes` from `src/core/geom/3d/plane/is_point_within_planes.js` | `plane3_contains_point_within_set` from `src/core/geom/3d/plane/plane3_contains_point_within_set.js` |
+| `isImageBitmap` from `src/engine/graphics/texture/isImageBitmap.js` | `isImageBitmap` from `src/core/dom/isImageBitmap.js` |
+| `LightSystem3` from `src/engine/graphics3/LightSystem3.js` | `LightSystem` from `src/engine/graphics3/LightSystem.js` |
+| `line_segment_compute_line_segment_intersection_2d` from `src/core/geom/2d/line/line_segment_compute_line_segment_intersection_2d.js` | `segment2_segment_compute_intersection_v2_2d` from `src/core/geom/2d/line/segment2_segment_compute_intersection_v2_2d.js` |
+| `line_segment_compute_line_segment_intersection_array_2d` from `src/core/geom/2d/line/line_segment_compute_line_segment_intersection_array_2d.js` | `segment2_segment_compute_intersection_array_2d` from `src/core/geom/2d/line/segment2_segment_compute_intersection_array_2d.js` |
+| `line_segment_compute_line_segment_intersection_vectors_2d` from `src/core/geom/2d/line/line_segment_compute_line_segment_intersection_vectors_2d.js` | `segment2_segment_compute_intersection_v2_objects_2d` from `src/core/geom/2d/line/segment2_segment_compute_intersection_v2_objects_2d.js` |
+| `line_segment_compute_line_segment_intersection_vectors_array_2d` from `src/core/geom/2d/line/line_segment_compute_line_segment_intersection_vectors_array_2d.js` | `segment2_segment_compute_intersection_to_new_array_2d` from `src/core/geom/2d/line/segment2_segment_compute_intersection_to_new_array_2d.js` |
+| `line_segment_intersection_fraction_2d` from `src/core/geom/2d/line/line_segment_intersection_fraction_2d.js` | `line2_segment_intersection_fraction_2d` from `src/core/geom/2d/line/line2_segment_intersection_fraction_2d.js` |
+| `line_segment_line_segment_intersection_exists_2d` from `src/core/geom/2d/line/line_segment_line_segment_intersection_exists_2d.js` | `segment2_intersects_segment2_2d` from `src/core/geom/2d/line/segment2_intersects_segment2_2d.js` |
+| `line2_distance_to_point_sqr` from `src/core/geom/2d/line/line2_distance_to_point_sqr.js` | `line2_compute_segment_point_distance_sqr` from `src/core/geom/2d/line/line2_compute_segment_point_distance_sqr.js` |
+| `line3_closest_points_segment_segment` from `src/core/geom/3d/line/line3_closest_points_segment_segment.js` | `line3_compute_segment_segment_closest_points` from `src/core/geom/3d/line/line3_compute_segment_segment_closest_points.js` |
+| `line3_compute_nearest_point_to_point` from `src/core/geom/3d/line/line3_compute_nearest_point_to_point.js` | `line3_compute_segment_closest_point` from `src/core/geom/3d/line/line3_compute_segment_closest_point.js` |
+| `line3_compute_segment_nearest_point_to_aabb3_t` from `src/core/geom/3d/line/line3_compute_segment_nearest_point_to_aabb3_t.js` | `line3_compute_segment_closest_point_to_aabb3_t` from `src/core/geom/3d/line/line3_compute_segment_closest_point_to_aabb3_t.js` |
+| `line3_compute_segment_nearest_point_to_point_t` from `src/core/geom/3d/line/line3_compute_segment_nearest_point_to_point_t.js` | `line3_compute_segment_closest_point_t` from `src/core/geom/3d/line/line3_compute_segment_closest_point_t.js` |
+| `LOW_MID_HZ, MID_HIGH_HZ` from `src/engine/sound/simulation/render/reverbImpulseResponse.js` | `LOW_MID_HZ, MID_HIGH_HZ` from `src/engine/sound/simulation/render/reverb_band_tails.js` |
+| `lsb_32` from `src/core/binary/lsb_32.js` | `ctz32` from `src/core/binary/ctz32.js` |
+| `m3_cm_from_translation` from `src/core/geom/mat3/m3_cm_from_translation.js` | `m3_cm_make_translation` from `src/core/geom/mat3/m3_cm_make_translation.js` |
+| `m3_cm_invert` from `src/core/geom/mat3/m3_cm_invert.js` | `m3_invert` from `src/core/geom/mat3/m3_invert.js` |
+| `m3_make_rotation_TBN` from `src/core/geom/mat3/m3_make_rotation.js` | `m3_make_rotation_TBN` from `src/core/geom/mat3/m3_make_rotation_TBN.js` |
+| `m3_multiply_vec3` from `src/core/geom/mat3/m3_multiply_vec3.js` | `m3_scale_columns_by_vec3` from `src/core/geom/mat3/m3_scale_columns_by_vec3.js` |
+| `m4_compute_normal_matrix3` from `src/core/geom/3d/mat4/m4_compute_normal_matrix3.js` | `m4_normal_matrix3` from `src/core/geom/3d/mat4/m4_normal_matrix3.js` |
+| `make_justified_point_grid` from `src/core/geom/3d/util/make_justified_point_grid.js` | `aabb3_emit_point_grid` from `src/core/geom/3d/util/aabb3_emit_point_grid.js` |
+| `MeshSystem3` from `src/engine/graphics3/MeshSystem3.js` | `MeshSystem` from `src/engine/graphics3/MeshSystem.js` |
+| `mortonEncode_LUT` from `src/core/geom/3d/morton/mortonEncode_LUT.js` | `v3_morton_encode_lut` from `src/core/geom/3d/morton/v3_morton_encode_lut.js` |
+| `mortonEncode_magicbits` from `src/core/geom/3d/morton/mortonEncode_magicbits.js` | `v3_morton_encode_magicbits` from `src/core/geom/3d/morton/v3_morton_encode_magicbits.js` |
+| `NodeGraphCamera` from `editor/view/node-graph/NodeGraphView.js` | `NodeGraphCamera` from `editor/view/node-graph/NodeGraphCamera.js` |
+| `octahedral_uv_to_direction` from `src/shade/renderer/light/environment/octahedral_uv_to_direction.js` | `octahedral_z_pole_uv_to_direction` from `src/shade/renderer/light/environment/octahedral_z_pole_uv_to_direction.js` |
+| `optional_equality` from `src/core/model/object/optional_equality.js` | `objectsEqual` from `src/core/function/objectsEqual.js` |
+| `OrbitalCameraController` from `src/shade/renderer/camera/OrbitalCameraController.js` | `OrbitalCameraController` from `src/shade/renderer/camera/orbital/OrbitalCameraController.js` |
+| `orientation3_array` from `src/core/geom/2d/convex-hull/orientation3_array.js` | `orient2d_indexed` from `src/core/geom/2d/convex-hull/orient2d_indexed.js` |
+| `packMaxRectangles` from `src/core/geom/packing/max-rect/packMaxRectangles.js` | `pack_max_rectangles` from `src/core/geom/packing/max-rect/pack_max_rectangles.js` |
+| `packOneBox` from `src/core/geom/packing/max-rect/packOneBox.js` | `pack_one_box` from `src/core/geom/packing/max-rect/pack_one_box.js` |
+| `ParticipatingMediaSystem3` from `src/engine/graphics3/ParticipatingMediaSystem3.js` | `ParticipatingMediaSystem` from `src/engine/graphics3/ParticipatingMediaSystem.js` |
+| `PARTICLE_GRAPH_ERROR, PARTICLE_GRAPH_INFO, PARTICLE_GRAPH_WARNING` from `src/shade/renderer/particles/graph/validate_particle_graph.js` | the same names from `src/shade/renderer/particles/graph/particle_graph_diagnostic.js` |
+| `PathDisplaySystem3` from `src/engine/graphics3/PathDisplaySystem3.js` | `PathDisplaySystem` from `src/engine/graphics3/PathDisplaySystem.js` |
+| `PickingSystem3` from `src/engine/graphics3/PickingSystem3.js` | `PickingSystem` from `src/engine/graphics3/PickingSystem.js` |
+| `plane3_compute_convex_3_plane_intersection` from `src/core/geom/3d/plane/plane3_compute_convex_3_plane_intersection.js` | `plane3_compute_3_plane_intersection` from `src/core/geom/3d/plane/plane3_compute_3_plane_intersection.js` |
+| `plane3_compute_plane_intersection` from `src/core/geom/3d/plane/plane3_compute_plane_intersection.js` | `plane3_compute_intersection_objects` from `src/core/geom/3d/plane/plane3_compute_intersection_objects.js` |
+| `plane3_intersect_plane` from `src/core/geom/3d/plane/plane3_intersect_plane.js` | `plane3_compute_intersection` from `src/core/geom/3d/plane/plane3_compute_intersection.js` |
+| `plane3_three_compute_convex_3_plane_intersection` from `src/core/geom/3d/plane/plane3_three_compute_convex_3_plane_intersection.js` | `plane3_compute_3_plane_intersection_from_three` from `src/core/geom/3d/plane/plane3_compute_3_plane_intersection_from_three.js` |
+| `PlaneGeometry` from `src/shade/renderer/geometry/BoxGeometry.js` | `PlaneGeometry` from `src/shade/renderer/geometry/PlaneGeometry.js` |
+| `Preloader` from `src/engine/asset/preloader/AssetPreloader.js` | `AssetPreloader` from `src/engine/asset/preloader/AssetPreloader.js` |
+| `qt_query_data_nearest_to_point` from `src/core/geom/2d/quad-tree/qt_query_data_nearest_to_point.js` | `qt_query_closest_to_point` from `src/core/geom/2d/quad-tree/qt_query_closest_to_point.js` |
+| `quat_decode_from_uint32` from `src/core/geom/3d/quaternion/quat_decode_from_uint32.js` | `quat3_decode_from_uint32` from `src/core/geom/3d/quaternion/quat3_decode_from_uint32.js` |
+| `quat_encode_to_uint32` from `src/core/geom/3d/quaternion/quat_encode_to_uint32.js` | `quat3_encode_to_uint32` from `src/core/geom/3d/quaternion/quat3_encode_to_uint32.js` |
+| `quat3_createFromAxisAngle` from `src/core/geom/3d/quaternion/quat3_createFromAxisAngle.js` | `quat3_from_axis_angle` from `src/core/geom/3d/quaternion/quat3_from_axis_angle.js` |
+| `randomPointInBox` from `src/core/geom/random/randomPointInBox.js` | `random_point_in_box` from `src/core/geom/random/random_point_in_box.js` |
+| `randomPointInCircle` from `src/core/geom/random/randomPointInCircle.js` | `random_point_in_circle` from `src/core/geom/random/random_point_in_circle.js` |
+| `randomPointInPoint` from `src/core/geom/random/randomPointInPoint.js` | `random_point_in_point` from `src/core/geom/random/random_point_in_point.js` |
+| `randomPointInSphere` from `src/core/geom/random/randomPointInSphere.js` | `random_point_in_sphere` from `src/core/geom/random/random_point_in_sphere.js` |
+| `randomPointOnBox` from `src/core/geom/random/randomPointOnBox.js` | `random_point_on_box` from `src/core/geom/random/random_point_on_box.js` |
+| `randomPointOnSphere` from `src/core/geom/random/randomPointOnSphere.js` | `random_point_on_sphere` from `src/core/geom/random/random_point_on_sphere.js` |
+| `ray3_array_compose` from `src/core/geom/3d/ray/ray3_array_compose.js` | `ray3_compose_array` from `src/core/geom/3d/ray/ray3_compose_array.js` |
+| `ray3_compute_nearest_point_to_point` from `src/core/geom/3d/ray/ray3_compute_nearest_point_to_point.js` | `ray3_compute_closest_point` from `src/core/geom/3d/ray/ray3_compute_closest_point.js` |
+| `ray3_distance_to_point` from `src/core/geom/3d/ray/ray3_distance_to_point.js` | `ray3_compute_point_projection_t` from `src/core/geom/3d/ray/ray3_compute_point_projection_t.js` |
+| `ray3_shift_origin_along_direction` from `src/core/geom/3d/ray/ray3_shift_origin_along_direction.js` | `ray3_shift_origin_along_direction_array` from `src/core/geom/3d/ray/ray3_shift_origin_along_direction_array.js` |
+| `rayTriangleIntersection` from `src/core/geom/3d/triangle/rayTriangleIntersection.js` | `tri3_ray_intersection_v3_objects` from `src/core/geom/3d/triangle/tri3_ray_intersection_v3_objects.js` |
+| `read_three_planes_to_array` from `src/core/geom/3d/frustum/read_three_planes_to_array.js` | `frustum3_planes_to_flat_from_three` from `src/core/geom/3d/frustum/frustum3_planes_to_flat_from_three.js` |
+| `rectangle_to_aabb` from `src/core/geom/2d/rectangle_to_aabb.js` | `aabb2_from_rectangle` from `src/core/geom/2d/aabb/aabb2_from_rectangle.js` |
+| `removeRedundantBoxes` from `src/core/geom/packing/max-rect/removeRedundantBoxes.js` | `remove_redundant_boxes` from `src/core/geom/packing/max-rect/remove_redundant_boxes.js` |
+| `removeRedundantBoxesArray` from `src/core/geom/packing/max-rect/removeRedundantBoxesArray.js` | `remove_redundant_boxes_from_array` from `src/core/geom/packing/max-rect/remove_redundant_boxes_from_array.js` |
+| `rgb2hex` from `src/core/color/hex/rgb2hex.js` | `rgb_to_hex` from `src/core/color/hex/rgb_to_hex.js` |
+| `rgb2hsv` from `src/core/color/hsv/rgb2hsv.js` | `rgb_to_hsv` from `src/core/color/hsv/rgb_to_hsv.js` |
+| `rgb2uint24` from `src/core/color/rgb2uint24.js` | `rgb_to_uint24` from `src/core/color/rgb_to_uint24.js` |
+| `rgb2uint32` from `src/core/color/rgb2uint32.js` | `rgb_to_uint32` from `src/core/color/rgb_to_uint32.js` |
+| `sh_compute_K` from `src/core/geom/3d/sphere/harmonics/sh_compute_K.js` | `sh_normalization_factor` from `src/core/geom/3d/sphere/harmonics/sh_normalization_factor.js` |
+| `sh3_rotate_bl` from `src/core/geom/3d/sphere/harmonics/sh3_rotate_bl.js` | `sh3_rotate` from `src/core/geom/3d/sphere/harmonics/sh3_rotate.js` |
+| `sh3_sample_irradiance_by_direction` from `src/shade/renderer/global_illumination/lpv/lpv_visualise_probes.js` | `sh3_sample_irradiance_by_direction` from `src/core/geom/3d/sphere/harmonics/sh3_sample_irradiance_by_direction.js` |
+| `ShadedGeometrySystem3` from `src/engine/graphics3/ShadedGeometrySystem3.js` | `ShadedGeometrySystem` from `src/engine/graphics3/ShadedGeometrySystem.js` |
+| `shader_cull_lights_frustum` from `src/shade/renderer/light/cluster/cull/shader_cull_lights_frustum.js` | `shader_cull_point_lights_frustum` from `src/shade/renderer/light/cluster/cull/shader_cull_lights_frustum.js` |
+| `shape_mesh_from_geometry` from `src/core/geom/3d/shape/shape_mesh_from_geometry.js` | `shape3_mesh_from_geometry` from `src/core/geom/3d/shape/shape3_mesh_from_geometry.js` |
+| `shape3d_voxelize_to_grid` from `src/core/geom/3d/shape/util/shape3d_voxelize_to_grid.js` | `shape3_voxelize_to_grid` from `src/core/geom/3d/shape/util/shape3_voxelize_to_grid.js` |
+| `slice_frustum_linear_to_points` from `src/core/geom/3d/frustum/slice_frustum_linear_to_points.js` | `frustum3_slice_linear_to_points` from `src/core/geom/3d/frustum/frustum3_slice_linear_to_points.js` |
+| `sphere_array_intersects_point` from `src/core/geom/3d/sphere/sphere_array_intersects_point.js` | `sphere_packed_contains_point` from `src/core/geom/3d/sphere/sphere_packed_contains_point.js` |
+| `sphere_array_intersects_ray` from `src/core/geom/3d/sphere/sphere_array_intersects_ray.js` | `sphere_packed_intersects_ray` from `src/core/geom/3d/sphere/sphere_packed_intersects_ray.js` |
+| `sphere_intersects_point` from `src/core/geom/3d/sphere/sphere_intersects_point.js` | `sphere_contains_point` from `src/core/geom/3d/sphere/sphere_contains_point.js` |
+| `sphere_matrix4_project` from `src/core/geom/3d/sphere/sphere_matrix4_transform.js` | `sphere_matrix4_transform` from `src/core/geom/3d/sphere/sphere_matrix4_transform.js` |
+| `sphere_projected_sphere_radius_sqr` from `src/core/geom/3d/sphere/sphere_projected_sphere_radius_sqr.js` | `sphere_projected_radius_sqr` from `src/core/geom/3d/sphere/sphere_projected_radius_sqr.js` |
+| `sphere_radius_sqr_from_v3_array_transformed` from `src/core/geom/3d/sphere/sphere_radius_sqr_from_v3_array_transformed.js` | `sphere_radius_sqr_from_v3_buffer_transformed` from `src/core/geom/3d/sphere/sphere_radius_sqr_from_v3_buffer_transformed.js` |
+| `spherical_from_cartesian` from `src/core/geom/3d/sphere/spherical_from_cartesian.js` | `sphere_spherical_from_cartesian` from `src/core/geom/3d/sphere/sphere_spherical_from_cartesian.js` |
+| `spline_bezier2_2d` from `src/core/geom/2d/spline_bezier2_2d.js` | `spline2_quadratic_bezier` from `src/core/geom/2d/spline2_quadratic_bezier.js` |
+| `SplitView` from `editor/view/v2/SplitView.js` | `SplitView` from `src/view/layout/SplitView.js` |
+| `src/core/binary/hash/xxh3_common.js` (every export) | `src/core/math/hash/xxh3_common.js` |
+| `string_compute_byte_size` from `src/core/primitives/strings/string_compute_byte_size.js` | `utf8_encoded_length` from `src/core/binary/utf8/utf8_encoded_length.js` |
+| `TerrainSystem3` from `src/engine/graphics3/TerrainSystem3.js` | `TerrainSystem` from `src/engine/graphics3/TerrainSystem.js` |
+| `tetrahedral_mesh_tet_get_neighbours` from `src/core/geom/3d/tetrahedra/tetrahedral_mesh_tet_get_neighbours.js` | `tetrahedral_mesh_get_neighbours` from `src/core/geom/3d/tetrahedra/tetrahedral_mesh_get_neighbours.js` |
+| `TooltipComponentSystem3` from `src/engine/graphics3/TooltipComponentSystem3.js` | `TooltipComponentSystem` from `src/engine/graphics3/TooltipComponentSystem.js` |
+| `Trail3DSystem3` from `src/engine/graphics3/Trail3DSystem3.js` | `Trail3DSystem` from `src/engine/graphics3/Trail3DSystem.js` |
+| `triangle_compute_plane_side` from `src/core/geom/3d/triangle/triangle_compute_plane_side.js` | `tri3_compute_plane_side` from `src/core/geom/3d/triangle/tri3_compute_plane_side.js` |
+| `triangle_compute_signed_volume` from `src/core/geom/3d/triangle/triangle_compute_signed_volume.js` | `tri3_compute_signed_volume` from `src/core/geom/3d/triangle/tri3_compute_signed_volume.js` |
+| `triangle_intersects_clipping_volume` from `src/core/geom/3d/triangle/triangle_intersects_clipping_volume.js` | `tri3_intersects_clipping_volume` from `src/core/geom/3d/triangle/tri3_intersects_clipping_volume.js` |
+| `triangle_mesh_compute_signed_volume` from `src/core/geom/3d/triangle/triangle_mesh_compute_signed_volume.js` | `tri3_mesh_compute_signed_volume` from `src/core/geom/3d/triangle/tri3_mesh_compute_signed_volume.js` |
+| `triangle2d_compute_area` from `src/core/geom/2d/triangle2d_compute_area.js` | `tri2_signed_area` from `src/core/geom/2d/triangle/tri2_signed_area.js` |
+| `triangle2d_contains_point` from `src/core/geom/2d/triangle2d_contains_point.js` | `tri2_contains_point` from `src/core/geom/2d/triangle/tri2_contains_point.js` |
+| `triangle2d_get_barycentric` from `src/core/geom/2d/triangle2d_get_barycentric.js` | `tri2_compute_barycentric` from `src/core/geom/2d/triangle/tri2_compute_barycentric.js` |
+| `triangle3_incenter` from `src/core/geom/3d/triangle/triangle3_incenter.js` | `tri3_incenter` from `src/core/geom/3d/triangle/tri3_incenter.js` |
+| `v3_angle_atan2_between` from `src/core/geom/vec3/v3_angle_atan2_between.js` | `v3_angle_stable` from `src/core/geom/vec3/v3_angle_stable.js` |
+| `v3_angle_between` from `src/core/geom/vec3/v3_angle_between.js` | `v3_angle` from `src/core/geom/vec3/v3_angle.js` |
+| `v3_angle_cos_between` from `src/core/geom/vec3/v3_angle_cos_between.js` | `v3_cos_angle` from `src/core/geom/vec3/v3_cos_angle.js` |
+| `v3_array_add_in_place` from `src/core/geom/vec3/v3_array_add_in_place.js` | `v3_add` from `src/core/geom/vec3/v3_add.js` |
+| `v3_array_centroid` from `src/core/geom/vec3/v3_array_centroid.js` | `v3_centroid_v3_buffer` from `src/core/geom/vec3/v3_centroid_v3_buffer.js` |
+| `v3_array_copy` from `src/core/geom/vec3/v3_array_copy.js` | `v3_copy_array` from `src/core/geom/vec3/v3_copy_array.js` |
+| `v3_array_displace_in_direction` from `src/core/geom/vec3/v3_array_displace_in_direction.js` | `v3_displace_in_direction_to_array` from `src/core/geom/vec3/v3_displace_in_direction_to_array.js` |
+| `v3_array_equals` from `src/core/geom/vec3/v3_array_equals.js` | `v3_equals_array` from `src/core/geom/vec3/v3_equals_array.js` |
+| `v3_array_immediate_add` from `src/core/geom/vec3/v3_array_immediate_add.js` | `v3_add_array` from `src/core/geom/vec3/v3_add_array.js` |
+| `v3_array_matrix4_rotate` from `src/core/geom/vec3/v3_array_matrix4_rotate.js` | `v3_matrix4_rotate_array` from `src/core/geom/vec3/v3_matrix4_rotate_array.js` |
+| `v3_array_normalize` from `src/core/geom/vec3/v3_array_normalize.js` | `v3_normalize_array` from `src/core/geom/vec3/v3_normalize_array.js` |
+| `v3_array_scale` from `src/core/geom/vec3/v3_array_scale.js` | `v3_scale_array` from `src/core/geom/vec3/v3_scale_array.js` |
+| `v3_compute_interior_angle` from `src/core/geom/vec3/v3_compute_interior_angle.js` | `v3_interior_angle` from `src/core/geom/vec3/v3_interior_angle.js` |
+| `v3_compute_triangle_normal` from `src/core/geom/3d/triangle/v3_compute_triangle_normal.js` | `tri3_compute_normal` from `src/core/geom/3d/triangle/tri3_compute_normal.js` |
+| `v3_dot_array_array` from `src/core/geom/vec3/v3_dot_array_array.js` | `v3_dot_array` from `src/core/geom/vec3/v3_dot_array.js` |
+| `v3_matrix4_rotate` from `src/core/geom/vec3/v3_matrix4_rotate.js` | `v3_matrix4_rotate_unit` from `src/core/geom/vec3/v3_matrix4_rotate_unit.js` |
+| `v3_multiply_scalar` from `src/core/geom/vec3/v3_multiply_scalar.js` | `v3_scale` from `src/core/geom/vec3/v3_scale.js` |
+| `v3_quat3_apply` from `src/core/geom/vec3/v3_quat3_apply.js` | `v3_quaternion_apply` from `src/core/geom/vec3/v3_quaternion_apply.js` |
+| `v3_quat3_apply_inverse` from `src/core/geom/vec3/v3_quat3_apply_inverse.js` | `v3_quaternion_apply_inverse` from `src/core/geom/vec3/v3_quaternion_apply_inverse.js` |
+| `v3_triple_cross_product` from `src/core/geom/vec3/v3_triple_cross_product.js` | `v3_triple_cross` from `src/core/geom/vec3/v3_triple_cross.js` |
+| `v4_multiply_mat4` from `src/core/geom/vec4/v4_multiply_mat4.js` | `v4_matrix4_multiply` from `src/core/geom/vec4/v4_matrix4_multiply.js` |
+| `vector_copy` from `src/core/geom/vec/vector_copy.js` | `vector_copy_offset` from `src/core/geom/vec/vector_copy_offset.js` |
+| `vector_scale_array` from `src/core/geom/vec/vector_scale_array.js` | `vector_scale_offset` from `src/core/geom/vec/vector_scale_offset.js` |
+| `VolumetricLightMapSystem3` from `src/engine/graphics3/VolumetricLightMapSystem3.js` | `VolumetricLightMapSystem` from `src/engine/graphics3/VolumetricLightMapSystem.js` |
+| `WaterSystem3` from `src/engine/graphics3/WaterSystem3.js` | `WaterSystem` from `src/engine/graphics3/WaterSystem.js` |
+| `XXH128Hash` from `src/core/binary/hash/XXH128Hash.js` | `XXH128Hash` from `src/core/math/hash/XXH128Hash.js` |
+| `xxh3_128` from `src/core/binary/hash/xxh3_128.js` | `xxh3_128` from `src/core/math/hash/xxh3_128.js` |
+| `xxh3_64` from `src/core/binary/hash/xxh3_64.js` | `xxh3_64` from `src/core/math/hash/xxh3_64.js` |
+| `XXH3_SECRET` from `src/core/binary/hash/XXH3_SECRET.js` | `XXH3_SECRET` from `src/core/math/hash/XXH3_SECRET.js` |
+| `xyz_to_hpe` from `src/core/color/hunt/xyz_to_hpe.js` | `xyz_to_hpe` from `src/core/color/xyz/xyz_to_hpe.js` |
+
+</details>
+
+### Every tile draws the species' own leaf, and a card is one leaf
+
+- **Added:** `LeafArchitecture` (`FoliageMaterialConfig.leaf`), a species' leaf as floras describe it, in the terms
+  of Ellis et al. (2009), *Manual of Leaf Architecture*. It has `LeafApexShape`, `LeafBaseShape` and
+  `LeafLobation`, and covers:
+  - blade size, length/width ratio and where the blade is widest;
+  - apex and base angles and shapes;
+  - pinnate or palmate lobes and sinus depth;
+  - teeth per centimetre, their depth and order;
+  - secondary veins, petiole, and a compound leaf's leaflets and rachis.
+  Oak, birch, willow, maple and hazel cite their floras (Flora of North America, Flora of China, BSBI, Critchfield
+  1971), and the oak's outline is fitted to Boratyński et al. (2008). See `LEAF_ARCHITECTURE_BRIEF_2026_10_26.md`.
+- **Added:** `leaf_geometry`, `needle_shoot_geometry`, `foliage_tile_layout` and `foliage_tile_raster`, which draw a
+  tile from the architecture. Also `polygon2_rasterize_coverage` (core): scanline coverage of contours by the nonzero
+  rule.
+- **Added:** `FoliageTileContent`. A tile draws one leaf, or a stretch of needle shoot with the needles the shoot bears
+  there, shared among the card's planes.
+- **Changed:** a broadleaf card is one leaf at its own node on its shoot, at the leaf's true size, leaving the shoot
+  at the rule's insertion angle. Short shoots' leaves sit at their tip (`FoliageConfig.leaves_per_short_shoot`). The
+  broadleaf presets draw `CutoutHull` cards.
+- **Changed:** card size, anchor and atlas resolution come from the tile layout. The resolution draws the leaf's
+  finest feature four texels across and its stems two.
+- **Changed:** `make_foliage_material(species, out_cutout)` and `foliage_atlas_cutout(species, out)` take the species.
+  `foliage_unit_card_spans` takes the leaves a card draws. `foliage_cards_per_metre`, `foliage_card_leaf_area` and
+  `foliage_leaf_area_per_metre` take the tile layout or a reach.
+- **Removed:**
+  - `FoliageMaterialConfig.leaf_shape`, `leaflets_per_cluster`, `leaf_arrangement` (the rosette),
+    `short_shoot_leaflets`, `resolution`, `stem_anchor_u` and `stem_anchor_v`;
+  - `FoliageConfig.card_width` and `card_length`;
+  - `foliage_leaf_silhouette.js` and `foliage_atlas_tiles.js`;
+  - `foliage_card_leaf_count`.
+
+### Every woody species grows its twigs, and its crown fills by light
+
+- **Added:** `ShootGrowthConfig` (`TreeSpeciesConfig.shoot_growth`): leader growth, and the net shoots a shoot leaves
+  a year as a function of its light, from 1 at the compensation light to `vigour` at saturation. Spruce, pine and
+  birch are sourced; oak, maple, willow and the shrub borrow the curve's shape. The shrub's full-sun vigour is its
+  gross yield from Grisafi et al. (2024), so only shade sheds its shoots.
+- **Added:** `ShootBudZone`, per-order bud zones of a `ShootSystemRule` (long, sylleptic and short shoots). Pine,
+  spruce, birch, maple, willow and the shrub get shoot rules from their sources (see
+  `SHOOT_SYSTEMS_ALL_SPECIES_BRIEF_2026_10_26.md`).
+- **Changed:** `tree_skeleton_grow_shoots` grows every carrier's twigs in one season loop under a voxel light field
+  (Beer-Lambert from a standard overcast sky). Shoots are shed to their light's net yield, the wood thickens each
+  season with what it carries, and a shoot the wood grows into dies (`CROWN_FILLING_BRIEF_2026_10_26.md`).
+- **Changed:** a unit carries as many cards as its leaves fill, not one scaled card. Short shoots draw rosette tiles
+  of their own.
+- **Added:** `TreeSkeleton.branch_unit_offset`, `branch_unit_count`, `unit_start_t` and `branch_unit_start_t`: every
+  annual unit of a branch grown by them.
+- **Removed:** `TreeSkeleton.branch_current_growth_t` (use `branch_unit_start_t(b, 0)`); `ShootSystemRule.years`,
+  `vigour` and `carrier_unit_length` (the light and the leader growth set them); `shoot_demography_grow`;
+  `foliage_current_shoot_card_scale`.
+
+### Wind seats keep the joints that move them alike
+
+- **Changed:** where more than four skinning joints meet at a branch seat or card, the four kept are those that leave
+  the point closest to where all of them would carry it in the reference wind, and a dropped joint folds into the
+  kept one that carries the point most alike: each joint between two turns the point by its rotation times its lever.
+  `interpolate_ring_skin_weights4` takes the joints' motion (`tree_skeleton_read_joint_motion`) and the point, in
+  place of `joint_parents`.
+- **Added:** `TreeSkeleton.joint_count`, `joint_vertex`, `joint_rotation` and `set_joints`, written by
+  `tree_skeleton_assign_skin_joints`: where each joint pivots and how far it turns in the reference wind.
+
+### Annual shoots: the oak's leaves sit on this year's twigs
+
+- **Added:** `TreeSpeciesConfig.shoot_rules` (`ShootSystemRule`). It grows the twig system on a carrier
+  generator year by year (`tree_skeleton_grow_shoots`), from the oak shoot demography of Buck-Sorlin & Bell
+  (Forestry 73(1), 2000; Bot. J. Linn. Soc. 127, 1998):
+  - Each living axis extends its terminal bud every year.
+  - Last year's unit bursts its 4 subapical buds (29% each) and its median buds (4.5% each).
+  - Unit lengths are drawn from their distributions, shorter with branching order.
+  - Each year keeps `vigour / 2.65` of its new shoots, highest-order and shortest first. `vigour` is the knob for
+    how full the periphery grows (1 holds it steady).
+  - Each axis is one branch with one segment per year. Twig radii follow the paper's Table 7, by length and age. No
+    twig grows through framework wood.
+  See `ANNUAL_SHOOTS_BRIEF_2026_10_25.md`.
+- **Added:** `TreeSkeleton.branch_current_growth_t`, where a branch's current-year unit starts (-1 if not recorded).
+  A carrier that records it carries one card on that unit, scaled to its length, in place of the density rule.
+  Each card draws its own maturity from its branch.
+- **Added:** `FoliageMaterialConfig.leaf_arrangement`. The new `"rosette"` crowds a shoot's leaves at its tip, as
+  an oak's are. `"rachis"` is the existing arrangement and the default.
+- **Changed:** the oak preset grows shoots on generators 1, 2 and 4, with 0.17 m `TriStarCluster` cards where its
+  cards were a median 0.90 m. Its secondary branches are 1.4x longer, 12 to a bough where there were 8. At seed 1337 it has 2,261
+  cards (was 842), 5,703 wind joints (447) and 9,860 skeleton nodes (766), with LAI 3.2 over its crown's top
+  silhouette (was 4.0). It is more see-through: side opacity 0.49 against 0.64. Generation takes 441 ms against 291 ms.
+- **Changed:** each segment bends under its own drag and weight, acting at L / 6, as well as under what it carries. A
+  one-unit twig had zero compliance before. `TreeWindConfig.elastic_modulus` is refitted from 3.33e7 to 4.55e7, so
+  the oak's median primary bough keeps its sway (ratio 0.999 over 12 seeds). Maple boughs move 1.12x, pine 1.14x and
+  birch 1.04x.
+- **Changed:** `TreeWindConfig.max_joints` defaults to 16,384, a chosen number above every preset's skeleton node
+  count, the oak's included.
+- **Changed:** `tree_skeleton_compute_branch_frequency` and `tree_skeleton_compute_segment_compliance` are exported.
+
+### Leaf cards count in how far a bend reaches
+
+- **Fixed:** `TreeSegmentMechanics.reach` counted only the skeleton a segment carries, though a leaf card hangs up to a
+  metre past its anchor (oak: median card 0.90 m). A leafy segment now reaches half its length plus its card, and a
+  segment carrying a leafy one adds that card to the distance, so joint placement sees how far twig rotation moves the
+  leaves. Counts at 1 cm barely move: oak 447 -> 447, pine 517 -> 525, fern 26 -> 26.
+
+### Wind joints sway in their branch's mode
+
+- **Fixed:** with the derived joint count the oak's leaves shook. Each joint's natural frequency was the
+  single-degree-of-freedom estimate of its own span, so cutting a branch into short spans made every piece stiffer:
+  the same 12 bough hinges rang at 5.0 rad/s with 32 joints, 10.4 at 1 cm and 12.7 with a joint on every node, and
+  the oak's twig joints at a median 4.4 Hz (max 19 Hz), each fluttering at its own rate.
+  - **Now:** every joint on a branch takes the branch's first-mode frequency, the same estimate taken for the whole
+    branch about its root with everything it carries (`tree_skeleton_compute_branch_frequency`). Joints already
+    shared their branch's phase, so a branch now sways as one piece however many joints the rig cuts it into.
+  - **Oak at 1 cm:** trunk 0.27 Hz, boughs a median 0.89 Hz (p90 1.5), twigs 1.7 Hz (p90 2.6, max 6.2). The bough
+    hinges are back at 5.0 rad/s at any joint count.
+  - **Playground.** Stepped at 1/240 s in the default wind, with every joint's deflection read back from the GPU,
+    the oak's joints swayed at a median 3.2–3.8 Hz (p90 5.9–6.5, max 12.5–18.9) before and sway at 1.3–1.5 Hz
+    (p90 2.4–2.7, max 4.6–9.9) now, at the same amplitude (median 0.0034–0.0040 rad), over two runs each.
+  - **Breaking:** `tree_skeleton_compute_joint_mechanics` no longer takes `joint_parents`.
+- **Specs:** a uniform stem's frequency scales as r / L^2, as an Euler-Bernoulli cantilever's; a stem's joints all
+  take its frequency; on the oak every joint on a branch shares one frequency and phase, and a branch's frequency is
+  the same at 32 joints and with a joint on every node. The last two failed against the per-span frequencies. A
+  mutant that leaves a branch's laterals out of what it carries survives them.
+
+### Wind joints: the tree decides how many, `max_joints` is a safety net
+
+- **Changed:** `tree_skeleton_assign_skin_joints` derives the number of wind joints from the tree instead of filling a
+  budget of 32. A joint goes wherever the rig would otherwise hide visible sway in the 6.5 m/s wind the wood is fitted
+  to (`TREE_WIND_REFERENCE_SPEED`).
+  - **Branch without a joint.** Its bending is lost, so it gets a joint when that bending would move what it carries
+    by more than the tolerance.
+  - **Within a joint's span.** The joint rotates the whole span about one pivot, so a new joint starts where the error
+    of doing that would pass the tolerance.
+  - **Tolerance.** `TreeWindConfig.deflection_tolerance`, a distance in metres (default 0.01, a chosen number). A tall
+    tree's bends move more, so it takes more joints than a small one. Bends are taken as the rig shows them, saturated
+    at its bend limit (`tree_wind_bend_limit`, now shared with `build_tree_wind_rig`).
+  - **Counts (seed 1337).** Oak 447, pine 517, birch 185, willow 514, maple 311, spruce 416, palm 65, shrub 46 and
+    fern 26, up from 32 each. With 10x stiffer wood the oak takes 187, and with 100x it takes 1, which leaves no joint
+    that moves. Dead stubs and other wood that barely bends get none.
+- **New:** `TreeWindConfig.deflection_tolerance` (m). The oak takes 234 joints at 0.04 and 609 at 0.0025, and
+  `Infinity` gives no wind joints.
+- **Changed:** `TreeWindConfig.max_joints` defaults to 4,096 and only caps the derived count. Past it, the joints that
+  keep the least sway are dropped. 4,096 is a chosen number above every preset's skeleton node count. Values above
+  65,536 are clamped, since joint indices are 16-bit.
+- **New:** `TreeSegmentMechanics.reach` (distance to the farthest element a segment carries) and
+  `tree_skeleton_compute_segment_compliance`.
+- **Changed:** where a child branch's base ring or a leaf card sits on a frustum whose two rings hold more than 4
+  joints between them, `interpolate_ring_skin_weights4` now gives each joint past the fourth to the kept joint
+  nearest it in the joint tree, instead of spreading its weight over all four. It takes the joint tree as a new
+  argument (`tree_skeleton_read_joint_parents`).
+  - **Measured.** In a steady 6.5 m/s pose, the widest seam on the bark spec's five presets went from 1.05 to 0.74 mm,
+    and on the oak's leaf cards from 0.81 to 0.39 mm.
+  - **Why it happens.** Skinning has 4 weights per vertex, so no layout can seat every branch exactly at every depth.
+    This happened at 32 joints too (the fern dropped up to 14% of a weight at 4 seats); the derived count makes it
+    more common (spruce at 73 of 1,341 seats).
+- A branch's joint compliances still sum to its own bend however many joints it gets, so `elastic_modulus` keeps its
+  fit.
+- **Specs:** the bark and foliage seam specs bound the gap in metres, by `deflection_tolerance`, in a steady
+  `TREE_WIND_REFERENCE_SPEED` pose, instead of asking for exactly matching weights. Skinning has 4 weights per vertex,
+  and a branch base or leaf card seated where more than 4 joints meet cannot carry them all; the 32-joint budget hid
+  that on all but the fern.
+
+### Seasons: leaves fall and wilt with senescence, and card tints can brighten
+
+- **New:** leaf drop. With `FoliageMaterialConfig.senescence`, `foliage_collect_attachments` sheds each card once
+  senescence passes its own threshold (`foliage_abscission_threshold`).
+  - **First leaves.** A leaf waits for its own atlas tile. The pigment model ages each tile at its own pace
+    (`foliage_variant_senescence`, now shared with `make_foliage_material`), and `foliage_variant_abscission_onset`
+    solves for the point where a tile's exposed lamina has lost its chlorophyll. That point runs from 0.66 for mature
+    tiles to 0.82 for mid-maturity ones.
+  - **Order.** After its tile's onset, outer and apical leaves go first; the threshold is ordered by sun exposure and
+    position along the shoot.
+  - **End state.** The crown is bare at 1. On maple (seed 5), 33% of cards are left at 0.9 and none at 0.97.
+- **New:** wilt. Each attached card carries `dryness`, which rises from its tile's onset to its own fall. A drying
+  card goes towards a leaf with no turgor: it rolls shut (fold towards 90°), its arch flattens, and its tip hangs
+  (`camber_droop` towards 1).
+  - **Card types.** Only the folding cards wilt: `FoldedVCard`, `RibbedFrond` and `CutoutHull`. `CrossCard` and
+    `TriStarCluster` cards have no fold to close.
+  - **About to fall.** A card falls before it reaches the limit. One about to fall is close to shut, a sliver with
+    near-zero area. That is measured and valid: no non-finite positions, normals or tangents.
+- **Changed:** the wind rig sees leaf drop. The joint mechanics drop the sail of shed leaves, judging the expected leaf
+  at each segment by the same rule, so maple's summed joint compliance falls by more than 20% when it is bare.
+- **Fixed:** card tints were clamped to 1 before the `unorm8` vertex colours, so they could only darken. About half
+  of all tint channels sat above 1 and were clipped.
+  - **Now:** `foliage_collect_attachments` computes each card's tint (`tints`) and the largest channel
+    (`tint_scale`, about 1.09–1.11 across presets). Vertex colours carry `tint / tint_scale`, and `generate_tree`
+    sets the synthesized foliage material's `diffuse_color` to `tint_scale`.
+  - **Custom material:** a caller's own foliage material is left alone, and its tints stay clamped.
+- **New:** `FoliageAttachmentSet.dryness`, `tints` and `tint_scale`. The attachment arrays are now views trimmed to
+  the cards that remain.
+
+### Plagiotropic shoots: layered foliage tiers, no buds under a bough, straight branches
+
+- **New:** `BranchGeneratorConfig.plagiotropism` [0, 1], how dorsiventral a lateral shoot is. It has three effects:
+  - **Spine.** The shoot's spine is pulled towards the horizontal.
+  - **Bud plane.** Its children's buds are fanned into the plane of its tangent and the horizontal across it.
+  - **Ventral knockout.** No bud is emitted into the downward cone of half-angle `plagiotropism * pi / 2`. This covers
+    the raw bud, and also its heading after fanning and after any turn for clearance. A bud with no admissible heading
+    does not break. There is no separate knockout setting. Contact projection can still deflect a child's first
+    segment afterwards (at most 1% of children in the specs).
+  - **Presets.** Only species whose branches are plagiotropic in their architectural model set it. The source is
+    Hallé, Oldeman & Tomlinson's architectural models, as listed by Pfisterer (2000, *Mitt. Biol. Bundesanst.* 370) and Millet, Bouchard & Édelin (1999, *Écoscience* 6: 187–203).
+    - **Spruce** (*Picea*, Massart's model: tiers of plagiotropic branches) sets 0.7 on its laterals. Averaged over
+      seeds 1, 7 and 1337, its pads flatten (vertical over horizontal spread of a bough's cards, 0.42 → 0.25) and its
+      crown gets gaps between tiers (empty height bands, 0.27 → 0.41).
+    - **Pine, maple, oak and birch** (*Pinus*, *Acer*, *Quercus*, *Betula*) grow to Rauh's model: their branches are
+      orthotropic and built like the trunk, so they set none. Pine's tiers come from its annual whorls.
+  - **Replaces.** It replaces an undocumented emission rule that biased every lateral's buds upward and off its
+    underside, keyed on the child's gravitropism. Removing that rule put more twigs under the broadleaf boughs
+    (12 seeds):
+    - oak: twigs more than 30° below horizontal 1.4% → 3.8%, mean heading y 0.398 → 0.327;
+    - birch: 0.6% → 1.2%.
+    That bias had no botanical basis. Rauh-model branches are orthotropic and branch radially, and where a positional
+    bias is reported for them it is slight *hypotony*, laterals favoured on the lower side (Millet et al. 1999, for
+    aspen and white ash), never an upward one. Silver birch's twigs hang.
+- **New:** `BranchGeneratorConfig.straightness` [0, 1], a pull back towards the heading the branch was given.
+  - **Heading.** That is the bud's heading, or for the fork that continues a split, the heading the split gave it.
+  - **Measured:** with `gnarl_strength` 0.6 on oak's boughs, the mean start-to-tip heading change falls from 72° to
+    54° at 1.
+  - No preset sets it. The apical upturn stays `tip_upcurl`.
+
+### Foliage cards are cut to their leaves, and as many as the shoot needs
+
+- **New:** `FoliageAtlasCutout`, the shape of the synthesized foliage atlas. For each tile it holds a convex hull
+  that contains the centre of every texel the tile draws, and the tile's leaf coverage. `make_foliage_material(config,
+  seed, out_cutout)` fills it while it synthesizes the atlas (the textures are byte-identical to before), and
+  `foliage_atlas_cutout(config)` computes it from the alpha alone. `generate_tree` keeps it as
+  `TreeAsset.foliage_cutout`.
+- **Breaking:** `FoliageCardType.OctagonalCutoutHull` is now `CutoutHull`.
+  - **Before:** a fixed octagon, the same for every leaf.
+  - **Now:** each card draws its tile's fitted hull, folded about the midrib and arched along its length. This is
+    passed to `tree_mesh_build_foliage(skeleton, attachments, config, lod_config, cutout, out)`; `cutout` comes before
+    `out`, which is a breaking change. Without a cutout, the cards cover whole tiles.
+  - **How much is cut:** needle tiles to 0.34 of the tile, against 0.63 for the octagon; palmate tiles to 0.63, about
+    the same.
+- **Breaking:** `FoliageSpawnRule.count` and `terminal_count` are gone. A carrier's cards now follow from its leafy
+  length: enough leaf that a line of sight through the shoot's foliage sleeve meets one leaf on average.
+  - **Formula:** `pi sin(insertion_angle) (1 - stem_anchor_v) / (card_width * scale * coverage * planes)` cards per
+    metre.
+  - **Rounding:** fractional counts are rounded with a per-branch dither, so short shoots carry their share on
+    average, instead of a fixed count per carrier (5–13 in the presets).
+  - **Leafy span:** it starts at `attach_min`, honoured up to 0.92, for the cards and the wind sail alike.
+  - **Per preset at seed 1337,** 5b96446cc vs now (with all of Tier 1): oak 1013 → 842, pine 1584 → 694, spruce
+    1296 → 1191, maple 847 → 439, willow 682 → 1455, palm 84 → 237.
+  - **Wind:** the joint mechanics take the same leaf area as the foliage's sail (within 0–3.5% on every preset).
+- **Changed:** `TreeWindConfig.elastic_modulus` is refitted from 2.42e8 to 3.33e7.
+  - **Why:** the foliage sail is now the derived leaf area, not whole cards. Measured over 12 seeds, that alone cut
+    the oak's median bough hinge compliance to 0.138 of its tuned value.
+  - **Oak:** the refit restores it (ratio 0.9998). The same modulus also sets natural frequency, so the median bough
+    hinge frequency falls from 4.2 Hz to 2.1 Hz, and oak's trunk base from 2.4 Hz to 0.95 Hz.
+  - **The other presets:** one modulus cannot hold every preset's old sway, because the old sail differed from the
+    new one by a different factor in each. Median bough compliance, now over before: pine 0.18, spruce 0.33, fern
+    0.33, maple 0.39, birch 0.88, shrub 1.17, willow 2.93, palm 4.16. Trunk frequencies fell about 2.5x across the
+    presets.
+- **New:** `FoliageAttachmentSet.carriers`, the skeleton branch that carries each card.
+- **New:** `convex_hull_fixed_count_2d_relaxation(…, bounds)`. Given a `[x0, y0, x1, y1]` box, it never removes an
+  edge whose removal would put a vertex outside the box. When no edge can be removed, it returns the remaining count
+  and writes nothing.
+- **Breaking:** `compute_foliage_variant_atlas_layout` moved to `material/compute_foliage_variant_atlas_layout.js`.
+  `make_foliage_material.js` no longer exports it; the package index still does.
+
+### Dead stubs and knots grow from the tree's history
+
+- **New:** `BranchGeneratorConfig.self_pruning`, how readily a species sheds branches that die in the crown's shade.
+  A crown rule's bare stretch below its living children (its `attach_min`) is where it once grew children too, at
+  the same nodes: the same spacing and phyllotaxis continued down the stem, so a conifer's are whorls. Each such
+  branch died the smaller the earlier it died, and keeps `(1 - self_pruning) - age` of its length as a dead stub,
+  age running from 0 just below the living children to 1 at the stem's base. Once that no longer clears the bark it
+  has been grown over and leaves a scar. No preset authors a number of stubs: oak keeps one dead limb under its crown,
+  maple a dead pair, pine and spruce a few thin dead branches, birch and willow none, and a palm's dropped fronds ring
+  its trunk. A stub is shaped as the base of the branch it was (shape envelopes at its position along that whole
+  branch, per-step amounts from its segmentation), so it bends like a living branch's base instead of carrying a
+  whole branch's tip curl in its short length.
+- **New:** `TreeSkeleton.branch_dead` and branch scars (`scar_count`, `scar_branch`, `scar_data`, `add_scar`). A dead
+  branch grows nothing, carries no leaves, conducts no sap (no pipe-model area) and ends in a flat break. Bark knots
+  are now those scars: the collar the branch had (`parent_collar_bulge`) outliving it as a callus rim, sized by the
+  branch when it died.
+- **Breaking:** `BranchGeneratorConfig.knot_count`, `knot_strength` and `apex_height` are gone, with the authored
+  lower-stub generators.
+- **Changed:** children on a stem's flare crests are no thicker than `R sin(pi / N)`, so N of them fit side by side.
+  Palm and fern fronds no longer kink their stem (`parent_kink` 0).
+
+### Tree generation grows from a generator graph, not a fixed list of levels
+
+- **Breaking:** `TreeSpeciesConfig.levels` is gone. A tree is now `branches: BranchGeneratorConfig[]` (how a branch
+  is shaped; `branches[0]` is the trunk) joined by `branch_rules: BranchSpawnRule[]` (which generator spawns which,
+  where along the parent, how many, with what phyllotaxis and insertion angle). Each rule has `source < target`, so the
+  graph is acyclic. One generator can spawn several kinds of children, and several can spawn the same kind. The
+  order rules are listed in does not change the tree. Overriding `branches` clears both rule lists unless they are
+  given with it, since rules index generators.
+- **Breaking:** `BranchLevelConfig` is replaced by `BranchGeneratorConfig`. Its emission fields (`child_count`,
+  `bare_length_ratio`, `phyllotaxis_mode`, `whorl_count`, `azimuth_jitter`, `insertion_angle*`, `length_profile`)
+  moved to `BranchSpawnRule` (`count`, `attach_min`/`attach_max`, …).
+- **Breaking:** `FoliageConfig` keeps only the card geometry. Which generators carry leaves, and how densely, is
+  `TreeSpeciesConfig.foliage_rules: FoliageSpawnRule[]`. `enabled`, `attach_min_level`, `cards_per_branch`,
+  `terminal_rosette_count`, `bare_ratio`, `phyllotaxis_mode`, `whorl_count` and `insertion_angle` are gone; a bare
+  tree has no foliage rules. `foliage: false` now fails an assertion.
+- **Breaking:** `tree_skeleton_assign_skin_joints(skeleton, species)` takes the species and reads its
+  `wind.max_joints`. `TreeSkeleton.add_branch` takes the generator index after the level, and `TreeSkeleton` gains
+  `branch_generator`.
+- **New:** `BranchGeneratorConfig.root`: structural surface roots that descend onto the ground plane and creep along it,
+  add no pipe-model area to their stem, and never get a wind joint. `PhyllotaxisMode.FlareLobes` plants them on the
+  crests of the trunk's buttress lobes.
+- **New:** `BranchGeneratorConfig.excurrent` (the conifer leader habit, which was inferred from a whorled trunk),
+  `BranchSpawnRule.parent_kink` (replaces "whorls never kink the stem") and
+  `crown_envelope` (children below or outside the crown are not shrunk or pulled in by it).
+- **Changed:** Oak, Pine, Birch, Willow, Maple and Spruce have surface roots, one per flare lobe, that sink into the
+  ground about halfway out. Oak also has epicormic sprouts that
+  carry leaves; Pine and Spruce have inter-whorl branches that feed the same twigs as the whorl boughs. Every
+  preset's trees change for the same seed.
+
+### Tree wind joints get their stiffness from beam mechanics
+
+- **Fixed:** a joint's sway no longer depends on its branching level. Bare stubs, which carry no sail, swayed like
+  leafy boughs (2.7 times the stiffest bough's compliance on the oak). Bent as one cantilever, every stub now sways
+  less than every primary bough on all six woody presets, 3,300-17,700 times less at the median.
+- **New:** `tree_skeleton_compute_segment_mechanics` and `tree_skeleton_compute_joint_mechanics`. Each skeleton
+  segment is an Euler-Bernoulli beam element with the drag of its bark (C_d 1.2) and leaf cards (C_d 0.4) and the
+  mass of green wood and fresh leaves; a lateral loads the parent segment it hangs from below its attachment. A
+  joint's compliance is the drag moment integrated over the flexibility `dx / (E I)` of the span it rotates; its
+  natural frequency is the single-degree-of-freedom `sqrt(K / J)` of that span under its own weight. Surface roots
+  carry no load. Pinned against the analytic cantilever: `L^3 / r^3` scaling, and a joint at 0.375 L carrying
+  0.2441 of the tip slope under a uniform load.
+- **Changed:** wind joints go to what the wind moves. Primary-bough hinges and mid-bough joints compete for the
+  budget ranked by the bending they would govern, then secondary hinges likewise; a stub gets a joint only once
+  every primary bough has its own. The oak spends 23 joints on boughs and none on stubs.
+- **Changed:** `chunk_foliage_wind_step` drags with the dynamic pressure: deflection `0.5 * compliance * v^2`. It
+  was `compliance * |v| * (0.5 + 0.5 |v|)`, whose linear term has no physical basis (3x the deflection at 0.5 m/s).
+- **Breaking:** `TreeWindConfig.trunk_compliance`, `branch_compliance` and `natural_frequency` are gone, replaced by
+  one `elastic_modulus` (2.42e8 Pa effective), fitted so the oak's boughs keep their previous sway in a 6.5 m/s
+  wind. The oak's trunk base then rings near 1.0 Hz and its boughs near 2.1 Hz.
+- **Breaking:** `tree_skeleton_assign_skin_joints` returns `joint_compliance` and `joint_natural_frequency` in
+  place of `joint_t_norms`, `joint_radii` and `joint_lengths`. A joint whose span holds no segment is rigid
+  (compliance 0). `build_tree_wind_rig` returns `null` for a single joint: joint 0 is the anchored trunk base.
+
+### ACES, Unreal Engine's look, is the default tone mapping
+
+- **Added:** `ShadeToneMappingMode.ACES`, and **Breaking:** it is the renderer's default, where GT7 was. Every
+  default look changes. Set `renderer.tone_mapping_mode = ShadeToneMappingMode.GT7` to keep the previous one.
+  - SDR is Unreal's "Filmic" tone mapper at its default settings, with Expand Gamut
+    and Blue Correction around it, per pixel where UE bakes a LUT. An exposed 0.18 shows at 0.18 of SDR white, as
+    with GT7, at a mid-tone contrast of 1.36 against GT7's 1.05. Shadows are deeper, highlights brighter, and
+    saturation 12–15% higher on the volumetrics playground.
+  - HDR is what Unreal 5.8 does with Filmic past 100 cd/m². The SDR picture goes back through the inverse ACES 2.0
+    output transform for an SDR display, then out through ACES 2.0 for the display's headroom over the paper white.
+    Both are limited to Rec.709, the SDR picture's gamut, so as the headroom shrinks to none the HDR picture becomes
+    the SDR one. Mid-grey rises with the peak, as ACES 2.0 is designed to: 0.26 of SDR white at 1000 cd/m².
+  - The inverse is limited where OpenColorIO's is ill-conditioned. Its decompression is clamped at the estimated
+    gamut boundary, held to a gain of 5, and faded out over the last unit of J before white. Without these limits, a
+    bright tinted highlight, whose SDR picture Filmic clips onto the gamut's surface, jumps by up to a quarter of SDR
+    white between neighbouring scene values.
+- **New:** `TonemapAces2Tables`, the HDR pass's two ACES 2.0 output transforms. They are built on the first HDR frame
+  and rebuilt only when the display's peak changes (7–13 ms).
+- **New:** `aces2_transform_block_write`, OpenColorIO 2.6.0's ACES 2.0 parameter and gamut-table setup, and the WGSL
+  `aces2_forward` / `aces2_inverse` that read it. Outside the inverse's limits they match OCIO to 1e-4, encoded.
+- **New:** `PAPER_WHITE_NITS` is exported to JS from `chunk_PAPER_WHITE_NITS.js`, which writes it into WGSL.
+- **Cost:** the SDR pass takes 12–13 µs at 1258×646 on an RTX 4090, against GT7's 14–21. The HDR pass takes 55–102 µs,
+  against GT7's 16–33.
+- `ACES_TONE_MAPPING_BRIEF_2026_10_17.md`, beside the tone mapping chunks, has the sources, the decisions and the
+  measurements.
+
+### Environment maps carry an octahedral skirt, and are filtered in hardware
+
+- **Breaking:** an environment map (`scene.lights.environment`) must carry a one-texel octahedral skirt:
+  the octahedral square in the interior `size - 2` texels, each texel of the outer ring a copy of the
+  interior texel the octahedral fold puts beside it. A map without one, or one too small to keep an
+  interior at its last filtered level (under 48 texels), fails an assertion in `GPULightCollection` when it
+  is uploaded. A constant map already has its skirt. Octahedral `.hdr` files converted before this
+  change have none: re-convert them from their equirectangular sources.
+- **Breaking:** `resample_equirectangular_to_octahedral` and `resample_cube_to_octahedral` write the skirt,
+  and take a third argument `skirt` (default `true`); `output_resolution` is the side with the skirt.
+  `tools/environment/convert_equirectangular_to_octahedral.mjs` writes it too; `--no-skirt` writes the
+  square across the whole map.
+- **Breaking:** `sample_environment_map` and `sample_environment_color` take a sampler after the texture.
+  Every shader that reads the environment binds `sEnvironment` (`ENVIRONMENT_MAP_SAMPLER_RESOURCE`, in
+  `SHADING_LIGHT_RESOURCE_GROUP`), and `tEnvironment` is declared filterable (`"float"`).
+- **Faster:** `sample_environment_map` is two hardware bilinear taps, one per level, where it was eight
+  loads and eight octahedral wraps. Radiance plus irradiance over 1920×1080: 88 → 17 µs on an RTX 4090,
+  15.4 → 1.3 ms on a 2-CU RDNA2 iGPU. `sample_environment_color` and the prefilter's 196 taps a texel
+  are one tap each. The split-sum error against the SH-exponential playground's quadrature reference is
+  unchanged to four digits at every roughness.
+- **New:** `sampler2d_octahedral_skirt_fill`, `octahedral_skirt_matches`, `octahedral_skirt_source_texel`
+  (CPU), and the WGSL `texture_octahedral_skirt_uv` and `texture_octahedral_skirt_texel_uv`.
+- **Changed:** the prefilter (`shader_convolve_reflection_map`) and the sky irradiance map write their levels
+  with the skirt; the SH-exponential encoder's cell pass integrates the interior only.
+
+### The froxel media build keeps a volume in the rows at its top and bottom edges
+
+- **Fixed:** `shader_volumetrics_build_participating_media` turned its froxels' Y planes to face out, so its
+  box test kept a volume only in the rows of froxels the volume spanned from top to bottom. A volume lost up
+  to a row of fog at its top and bottom edges, and one less than a row tall (16 px) never drew at all. The
+  build now takes its planes from `volumetrics_froxel_planes`, as the bin does. The playground's picture
+  stays inside its noise floor at all 11 of its viewpoints, and on a 2-CU RDNA2 iGPU the build costs what
+  it did (new/old 0.998).
+
+### The froxel media build walks only the volumes its workgroup can see
+
+- **New:** `shader_volumetrics_bin_participating_media`. Before the participating-media build it tests every
+  volume against each build workgroup's slab of froxels, and the build walks only its group's list, in row
+  order. The media written is unchanged (bit for bit under the emulator). On a 2-CU RDNA2 iGPU at 1898×982 the
+  build plus the bin costs 4.85 ms against 7.78 with the playground's six volumes, and 6.10 against 207 ms
+  with 256 more volumes no froxel reaches.
+- **New:** `VOLUMETRICS_MEDIA_GROUP_VOLUME_BUDGET` (32), the most listed volumes a froxel walks. Past it the
+  group's highest-indexed volumes are dropped. The walk had no budget before.
+- **New:** `chunk_volumetrics_media_group_list` and `VOLUMETRICS_MEDIA_WORKGROUP_RESOLUTION`, which the
+  build's `@workgroup_size` now reads.
+- **New:** `shader_volumetrics_split_participating_media`, run before the bin. It splits the volumes between a
+  near field (any part nearer than `froxel_far`) and a far field (any part beyond), both when a volume is
+  across the plane, and drops what lies outside the grid's sides or behind its near plane. The bin
+  reads only the near field: on the iGPU it stays at 0.35 ms with 1,024 volumes the camera cannot see,
+  against 3.54 ms, for 0.01–0.02 ms of split. Both fields are `VOLUMETRICS_MEDIA_VOLUME_LIST`s.
+- **New:** the aerial pass's far field walks the far-field list instead of every volume. Its sums vary by rounding
+  from frame to frame, since the list is unordered. On the iGPU, with `froxel_far` at 40 m and 1,024 volumes
+  the camera cannot see, the aerial pass costs 5.9 ms against 56. At the default `froxel_far` it costs 1.13
+  against 10.7.
+
+### A wrapped shape answers about its own point, however deeply it is nested
+
+- **Fixed:** `TransformedShape3D` and `PosedShape3D` gave wrong distances, gradients, `contains_point`
+  answers and volume samples when a union between them held more wrappers. Every instance shared one
+  scratch point, so the union's first child wrote over the point its siblings had still to be asked
+  about. A wrapped union of two wrapped unit spheres answered 1.024 for a distance of 0.118. Each instance
+  now holds its own arrays. A flat `TransformedShape3D` distance costs what it did (34–36 ns against
+  38–40 ns, node, one wrapper class per process), `support` costs what it did, and
+  `compute_bounding_box` no longer copies the box it guarded.
+- **Fixed:** `UnionShape3D#signed_distance_gradient_at_point` answered about the wrong point when one of
+  its children's distances sampled a gradient of its own: the sampler's probe was shared too. It now
+  probes in its caller's `result`.
+- **Fixed:** `UnionShape3D#compute_bounding_box` rounded its children's boxes to float32 and allocated
+  an array per call. `raycast` on `TransformedShape3D`, `PosedShape3D` and `UnionShape3D` allocated a
+  ray per call. Each instance now keeps its own.
+- **Fixed:** `PosedShape3D` had no `signed_distance_gradient_at_point`, so a `TransformedShape3D`
+  wrapping one threw on every distance query. It answers the shape's gradient, turned into the world by
+  the pose.
+
+### The scene's wind reaches cloth, water, volumetrics and particles
+
+The GPU wind fluid's readers (S3, S5, S6): every consumer of wind now reads one scene wind, the GPU
+fluid where a domain exists and the far field of the global effectors elsewhere.
+
+- **New:** `GPUFluidSystem#request(min…, max…, nx, ny, nz, target, target_offset)` and `#status`, the
+  GPU wind read back to the CPU as a lattice of `(x, y, z, 0)` m/s: in order, at most 4 batches in
+  flight, drops reported, headless answered from the far field. On the RTX 4090 a lattice lands a
+  median 2 frames after it is asked for. `GPUFluidQueries`, `FLUID_QUERY_DATABASE_SPEC`,
+  `shader_fluid_query_gather`.
+- **New:** `ClothGPUFluidWind`. Cloth reads the scene's wind by default: `ClothGPUFluidWind` while the
+  scene has an enabled `GPUFluidComponent`, else `ClothFluidWind` while the far field is not still,
+  else no wind. An assigned `ClothSystem#wind`, `null` included, wins.
+- **Breaking:** `ClothAmbientWind` is removed. Its gust is `GlobalFluidEffector#gust`, on the scene
+  clock. Cloth's worker/inline parity holds for cloths registered on the same tick and under a wind
+  that does not change over time (cloth `MEASUREMENTS.md` §69).
+- **Breaking:** `ClothFluidWind` takes the `FluidEffectorsSystem` and loses `ambient`; outside the CPU
+  fields it answers the far field.
+- **Breaking:** `GlobalFluidEffector#apply` is removed; `FluidSimulator#step` refuses a global (dev
+  assert). Bring a field to the far field with `fluid_apply_atmosphere`.
+- **Breaking:** `WaterWaves.windSpeed` and `windDirection` are removed. A body's waves follow the
+  scene's wind 10 m above its origin, low-passed over 20 s on the GPU; weights re-derive only past a
+  5% / 3° deadband, and a turn starts only past 3°. `WaterWaves` binary v2; the v1→v2 upgrader drops
+  the wind. The wave row is re-laid (`shore_reflection` its own field, a GPU-written `wind` and
+  `wind_seeded`, `derived_for` a vec4). Water animates its bands only while an enabled
+  `GPUFluidComponent` exists or the far field is not still.
+- **Breaking:** `SceneVolumetrics.wind` is removed. Participating media scroll with the scene's far
+  field (`GPUFluidSystem#far_field` × `noise_wind_factor` + `noise_velocity`, folded on the host;
+  still air without a `GPUFluidSystem`). Where the scene's fluid departs from the far field, every
+  pass that evaluates the noise samples the published wind field there and carries the noise by the
+  departure as a flow map (period 2.5 s); nothing is read back. A scroll writes each moved row's seven
+  phase words (`SceneVolumetrics.noise_version`, `invalidate_noise()`) instead of repacking the
+  table: `GPUSceneVolumetrics.update` went from 41.5–46.5 µs and 72.3 KB a frame to 2.6–2.7 µs and
+  nothing per volume, at 64 volumes. `ParticipatingMediaSystem` allocates nothing per frame.
+- **New:** `ParticipatingMediaVolume.noise_wind_factor` and `noise_flow_phase`, in the row's padding
+  (still 240 B); `participating_media_noise_multiplier_in_wind`. Every reader of the volumes' noise
+  (the froxel build, both path tracers, Brick4, the lightmap viz bakes, the LPV trace) binds the scene's
+  wind field. The froxel build costs 15.4 → 19.4 µs with a disturbed domain, and in uniform air what it
+  did (RTX 4090, 1280×720, camera inside the fog): the flow map and the cascades' read are linked only
+  where the scene's wind field has cascades.
+- **New:** `WIND_FIELD_UNIFORM`, the shader switch for a wind field with no cascades, decided by
+  `chunk_wind_field_sample` (the far field) and `chunk_participating_media_noise` (the scroll alone). The
+  froxel build sets it from `scene.wind.cascade_count`; a pass that does not reads the field as before.
+  Linked for it, the froxel build in uniform air reads the old shader's time to within 0.1 µs, 1.3–1.5 µs
+  under the variant for the field as it is.
+- **Fixed:** `ShaderSwitchSet#with` allocated 595 B a call that changed a value, though the set it
+  returned already existed; asked again, it allocates nothing.
+- **Fixed:** the volumetrics noise scrolled upwind; it is carried downwind.
+- **New:** `SAMPLE_WIND` (opcode 62), the particle VM's read of the scene's wind at a world position in
+  m/s, and the node library's `wind` node. Every particle VM pass binds the scene's wind field (one
+  uniform, one 3-D texture, a sampler, no storage buffer); `execute_particle_vm` takes `sample_wind`;
+  `ParticleReferenceSimulation.wind`.
+- **Fixed:** a wide-register particle frame that registered a pre-warmed emitter failed frame-graph
+  validation.
+- **Fixed:** `GPUTypedTable#set_record` allocated 278.8 B a call and `#set_fields` built ~216 B of
+  assert messages a call in dev builds; the run search's assert message 132 B a run. All now 0.
+- **New:** `GPUTypedTable#add_run_filled`.
+- Playgrounds: the bonfire burns in a gust (`?wind=0&gust=0` for the old still night); the
+  water-surface playground's four per-body winds are one far field with a gust and a domain on the
+  current body.
+
+### The GPU fluid on entities: effectors, obstacles and forcing
+
+S4 of the GPU wind fluid: a scene gets the GPU wind by giving an entity a `GPUFluidComponent`; its
+effectors and obstacles reach the cascades through GPU rows, a per-frame LBVH and brick queries.
+
+- **New:** `GPUFluidComponent` (+ v0 adapter) and `GPUFluidSystem(graphics, scene)`: steps the domain
+  at the fixed step (at most 2 ticks a frame, the excess counted), keeps fluid rows from
+  `FluidEffectorsComponent`s and `FluidObstacle` tuples, publishes `GPUSceneContext#wind`, and offers
+  `far_field(out)`. The lowest enabled entity id is the domain. `EngineHarness.buildTerrain`
+  registers it with water. `GPUFluidComponent.vorticity_confinement` drives a curl pass and its
+  confinement term.
+- **New:** `GPUFluidForcing` (`shade/renderer/fluid/forcing/`): the fluid database
+  (`FLUID_DATABASE_SPEC`), a per-frame LBVH per resolution a stepping cascade needs (one dispatch at
+  ≤ 1,024 leaves; above, rebuilt on a membership change or every 16th frame, refit otherwise), per-tick
+  cooperative brick queries, and the forcing each cascade step reads: solids, pinned faces at the wall's
+  velocity, effector deposits. `graph_bvh_refit_lbvh`, `shader_bvh_refit_prepare`.
+- **New:** `ImpulseFluidEffector#spread` (a cone half-angle: 0 the old push, π an omnidirectional
+  burst) and `VortexFluidEffector`, with adapters.
+- **New:** the effector and obstacle records: `FLUID_EFFECTOR_RECORD_STRUCT` (48 B),
+  `FluidEffectorRecordKind`, `AbstractFluidEffector#write_gpu_record` / `has_gpu_record`,
+  `fluid_record_apply`, `fluid_effector_record_deposit` / `_resolve` and their chunks;
+  `FLUID_OBSTACLE_RECORD_STRUCT` (80 B), `fluid_obstacle_write_gpu_shape` / `_motion`,
+  `fluid_obstacle_record_signed_distance` / `_wall_velocity` / `_extent`,
+  `chunk_fluid_obstacle_record`; `shape_record_pack_bounding_box`,
+  `chunk_shape_record_signed_distance`, `chunk_shape_record_local_bounds`, `chunk_shape_record_kind`.
+- **Breaking:** `ImpulseFluidEffector#apply` and `WakeFluidEffector#apply` deposit through their GPU
+  records, so the CPU and GPU fluids deposit the same momentum. The kernel floor is two cells and
+  keeps momentum: a sub-cell push carried 13–77× the continuum's momentum before, 0.98–1.08 now. A wake
+  carries `|v|·v·strength·πR²·dt`; its peak on the segment is `v·strength·L/(L/6 + 2R/15)`, not
+  `v·strength`. `dt ≤ 0` deposits nothing.
+- **Changed:** `WakeFluidEffector#advance(dt)` measures the tick's velocity.
+- **Changed:** `v3_clamp_to_cone` allocates nothing (it boxed 85 B a call), and its slerp takes the
+  angle by atan2; `v3_clamp_to_cone_array`.
+- **Changed:** `SoftwareGPUDevice`'s indirect dispatch records carry `indirect_buffer` and
+  `indirect_offset`.
+- On the RTX 4090, at the defaults (four cascades of 64×32×64), a scene of a gusting global, impulses, a
+  vortex, a wake and a moving box costs the fluid 220 µs on a tick without a coarse step and 396 µs with
+  one.
+
+### The GPU fluid's cascades, and the wind every GPU consumer reads
+
+S2 of the GPU wind fluid: a stack of nested, scrolling, two-way coupled cascades, and the published
+wind field they write. On the RTX 4090 a tick at the defaults (four cascades of 64×32×64) costs
+144 µs, or 292 µs on a tick that also steps a coarse cascade.
+
+- **New:** `GPUFluidCascadeStack` (`shade/renderer/fluid/`): 1–8 nested cascades around an anchor,
+  each twice its child's cell size. Placement goes through `ClipmapWindowSet`, a child stays the
+  published band inside its parent, and a jump re-places the whole stack; a placement's exposed
+  region is filled from the parent in one dispatch. Two-way coupling: each step reads its parent
+  through a per-step ghost shell, relaxes toward it in a WRF band, and is restricted back into it by
+  face means, divergence-free. Ruler sub-cycling steps cascade 0 every tick and at most one other.
+  Every step meets the far field through the atmosphere identity, under a deviation clamp.
+  `record_publish` writes the stack into the scene's wind field.
+- **New:** `FluidCascadePlacement`, `fluid_cascade_ruler`, `fluid_cascade_window_place`;
+  `ClipmapWindowSet#clamp_corner`.
+- **New:** `GPUSceneWind` (`shade/renderer/wind/`), on every `GPUSceneContext` as `context.wind`: an
+  `rgba16float` `GPUTileAtlas3D` with a tile per cascade and the uniform table `WIND_FIELD_STRUCT`.
+  Producer API `set_cascades`, `set_cascade_window`, `set_cascade_decay`, `set_far_velocity`,
+  `update`. With no producer it is still air.
+- **New:** `chunk_wind_field_sample` and `wind_field_add_resources`: `wind_field_sample(p)`, in m/s,
+  for any GPU consumer: the finest cascade through the atmosphere identity, blended live across a
+  5-cell edge band toward its parent or the far field, and the far field outside every cascade. One
+  uniform, one 3-D texture and a sampler; no storage buffer.
+- **New:** `FluidWindPublish`, `shader_fluid_wind_publish`, `chunk_fluid_wind_publish_cell`: a
+  cascade's cell-centred deviation from its step's far field into its tile. A tile stores the
+  deviation, so uniform air reads back exactly through the 4090's truncating f16 store.
+- **Changed:** `GPUFluidCascade` takes `FluidAtmosphere` records instead of a far velocity, and a
+  parent; `FluidMacPasses` gains `record_ghosts`, and `GPUFluidPressureSolve` takes the ghost
+  pressure.
+
+### The GPU fluid's solver core: one cascade window
+
+The first stage of the GPU wind fluid (`engine/physics/fluid/GPU_FLUID_CASCADES_PROPOSAL_2026_10_16.md`,
+S1): one cascade window stepped on the GPU, every kernel a WGSL twin of the CPU fluid's kernels or of
+a CPU model, and held to them. On the RTX 4090 a step costs 115 µs at 64×32×64 and 245 µs at
+128×32×128.
+
+- **New:** `GPUFluidCascade` (`shade/renderer/fluid/`), one cascade window and the step that advances
+  it, recorded into a FrameGraph as one pass: MacCormack advection, divergence, the pressure solve and
+  the gradient. The velocity starts at the far field; outside the window, velocity is the far field and
+  pressure is 0.
+- **New:** `GPUFluidPressureSolve` (`shade/renderer/fluid/pressure/`), a window's pressure solve:
+  geometric-multigrid V-cycles with the finite-volume edge weight and a colour-masked LDS block
+  smoother at ω = 1, 3L − 2 dispatches a V-cycle (10 at 64×32×64) plus L weight dispatches a solve, or
+  red-black SOR one colour a dispatch. `record_v_cycles` / `record_sor` record it as its own pass,
+  `encode_v_cycles` / `encode_sor` into a caller's. Non-finite pressure and RHS are read as 0 and
+  counted. V-cycles reach the same residual ~3× faster than SOR; two a step is the default.
+- **New:** `FluidMacPasses` and `FluidMacVelocitySet` (`shade/renderer/fluid/mac/`): the MAC passes of
+  a step (`shader_fluid_mac_advect_predict`, `_advect_correct`, `_divergence`, `_gradient`, with
+  `FLUID_MAC_STEP_STRUCT`) on `r32float` face textures.
+- **New:** `chunk_v3_mac_*`, the MAC grid's per-face and per-cell maths in WGSL (pin rule, divergence,
+  gradient subtraction, clipped trace, 4-tap carriers, manual f32 trilinear taps through seams,
+  Selle's limiter, MacCormack predict and correct), twins of the CPU's `v3_mac_*` kernels.
+- **New:** the V-cycle's per-cell WGSL: `chunk_fluid_mg_word`, `chunk_fluid_mg_level0_word`,
+  `chunk_fluid_mg_coarse_word`, `chunk_fluid_mg_relax`, `chunk_fluid_mg_restrict`,
+  `chunk_fluid_mg_prolong`, and the Dirichlet seam `chunk_fluid_pressure_ghost`.
+- **New:** `chunk_subgroup_atomic_add`, a lane's count added with one atomic per subgroup.
+
+### The CPU fluid meets one far field
+
+Every global effector used to act on every field on its own, in whatever order the fields gathered
+them. They are now folded into one far field once a tick, which the CPU fluid meets through one exact
+step, and which the GPU fluid will read too.
+
+- **New:** `GlobalFluidEffector` gains `gust`, `gust_period`, the state `gust_phase`
+  (Float64Array(3), turns), and `compute_gust(out)`; `advance(dt)` advances the phases. It is
+  `ClothAmbientWind`'s gust term for term, and editing the period never jumps.
+- **New:** `FluidEffectorsSystem` folds every global into one far field once a tick;
+  `read_atmosphere(out, offset)` returns a `FluidAtmosphere` record without allocating.
+- **New:** `fluid_atmosphere_to_grid`, `fluid_apply_atmosphere`, `FluidAtmosphere`,
+  `FluidFieldAtmosphere`; `FluidField#atmosphere` holds the field's last instant, `clear()` resets it
+  and `equals()` compares it.
+- **Breaking:** `FluidSystem` and `WorkerFluidSystem` no longer apply each `GlobalFluidEffector` on its
+  own. They bring every field to the folded far field through the atmosphere identity, so globals act
+  as one whatever their order, and the gust is carried without drag filtering. Only the first fold
+  seeds the far field at the globals' wind; a global added later brings the air up to its wind at its
+  drag, and when the last global goes the far field holds. Calm is authored as a global with wind 0
+  and a drag; a scene that never had a global is still air.
+- **Breaking:** the worker protocol's `FluidCommand.FIELD_IDS` is replaced by `FluidCommand.FIELDS`,
+  per-field records of `FLUID_COMMAND_FIELD_WORDS` (id plus atmosphere) in a `FluidCommandField`
+  layout.
+- **Changed:** `GlobalFluidEffector#apply` is only the direct `FluidSimulator#step` path, and it has
+  no gust.
+- **Fixed:** saving a scene with fluid effectors threw. `FluidEffectorsComponent` and the Global,
+  Impulse and Wake effectors have a `typeName` and v0 serialization adapters, and a load resumes the
+  gust where it was.
+
+### Fluid effectors live once a tick, in their own system
+
+A wake advances its trail when it is synced to its entity, and every fluid system synced effectors
+itself, so a scene with two fluid systems advanced every wake twice a tick and the second applied
+no wake at all.
+
+- **Breaking:** `FluidSystem` and `WorkerFluidSystem` require a `FluidEffectorsSystem`; register it
+  with them (first, if the `EntityManager` is already running). Without one, startup fails in a
+  development build.
+- **New:** `FluidEffectorsSystem` syncs every effector on an entity with a `Transform64` and calls
+  `advance(dt)` on every effector, exactly once per fixed step and before any fluid system applies
+  them, whatever order the systems were registered in.
+- **New:** `AbstractFluidEffector#advance(dt)`, a per-tick hook for state an effector evolves on its
+  own; a no-op by default.
+
+### One clipmap module for the shadow map, the fluid and the cascades to come
+
+- **New:** `core/geom/clipmap/`: `quantize_hysteretic`, `ClipmapWindowSet` (integer corners per
+  level; `place`, `contains`, `storage_cell`, `decode`; no allocation per call), `window_scroll_regions`
+  (what a scroll exposes, as disjoint boxes) and `clipmap_select_finest`.
+- **New:** WGSL chunks `chunk_clipmap_storage_coord`, `chunk_clipmap_contains` and
+  `chunk_clipmap_select_finest` (the finest level holding a point, with an edge-band weight), and
+  `CLIPMAP_LEVEL_STRUCT` / `CLIPMAP_LEVEL_ARRAY`.
+- **Changed:** `VSMPageManager` keeps its windows in a `ClipmapWindowSet` and evicts through
+  `window_scroll_regions`; `VirtualShadowMap`'s depth range and `fluid_reanchor_field` snap through
+  `quantize_hysteretic`. Window placement, eviction order, the depth range and the fluid anchor are
+  unchanged to the bit.
+- **Breaking:** `shader_debug_clipmap` draws any clipmap of cascades from a `CLIPMAP_DEBUG_STRUCT`
+  uniform named `clipmap` (a colour per level, the edge band, cell lines). It no longer reads
+  `clipmap_info` or `gBufferOcclusion`.
+- **Removed:** `GPUClipMap3D`, `shader_update_clipmap_cascade`, `chunk_clip_cascade_coord_encode` /
+  `chunk_clip_cascade_decode` (`chunk_clip_cascade_wrap_coord.js`) and `GPURadianceField`
+  (`RadianceField.js`). Use the clipmap module.
+
+### The 3-D tile atlas has a tile length per axis, and the shaders share its placement
+
+- **Breaking:** `GPUTileAtlas3D`'s `content_size` is `[x, y, z]` (a cube is `[n, n, n]`); its
+  `content_size` and `tile_size` getters return frozen `[x, y, z]` arrays.
+  `tile_atlas_bordered_block` takes `content_size` as `[x, y, z]`, and
+  `tile_atlas_widened_footprint(slots_x, slots_y, tile_size_x, tile_size_y, max_dimension, out)`
+  replaces `(slots_x, slots_y, axis_limit, out)`.
+- **Changed:** a full atlas widens the side narrower in texels (x on a tie, each side capped at its
+  own limit); with cubic tiles this is the old rule.
+- **Removed:** `chunk_sdf_slot_index_to_texture_offset`; use
+  `chunk_tile_atlas_slot_origin(slot, slots.xy, tile_size)`.
+- **New:** `chunk_tile_atlas_slot_origin`, `GPUTileAtlas3D.slot_origin` on the device; the
+  volumetrics noise tap, the geometry SDF build and its three readers use it.
+- **New:** `chunk_texture3d_trilinear_corners` (with `_load`, `_corner_aligned`, `_cell_centred`,
+  `chunk_texture3d_trilinear_interpolate` and `TEXTURE3D_TRILINEAR_CORNERS_STRUCT`): a manual
+  trilinear tap with exact f32 weights whose eight corners also feed a limiter. The geometry SDF tap
+  is now its corner-aligned form.
+- **New:** `chunk_texel_coordinate_to_uv3` and `chunk_uv3_to_texel_coordinate`, cell-centred.
+
+### Shared SDF and effector kernels, in JS and WGSL
+
+- **New:** `chunk_sdf3_box`, `chunk_sdf3_sphere`, `chunk_sdf3_capsule` and `chunk_sdf3_cylinder`, the
+  WGSL twins of `sdf3_box`, `sdf3_sphere`, `sdf3_capsule` and `sdf3_cylinder`, with the same frames
+  and parameters. `aabb3_signed_distance_to_point` now calls `sdf3_box`.
+- **New:** `falloff_quadratic`, `v3_clamp_to_cone`, `rigid_velocity_at_point` and
+  `vortex_swirl(out, out_offset, x, position, axis, segment_length, radius, strength)` (a
+  `segment_length` of 0 is a point vortex about the axis line), each with a WGSL chunk of the same
+  name. The cone clamp's twins compose the same slerp and agree at the antipode and next to the axis.
+- **New:** `chunk_v3_slerp` and `chunk_v3_angle_stable`, the twins of `v3_slerp` and
+  `v3_angle_stable`, branch for branch. The general branch takes its angle by atan2, which holds f32
+  parity next to the antipode where acos does not.
+- **New:** `chunk_point_closest_on_line`, the closest point on a segment; `point_distance_to_line`
+  now measures to it.
+- **Fixed:** `point_distance_to_line` returned NaN for a segment of no length; it now returns the
+  distance to that point.
+- To reach WGSL's `point_distance_above_plane`, an `sdf3_plane` is packed as `vec4(n, −offset)`.
+
+### A physics shape as a core record
+
+The kind-and-four-parameters record cloth kept for its colliders is now core's, so the GPU fluid's
+obstacles can pack the same shapes.
+
+- **New:** `core/geom/3d/shape/record/`: `ShapeRecordKind` (cloth's five analytic kinds, then
+  `ConvexHull`), the record layout, `shape_record_count` and `shape_record_pack(record, offset, pose,
+  pose_offset, planes, plane_index, shape, element)`. A shape is a run of records: a rigid
+  `TransformedShape3D` packs its subject with each pose composed, a `UnionShape3D` its children
+  depth first, and a hull of up to 16 planes its planes into a caller's plane array. A mesh, a
+  heightmap, a wrapper that scales, shears or mirrors, and any union holding one, pack nothing.
+- **New:** `shape_record_local_bounds` and `shape_record_signed_distance(record, offset, planes, x,
+  y, z)` / `_gradient_array`, the CPU field of a record (a hull: exact inside, conservative outside).
+- **New:** `m4_decompose_rigid_array`, the narrowphase's rigid-matrix test, moved to core;
+  `rigid_subject_pose` calls it.
+- **Changed:** cloth's collider record composes the core record. Its slots, its accepted kinds and
+  its results are unchanged to the bit.
+
+### Shared GPU chunks: an append, a box overlap, a cooperative BVH query, halo tiles
+
+- **New:** `subgroup_append_slot(count, want, capacity)` (`chunk_subgroup_append_slot`): claims a
+  lane's slot in an append-only list with one atomic per subgroup. Past the capacity the count keeps
+  rising and the lane gets `SUBGROUP_APPEND_NONE` (0xFFFFFFFF).
+- **New:** `collection_u32_append(&list, want, value, capacity)` (`chunk_collection_u32_append`) for
+  a `COLLECTION_U32_STRUCT_WRITE` list.
+- **Changed:** the virtual shadow map's mover list appends through it; what it lists is unchanged.
+- **New:** `chunk_aabb3_intersects_aabb3`, closed like the CPU `aabb3_intersects_aabb3`: boxes that
+  share a face, an edge or a corner intersect.
+- **New:** `chunk_bvh_query_aabb_cooperative`: every leaf of a BVH whose box overlaps one query box,
+  found by a 64-invocation workgroup a level at a time and returned as payloads in ascending order.
+  At most 256 frontier nodes, 51 levels and 128 candidates; what does not fit is counted. The
+  candidates are ordered with `chunk_sort_bitonic_comparator`. The shader defines
+  `bvh_query_aabb_node` and `bvh_query_aabb_accept_leaf`.
+- **New:** `chunk_grid_tile_halo_f32` and `chunk_grid_tile_halo_vec4`: an 8×8×4 tile of a toroidally
+  stored 3-D grid and its one-cell halo, loaded into workgroup memory by 256 invocations, any number
+  of tiles per kernel. The shader defines the fetches inside and outside the window.
+- **New:** `graph_draw_texture_3d_slice_as_rgba({graph, source, resolution, axis, slice, mip_level,
+  scale, bias, output_format})` draws one slice of a 3-D texture as texel × scale + bias per channel,
+  so signed fields such as velocity can be viewed.
+
+### Readback runs, interleaved sampling, a singleton without allocation, and a teleport without motion
+
+- **New:** `GPUDatabaseReadback.request_run(table, first_row, row_count, byte_offset, byte_size,
+  target, target_offset)` reads the same byte range of consecutive rows under one handle and one
+  status, all or nothing; a run of whole records is one copy per page rather than one per row.
+  `request` is a run of one.
+- **New:** `scs3d_sample_linear3_strided(out, data, stride, channel_offset, res_x, res_y, res_z,
+  position, position_offset)` samples three interleaved channels where a readback landed them, with
+  the planar form's corners, weights and clamping.
+- **New:** `EntityComponentDataset#getAnyComponentInstance(type)`: the instance held by the lowest
+  entity id, or null, without allocating (0 B and 14–36 ns against `getAnyComponent`'s 24–41 B and
+  99–124 ns, 10,000 entities). `getAnyComponent` answers from the same record.
+- **Fixed:** a `Transform64` placed with `TRANSFORM64_EVENT_PLACED` reported its whole teleport as
+  one frame's motion on the GPU, to TAA and to anything reading `global − prev_global`.
+  `GPUSceneRows` now seeds the placed row's `prev_global` to its new pose.
+
+### Tone mapping
+
+- **Added:** `ShadeToneMappingMode.PBR_NEUTRAL`, Khronos PBR Neutral on every output. SDR runs the specification:
+  base colours under 0.8 come out as they are, less a 0.04 offset, and hues never shift. HDR puts the display's
+  peak, over the paper white, where the specification has 1, so below the compression start an HDR display shows
+  what an SDR display shows. GT7 stays the default.
+- **Breaking:** the WGSL `tonemap_khronos_pbr(color)` is `tonemap_khronos_pbr(color, peak)`. A peak of 1 is the
+  specification, as before.
+- **Breaking:** the unwired ACES and AgX chunks are gone. Neither has a form that serves an SDR and an HDR display with
+  the same mid-tones (`HDR_TONE_MAPPING_FORMS_BRIEF_2026_10_16.md`). Removed from `shade/renderer/shader/chunk/color/`:
+  `tonemap/chunk_tonemap_aces.js`, `sRGB/chunk_RRTAndODTFit.js` (its fit), `tonemap/chunk_tonemap_agx.js`, and
+  `tonemap/chunk_tonemap_pbr_neutral.js`, a duplicate of `chunk_tonemap_khronos_pbr` that mixed toward 1 instead of
+  the compressed peak. The CPU `core/color/tonemap/tonemap_aces.js` stays.
+- **Breaking:** the paper white is a convention of every tone mapping mode, not of GT7:
+  `shade/renderer/shader/chunk/color/tonemap/gt7/chunk_GT7_PAPER_WHITE_NITS.js` is now
+  `shade/renderer/shader/chunk/color/tonemap/chunk_PAPER_WHITE_NITS.js`, and its WGSL constant `GT7_PAPER_WHITE_NITS`
+  is `PAPER_WHITE_NITS`. The value is unchanged, 250 cd/m².
+
+### A skinned mesh's normals turn with it, however alike they were bound
+
+`MeshletBatch#compress` collapsed any attribute all of a meshlet's vertices shared, normals and
+tangents included, and the skinning pass leaves a collapsed slot alone. A flat cloth sheet, every bind
+normal up, was lit in its bind pose whatever shape it took: a corner folded over on top came out dark,
+and the drape was shaded only by its shadows.
+
+- **Fixed:** a meshlet that carries skin weights keeps a normal and a tangent per vertex. A skinned
+  `MeshletGeometry` serialized before this keeps its collapsed slots until it is built again.
+
+### What travels is what goes through the action executor
+
+The host compared every replicated component of every networked entity at the end of each step, to
+find what its simulation had written directly: 7–8 ms a tick for 20,000 entities with nothing
+changing, a cost in the size of the world, where the stack is for worlds of millions of objects. It
+is gone, and the session now finds no change by itself.
+
+- **Breaking:** a replicated component the host writes directly (physics, a controller) reaches the
+  clients only if its writer reports it: `dataset.sendEvent(entity, "net_mutate_component",
+  { component_type })`, once per write. A write nobody reports stays on the host.
+- **Breaking:** the `publish_changes` option is gone.
+- **Changed:** on the host, `net_mutate_component` without `new_state` records the component as it
+  stands instead of executing it: the host's state is no longer overwritten with the wire's quantised
+  image (a `Transform64` rotation lost precision every tick it was reported).
+- **Changed:** a host's per-peer AUTH_STATE and a client's record of what it predicted walk the
+  entities each peer owns, not every networked entity. Host, 20,000 entities, nothing changing:
+  14–15 ms a tick → 0.01–0.02 ms. Ownership is set when a `NetworkIdentity` attaches, or by the join;
+  `owner_peer_id` and `network_id` are not written afterwards.
+- The assumptions and the measured costs: `engine/network/README.md`, "What the session assumes".
+
+### A network message can be any size, and a world of any size can be joined
+
+A client could not join a large world: messages past 64 KiB were dropped silently, so 2,990
+one-component entities could never be joined, and a join past ~302 KB threw every tick. One connection
+layer now carries every message, engine or user, up to `max_message_bytes` (1 MiB): numbered packets
+acknowledged by ranges, loss detection and probes after QUIC, paced reliable lanes. A tick's traffic to a
+peer leaves in as few datagrams as fit — 16 owned entities went from 17 datagrams a tick to 1. Design:
+`engine/network/MESSAGE_TRANSPORT.md`.
+
+- **Breaking:** the wire protocol is new and versioned; a peer on an earlier build cannot connect.
+- **Breaking:** `Channel`, `ReliableCommandPipeline` and `transport/fragments/*` are gone, replaced
+  by `transport/connection/Connection`. `NetworkPeer.channel_for` is `connection_for`.
+- **Breaking:** `NetworkPeer` takes a required `clock` (ms) and `tick_period_ms`, and the connection
+  options `send_rate_bytes_per_second`, `max_message_bytes`, `receive_window_bytes` and
+  `max_queued_bytes`. Its `send_*` methods queue; `send_queued()` and `flush_peer(id)` send, and
+  `end_tick` calls `send_queued()` last. `NetworkSession` wires all of this.
+- **Breaking:** `send_reliable_command` carries up to `max_message_bytes` (was 1,178 B), paced.
+- **Changed:** `Transport.max_datagram_bytes` (1,200; WebRTC 1,150; WebTransport its own).
+  `LoopbackTransport` is no longer `reliable`: `drop_next` loses packets.
+- **New:** a join is paged, paced, and catches up with what changed while it went out;
+  `NetworkSession.onSynced` fires once the client's world is whole. 20,000 entities join, including
+  while the world grows by 1,000 a tick.
+- **New:** `NetworkPeer.onFrameTooLarge`: an action-stream frame larger than any message is given up
+  and said so, instead of throwing every tick.
+- **New:** a connection that stops being whole (`onProtocolError`) is handled as a dropped transport:
+  the host puts the peer in grace, the client resumes on a new connection. One stray datagram used to
+  wedge a connection for good.
+- **Fixed:** `NodeUDPTransport` drops datagrams from anyone but its remote.
+
+### shade: a below-floor failure names everything the hardware lacks
+
+Hardware below the device floor was told only that it was "below the minimum this game requires": the
+check stopped at the first gap, and what it found went into `detail`, which nothing showed. An `Engine`
+application showed less still — a "Graphics device lost" overlay advising a reload, for hardware a
+reload cannot help.
+
+- **New:** `SHADE_DEVICE_FLOOR` (`shade/device`) — the required features and limits, one definition
+  that both the check and the device request read. `shade_device_floor_unmet(adapter)` lists every
+  feature and limit an adapter falls short of, with the value it offers, as phrases a person can read.
+- **Changed:** `ShadeDeviceFailure.below_floor(unmet)` takes that list (was one `detail` string). Its
+  `message` names every gap — "This graphics hardware does not meet this application's minimum
+  requirements: feature 'float32-blendable' is not supported; limit maxStorageBuffersPerShaderStage
+  is 8, at least 10 is required." — and `detail` is the list alone.
+- **Changed:** no failure message calls the application a game; the engine also runs CAD tools and
+  product visualizers.
+- **Fixed:** `Renderer.initialize()` rejects with a `ShadeDeviceFailure` in the two cases that escaped
+  it: a browser without WebGPU (was a plain `Error`), and a refused device request
+  (`device_request_failed`, whose message now carries what the browser said).
+- **Fixed:** `Engine` shows a failed start as "Graphics unavailable" with the failure's own message.
+
+### A positioned sound is placed when it or the listener moves, not every frame
+
+A playing 3D instance wrote its distance gain and its panner position to Web Audio every frame, moved or
+not; a crowd of one-shots standing where they were played made that most of the audio system's frame.
+
+- **Breaking:** an `EventInstance` reads its `position` when it starts, after `moved()`, and when the
+  listener moves — no longer every frame. The array is still held by reference, so whoever writes it
+  calls `instance.moved()`; a write nobody reports is not heard. Give each instance an array of its own:
+  instances sharing one are all wherever it was last written.
+- **Breaking:** `SopraEngine.setListener(position)` is the listener's move report. Every 3D instance
+  re-attenuates on the next `update` after a call, and none does between calls, so after writing into
+  the same array, call it again. A caller that already sets it every frame sees no difference.
+- **New:** `EventInstance.moved()`, and `SopraEngine.listenerVersion`, which `setListener` advances.
+- **Changed:** `EventInstance.update(now)` reads the engine's listener itself, with the version that
+  goes with it; the `listenerPosition` argument is gone.
+- **Changed:** `AudioEmitterSystem`, `LiveEmitterSet` and `AudioEventTriggerSystem` report moves from
+  `TRANSFORM64_EVENT_CHANGE`, the listener's included, as the live set already refit its broadphase. A
+  transform written without `t64_announce_change` moves no sound, as it moves no rendered row.
+- **Fixed:** `TopDownCameraControllerSystem` announces the transform it writes, when the pose changed.
+  Without it a `SoundListener` on that camera never moved, so every panned sound was directed from where
+  the camera stood when it linked.
+- **Fixed:** `PathFollowingSystem` announces the moves it writes. Without it, nothing that follows a
+  transform by its announcement saw a path follower move — its sound included, from this change on.
+
+### The transient pool keeps what it is ordered by on its records
+
+- **Changed:** a `TransientResourcePool` record carries `size`, read once as its resource enters the
+  pool, and a subclass caches whatever else its `compare` and `find` read in the new
+  `describeRecord(record)` hook. `GPUBufferAllocator` caches `usage`.
+- **Breaking:** `buffer_find` and `buffer_compare` read a record's `size` and `usage`, not its
+  resource's; a pool of your own built on them caches both, as `GPUBufferAllocator.describeRecord` does.
+- **New:** `array_remove_at` and `array_insert_at` (`core/collection/array`): `splice` by one element in
+  place, without the array `splice` returns. The pool edits its free list with them.
+
+### A look rotation allocates nothing
+
+- **New:** `quat3_look_rotation(out, out_offset, fx, fy, fz, ux, uy, uz)` (`core/geom/3d/quaternion`),
+  worked in locals. `Quaternion._lookRotation` and `t64_look_rotation` answer through it, with the same
+  results but the sign of a zero lane; `t64_look_rotation` no longer allocates. Its inputs must be finite
+  where assertions are kept.
+
+### sopra: events carry their own effects, and effect parameters move live
+
+A cue could not be filtered per play: effects existed only on buses, and a bus effect's parameters
+could not be moved once built — the nodes were private, and the only way in was to know that a
+one-effect bus's input happens to be its effect. Nor could an effect follow a sopra parameter the way a
+bus volume can, or hold a value on an emitter whose voice is rebuilt each time it is promoted. And adding
+a bus to the tree reset every fader the player had moved.
+
+- **New:** `EventDescription.effects` — insert effects of the event's own, the same types a bus takes.
+  Every instance builds its own copy, pre-fader (`voices → effects → instance gain → 3D chain → bus`),
+  so one play can be filtered, compressed or shaped apart from every other. Serialized (JSON and
+  binary), and part of `equals`/`hash`/`clone`.
+- **New:** `EventInstance.setEffectParam(index, name, value)` / `approachEffectParam(index, name,
+  value, timeConstant)` / `getEffectParam` — move one instance's copy, from the moment it exists (while
+  its buffers load included).
+- **New:** `SopraEngine.setBusEffectParam` / `approachBusEffectParam` / `getBusEffectParam`, over
+  `BusGraph.setEffectParam` / `approachEffectParam` / `getEffectParam` — the same two verbs as the
+  fader's `setVolume` / `approachVolume`. `set` moves it now; `approach` glides there exponentially
+  (`setTargetAtTime`). Either way in-flight automation is cancelled and held first, so a value sent every
+  frame glides on from where the last one had got to. The getters return where the parameter was sent,
+  not where a glide is. An effect is addressed by its index in the definition's `effects`, a parameter
+  by name.
+- **New:** `SopraEngine.bindParameterToBusEffectParam(name, busId, effectIndex, paramName, curve,
+  timeConstant = 0)` — `bindParameterToBusVolume`'s counterpart. The curve maps the parameter's value to
+  the effect parameter's; above 0, `timeConstant` makes each change a glide. The address is checked at the
+  bind (throws naming what is missing). The parameter's value takes hold at once, without a glide — at
+  the bind, or when it is first defined or set. The binding is a standing rule: `setBuses` builds every
+  tree that has its target at the bound value (with `keepVolumes` or without; one binding that fails to
+  apply does not stop the rest, and is thrown after), and over a tree that lacks the target it does
+  nothing until a tree has it again. Binding the same parameter to the same target again replaces it.
+- **New:** `AudioEmitter.effectOverrides` (`EffectParamOverrides`, `sopra/runtime`) — the emitter's own
+  values for its event's effect parameters: `set` / `approach` / `get` / `has` / `remove` / `clear`.
+  `AudioEmitterSystem` attaches them at link (`checkAttach` / `attach(event, onChange)` / `detach`): each
+  write is then checked against the event — an address it lacks, or a non-finite value, throws at the
+  write in every build and is not kept, and ones written before the link are checked by the link, which
+  throws before anything plays — and moves the current instance, on both routes. One owner at a time, so
+  one entity per `AudioEmitter` (a second link throws). Every new
+  instance is built at the overrides, at once, never as a glide from the definition, so a managed emitter
+  demoted and promoted again keeps them; `LiveEmitterSet.add` takes them as a new last argument and puts
+  them on each promotion. Live state: not serialized, not part of `equals`/`hash`.
+- **New:** `EffectChain.hasParam(index, name)` and `BusGraph.hasEffectParam(busId, index, name)` — ask
+  whether an address exists, without throwing; `effectParamIndex(effects, index, name)` (`EffectChain.js`)
+  resolves one against a list of effect definitions, or throws naming what it has.
+- **New:** `AbstractAudioEffect.parameters` — each effect class names, once, the parameters its built
+  effect can move: `EqEffect` `frequency`, `Q`, `gainDb`; `CompressorEffect` `threshold`, `knee`,
+  `ratio`, `attack`, `release`; `ReverbEffect` none. Each is the definition field it starts from.
+  `build` returns their `AudioParam`s as `params`, in that order (`BuiltAudioEffect`); a mismatch is
+  refused at build, naming the class. A subclass written before this inherits an empty list and builds
+  and chains as before. `EffectChain` (`sopra/runtime`) is the one place a list of effects is wired and
+  its parameters moved, for buses and instances alike; `BusGraph` builds its inserts through it.
+- **New:** `cancelAndHold(param, time)` (`sopra/util/fadeOutAndStop.js`) — the engine's one
+  cancel-and-hold, with the Firefox fallback; `rampGain`, `BusGraph.setVolume` and `EffectChain` share
+  it. `BusGraph.setVolume`'s fallback now anchors at the current value before setting, as `rampGain`'s
+  always did (no audible change).
+- **New:** `setBuses(definitions, {keepVolumes: true})` — buses present in both trees keep their faders
+  (moved as `setBusVolume` moves them, so an engaged duck carries over); new buses start at their
+  definition. The default is unchanged: every bus starts at its defined gain.
+- **Changed (format):** `EventDescription` binary format 0 → 1 (effects appended). Its record is embedded
+  untagged by `AudioEmitter` and `AudioEventTrigger`, so they move 0 → 1 with it. All three are read from
+  version 0 by upgraders (`EventDescriptionSerializationUpgrader_0_1`, `AudioEmitterSerializationUpgrader_0_1`,
+  `AudioEventTriggerSerializationUpgrader_0_1`), registered by `populateSopraSerializationRegistry` and
+  `populateEngineSerializationRegistry`. They take the registry, because the record's root clip is a
+  polymorphic tree that can only be measured by reading it.
+- **Changed:** the `BusGraph.buses` record holds `effects: EffectChain|null` in place of `chain`, the
+  flat node list `dispose` used.
+
+### A replay reconciliation keeps every predicted entity's input
+
+- **Fixed:** `ServerAuthoritativeClient` (`NetworkSessionReconcile.Replay`) rewound to the end of
+  `server_frame - 1`, applied the one entity's AUTH_STATE, and replayed from `server_frame + 1` — so frame
+  `server_frame`'s input came off every other predicted entity and never went back. A client owning two
+  entities had the first-reconciled one wrong on every tick while input ran, falling up to 242 steps
+  behind; it caught up only once input stopped. It now rewinds to the END of `server_frame`, the point
+  the AUTH_STATE describes, overwrites there, and replays what follows. The default `Correct` mode was
+  never affected.
+- **Fixed:** an applied AUTH_STATE is kept per `network_id` and applied again, at the end of its frame,
+  by any later replay that crosses it. Before, a lossy link delivering one entity's AUTH_STATE for an
+  older frame after another's newer one replayed the second entity back onto its misprediction.
+  A kept correction belongs to one entity on one frame numbering: it is dropped once its id is freed
+  or handed to another entity, and `NetworkSession` forgets them all when an INITIAL_SYNC replaces the
+  world and seeks the clock.
+- **Fixed:** action-stream records arriving for a frame the client had already predicted erased the
+  client's own records for that frame, so the next rewind across it could not undo that input and the
+  replay applied it twice. They are now written after what the frame holds. This is every client's
+  receive path, in either reconcile mode; only `Replay` rewinds across it.
+- **New:** `ServerAuthoritativeClient.forget_timeline()` — drops the kept corrections and the per-entity
+  reconcile watermark, for a caller that replaces the frame numbering itself.
+- **New:** `ActionLog.resume_frame(frame)` and `FrameBufferRing.resume(frame)` — open a frame to write
+  after its committed records; a frame not in the ring opens empty. `FrameBufferRing.open` now zeroes the
+  claimed slot's length until `commit`.
+- **Changed:** an `onApplyAuthState` handler must leave `buffer.position` past what it read: those bytes
+  are the kept correction. A replay that crosses its frame fires the handler again, with a buffer holding
+  just those bytes from position 0.
+- **Changed:** `replayed_arrived_count` counts only records above `server_frame`. Records at
+  `server_frame` are never undone now, so they are never reapplied.
+
+### A stopped network session gives its engine back
+
+- **Fixed:** `NetworkSession.stop()` left the `NetworkSystem` that `start()` added in the engine, so the
+  next session on the same engine — a rematch without a page reload — threw "Another instance of system
+  'NetworkSystem' is already registered" from `start()`. `stop()` now removes it: it is out of the
+  engine's loop when `stop()` returns, and the `network_id`s of the entities left in the world are
+  released. The `InterpolationSystem` stays, whoever added it; the session withdraws only its own source.
+- **Changed:** `stop()` returns a promise, resolved once the engine has shut the system down. Awaiting
+  it is optional.
+- **Changed:** `start()` on a stopped session throws. The next match is a new `NetworkSession`: a
+  stopped one still holds its old peers, and restarted it failed every host tick sending to them.
+
+### A clip plays whatever else its nodes carry
+
+- **Fixed:** a clip keying a node that is neither a skin's joint nor above a mesh — a leaf bone an
+  exporter left out of the skin, a socket nothing is attached to yet, an animated empty — never
+  played on the GPU, and nothing said so: it waited for a row no system held, and none of its other
+  nodes moved either. Broken in 3.44.0, when `MeshSystem` stopped holding a row for every node of a
+  model. `AnimationSystem` and `AnimationGraphSystem` now hold every node their entity's
+  `AnimationClips` key, with the chain above it, until the clips go (`hold_clip_targets` /
+  `release_clip_targets` in `register_clips.js`).
+- **Fixed:** a rig built in code, driven by `AnimationSystem` or `AnimationGraphSystem` with no
+  other system placing rows, threw "the scene names no dataset" once there was a device. The drivers
+  bind the scene to their dataset at startup, as every system placing rows does.
+
+### Cloth reuses core, and core gains what cloth had kept to itself
+
+Cloth had grown private copies of geometry, graph and numeric code the engine already had, and
+general-purpose code nothing else could reach. The copies now call core, and the general pieces
+live there.
+
+- **New:** rigid poses, translation and rotation as separate operands, no allocation —
+  `pose3_apply_point_array`, `pose3_apply_inverse_point_array`, `pose3_to_local_array`,
+  `pose3_compose_array` (`core/geom/3d/pose`). Cloth, frame FABRIK and the box, hull and capsule
+  narrowphase use them.
+- **New:** `quat3_multiply_conjugate_left_array` (a*⊗b), `quat3_multiply_conjugate_right_array`
+  (a⊗b*), `quat3_clamp_angle_array` (same axis, at most the given angle, exactly).
+- **New:** `v3_normalize_array_checked`, `v3_reject_array`, `v3_distance_array`,
+  `tri3_compute_normal_area_weighted_array`, `aabb3_array_round_outward_f32`, `min2_exact` /
+  `max2_exact` (`Math.min` / `Math.max` without the call), `array_sort_insertion_ascending`,
+  `matrix_symmetric_3x3_solve_ldlt` (packed `[m00, m11, m22, m01, m02, m12]`).
+- **New:** `csr_build_incidence`, `csr_graph_color_greedy`, `csr_graph_validate_coloring`
+  (`core/graph/csr`). Cloth colours over them: a 64×64 sheet's colouring went from 134 ms to
+  3.5 ms, same colours.
+- **New:** `parent_entity_model_of` (`engine/ecs/parent`), `t64_read_pose_array`
+  (`engine/ecs/transform`), `fluid_sample_velocity_world_mps` and `fluid_sample_domain_bounds`
+  (`engine/physics/fluid/ecs`); `FAT_LINEAR` is exported from `compute_fat_world_aabb.js`.
+- **Fixed:** a cloth frame spinning faster than its per-step limit turned exactly that limit; it
+  turned less, three quarters of it at a half turn.
+- **Fixed:** `ClothFluidWind` placed the field/ambient boundary half a cell off the field's cells,
+  toward +: `origin` is cell (0, 0, 0)'s centre, not its corner.
+- **Fixed:** a cloth collider's leaf in the broadphase is rounded outward to float32 exactly,
+  rather than padded by two ulps of its magnitude.
+- **Changed:** a vertex whose Hessian is not positive definite now keeps its position in a build
+  without asserts, rather than taking a step from a failed factorisation. With asserts it throws, as
+  before.
+
+### The cloth builders refuse a scaled rig
+
+- **Fixed:** `cloth_proxy_from_joints` and `cloth_proxy_from_mesh` refuse a rig with a rest scale
+  (beyond 1e-4) on any node above a particle, up to the model's root, and name it. Cloth simulates
+  and writes back rigid poses and the GPU scales what lies under a scaled node, so such a garment
+  was drawn at another size than the one simulated: a 10 cm chain under a joint scaled by 2 was
+  simulated at 0.1 and drawn at 0.2, and its colliders met the smaller one. A scale on the entity
+  that places the model is not seen at build time and is not checked.
+
+### A cloth collider that stands still costs nothing to keep
+
+- **Breaking:** `ClothColliderFlags.Static` is removed. A collider whose pose has not changed since
+  the last step is no longer refit (1.43 → 0.42 µs per collider per step), which is what the flag
+  saved, so there is nothing left to promise. A collider saved with the bit still loads, and is swept
+  when it moves rather than left behind. The `flags` word and its binary format are unchanged.
+
+### Clips are components; animation needs no model system
+
+`AnimationSystem` and `AnimationGraphSystem` could reach a model's clips only through
+`MeshSystem.instance_of(entity).clips`, so a rig built in code could not animate. The clips are now a
+component on the entity that plays them, and the drivers read nothing else.
+
+- **New:** `AnimationClips` (`engine/graphics3/animation`), the clips an entity can play:
+  `ShadeAnimationClip`s whose channels key entities, looked up by name. It goes beside the `Animation`
+  or `AnimationGraphController`. Not saved, as `MeshSkin` is not; replaced, never edited.
+- **New:** a model `MeshSystem` loads carries an `AnimationClips` on its root, its clips re-addressed
+  to the placement's entities, empty when the model has none. It comes and goes with the model.
+- **New:** a rig built in code animates: `Transform64`, `AnimationClips` and an `Animation` or
+  `AnimationGraphController` on the root; `TransformAttachment` and `GPUStateAuthority` on each joint a
+  clip keys, and `ParentEntity(root)` where IK, `ContactProbe` or cloth should see the clips.
+- **Breaking:** `AnimationSystem` and `AnimationGraphSystem` take `(graphics, scene)` and play the
+  `AnimationClips` on their entity. They no longer depend on `SGMesh` or hold a `MeshSystem`.
+- **Breaking:** `PrefabInstance.clips` is removed; read the root's
+  `getComponent(root, AnimationClips).clips`.
+- **Breaking:** `register_instance_clips.js` is `register_clips.js`:
+  `register_instance_clips(context, instance, slots)` is `register_clips(context, clips, slots)`,
+  `unregister_instance_clips` is `unregister_clips`, `InstanceClipRegistration` is
+  `ClipRegistration`. `ClipListPlayer.bind(entity, ecd, clips)` takes the clips, and
+  `ClipListPlayer.instance` is `clips`.
+
+Migrating: pass the drivers the scene the `MeshSystem` was given, in place of the `MeshSystem`.
+That is one argument at each known call site: queep-3-arena `src/app/main.ts:458`,
+`new AnimationSystem3(graphics, meshes)` → `new AnimationSystem3(graphics, scene)`; old-circle
+`packages/client/src/render/scene.mjs:75`, `new AnimationSystem(engine.graphics, this.meshSystem)` →
+`new AnimationSystem(engine.graphics, this.scene)`.
+
+### Skins are components; MeshSystem only loads
+
+`MeshSystem` is a shortcut: an `SGMesh` naming a file becomes the model under its entity when the
+file has loaded. It had also become the only place a model worked — it registered skins, held a row
+for every entity of a model and kept them current — so a skinned mesh built in code could not be
+drawn deformed without faking a loaded asset. All of that now lives in components read by their own
+systems, the same for a loaded model and a mesh built in code.
+
+- **New:** `MeshSkin` (`engine/graphics/ecs/mesh-v2`), the skin of the mesh on its entity: its joints
+  as entities, in the order the geometry's joint indices address them, and their inverse binds. Not
+  saved, as `ShadedGeometry` is not; replaced, never edited.
+- **New:** `MeshSkinSystem` registers every `MeshSkin` with the animation manager and binds its mesh,
+  again after a renderer restart. Meshes bound to one skeleton the same way (a body and its hair)
+  share one skin on the GPU. Add it beside `ShadedGeometrySystem`.
+- **New:** a primitive, and a skin's joint, holds the rows of everything above it, followed as they
+  move (`RowChains`), so it composes on the GPU under a node a clip drives. A clip keying a node above
+  a rigid mesh (a head under an animated tag) now binds without a model system holding every row.
+- **New:** `GPUAnimationManager.register_skin(joints, inverse_bind_matrices)` answers a second
+  registration of the same joint entities under the same inverse binds with the first one's id;
+  `bind_skin_mesh` / `unbind_skin_mesh` bind meshes one at a time, once the skin's joints are named.
+- **Fixed:** a mesh bound to a skin before its clone existed kept the skin's id after the skin was
+  unregistered: the next skin to take the id deformed it, and binding it to its own was refused.
+- **Breaking: a skinned model deforms only where `MeshSkinSystem` runs.** `MeshSystem` no longer
+  registers skins or holds rows. `MeshSystem.animation_of`, `PrefabInstance.skins`,
+  `InstanceAnimationRegistration` and `register_instance_animation` / `unregister_instance_animation`
+  are removed; `register_instance_animation.js` is `register_instance_clips.js`.
+- **Breaking:** `GPUAnimationManager.register_skin(skin)` is `register_skin(joints,
+  inverse_bind_matrices)` plus `bind_skin_mesh` per mesh, and `unregister_skin` on a skin it issued
+  releases one registration.
+- **Breaking:** `ClothRig.skin` is the entity whose `MeshSkin` the proxy indexes (-1 until named), not
+  an ordinal; `ClothRig.from(proxy, skin)`. `ClothSystem.models`, `WorkerClothSystem.models` and
+  `ClothWorld.models` are removed. A `ClothRig` saved as JSON with `skin: 0` now names entity 0.
+- **Breaking:** a primitive under a parent holds the parent's row and is written as its offset under
+  it, not as a world pose under the scene root.
+- **Breaking:** `prefab_place` answers `skins` (`{entity, skin_id}[]`, or null) instead of `animation`.
+
+### Water surface: spectral bands and wave particles
+
+`WATER_SURFACE_SIMULATION_PLAN_2026_10_06.md`, `WATER_SURFACE_DISTANCE_LOD_PROPOSAL_2026_10_06.md`. The placeholder
+simulation is replaced by a surface that works from a cup to an ocean, entirely on the GPU, and costs what the view
+shows: a body out of view costs one culling thread a frame.
+
+- **New:** every body's ambient waves follow from its wind and its fetch. Eighteen spectral bands, 7.8 mm to 1 km,
+  shared by every body and animated once a frame (128² FFT tiles in two fused workgroup passes, ~21 µs on an RTX 4090;
+  nothing while calm or paused), are weighted per body by a fetch-limited JONSWAP sea projected onto them on the GPU:
+  the band projection keeps the published spectrum's height variance within 1.5%, and a 10 m/s wind over 10 km raises
+  the half-metre sea of the JONSWAP growth law. Fetch is the chord of the ellipse in the body's box along the wind, so a
+  long narrow lake is long only along its length. Crests travel downwind and are pinched as a Gerstner wave's are, with
+  a fold clamp. Waves too short for the cells they are drawn on are filtered into slope variance for the BRDF rather
+  than aliased. The spectrum evaluates only the bands a body in view can draw, and only when time moved.
+- **New:** wave particles (Yuksel et al. 2007, with packet kernels after Jeschke & Wojtan 2017).
+  `WaterSystem.splash` rings travel at their group speed, spread over their widening front, damp by viscosity and
+  surface film (a raindrop's ripple is gone in a fraction of a second, a big splash crosses a bay), split as their
+  fronts widen, and reflect off the body's authored outline, islands included. Update, emission, binning into a
+  16-level hash and conservative per-body bounds all run on the GPU, dispatched from GPU counts.
+- **New:** the surface is drawn from a distance-LOD lattice per body (CDLOD, Strugar 2010): square cells fixed to the
+  water in its metric frame, their size from the distance to the camera, odd vertices morphing onto the coarser grid
+  so levels meet without cracks, cut exactly by the authored triangles so outlines, islands and sloped rest heights
+  stay the mesh's own. It replaces the screen-space lattice, which coarsened a whole body to keep displaced points on
+  screen and drew the sea flat with the camera among the waves (×166 at 9 m over a 20 m/s ocean). Displacement no
+  longer decides how many vertices there are. A quadrant wholly inside a triangle draws as one indexed 9 × 9 patch;
+  cells a triangle cuts are clipped once, in a compute pass, and drawn from their stored polygon; a body too far for
+  any of its waves draws its authored triangles. Measured on an RTX 4090 at 1058 × 746 for that ocean from 9 m:
+  180,000 cells in patches, 176,000 interior and 146,000 boundary cells; the two surface passes 0.82 + 1.21 ms and
+  the frame's GPU time 4.1 ms, against 2.03 + 2.42 and 6.4 ms with every cell drawn as its own 6 or 15 vertices.
+- **New:** a culling pass in front of the simulation, one thread a body against the frame's view with a prior bound on
+  its waves (twice its bands' envelopes, its particles' last bounds, its queued splashes). The spectrum, wave
+  particles, bounds and tessellation then run over what it keeps. A hidden body is paused — its wave particles stand
+  still, its wind turn holds — unless `Water.simulateWhenHidden`. 4,000 hidden bodies add under 2 µs (they cost
+  0.37 ms before); 1,000 sub-pixel ponds in view cost their triangles (+0.45 ms) instead of 4,608 vertices each per
+  pass (+340 ms).
+- **New:** the short waves are shaded per pixel. A band too short for the cells it is drawn on but long enough for the
+  pixel tilts the pixel's normal; only what neither resolves becomes roughness. Before, a band had to span sixteen
+  cells to be drawn whole, so at 4 px cells anything under ~64 px a wavelength turned to roughness, even up close.
+  The ocean from 9 m now shows at 4 px cells the chop it showed only with 1 px cells; on an RTX 4090 that costs
+  ~0.25–0.3 ms a surface pass.
+- **Fixed:** splash rings went missing: a fresh ring sometimes never showed, and rings winked out and came back with
+  no new splash, more and more as a pool filled with reflections. The particles were there all along; the hash's crowd
+  thinning hid whole fronts by a lottery, and counted every packet of a front an outline had broken as a front of its
+  own, so a few reflected rings made a crowd. In a 7 × 4.5 m pool with a stone every 0.9 s (the water-splash example,
+  seeded, stepped at 60 Hz on an RTX 4090), 47 of 66 rings were drawn at under half their height in their first second
+  — one not at all for two seconds — 38 vanished and 26 came back, and the surface drawn missed 88% (rms) of what the
+  packets make, while no point read more than 49 of the surface sampler's 64 entries. Now a run of a front's
+  neighbouring packets is one entry a hash cell, drawing exactly the surface its packets sum to, mirror images and gaps
+  included, so a point reads about one entry a front that reaches it. Where a point would still read more than 48, its
+  flattest runs are doomed: they fade over a third of a second and die. A front that would take a point past the
+  sampler's 64 is cut at once, whole, and dies. The steepest are always kept, and nothing doomed comes back. The same
+  pool: every ring drawn whole from its landing, none vanishing or returning, the surface drawn the packets' to f32,
+  never past 64 entries a point; a ring is doomed some 11 s after it lands, at a steepness of about 0.012 (0.1 when
+  fresh). The cup under 195 drops a second stays within the 64 too. On an RTX 4090, the water playground stepped at
+  60 Hz: the particle passes cost ~25 µs a frame more on its ocean (12,500 particles) and ~8 µs on its lake, and the
+  water as a whole ~110 and ~80 µs less, the surface passes reading one entry a run where they read every packet; the
+  cup costs the same. The pool costs ~13 µs more in the particle passes and ~67 µs more in the surface passes, which
+  now draw the rings that were hidden. ~10 MB more at the default capacity.
+- **Fixed:** a wave packet that falls below the drawing threshold fades out over a third of a second instead of
+  vanishing.
+- **Fixed:** a splash's ring snapped to a different shape under a second after it landed, when its particles first
+  split. Their packets had straight crests, which tile a front only along its tangent, so the split redrew the ring
+  (by 64% of its peak). Packets now curve around their front's centre, so a front draws the same ring at any particle
+  count.
+- **New:** `Water.simulateWhenHidden` (default off). The binary adapter is at version 5; the v4→v5 upgrader gives old
+  saves the default.
+- **New:** `WaterWaves.upwindFetch`, the open water beyond the mesh (an open sea states the distance to its far
+  shore), and `WaterWaves.shoreReflection`, the outline's amplitude reflection for wave particles (default 0.5).
+  The binary adapter is at version 1; the v0→v1 upgrader gives old saves no upwind fetch and the default
+  reflection.
+- **Changed:** `WaterWaves.windDirection` is an angle in the body's local xz that turns with the body and is not
+  skewed by its scale. A change of direction turns the waves over four seconds; a wind that keeps turning is
+  followed a turn behind.
+- **Removed:** the placeholder simulation: `GPUWaterWaveSimulation`, `shader_water_wave_batch`,
+  `shader_water_wave_domain` and `chunk_water_wave` — the 512² per-body wave-equation grid and its
+  terrain-depth wave speed. Waves no longer slow in shallows: deep water is assumed.
+- **New:** `GPUTypedTableDescriptor.chunk_read_field(name, rw)` reads one field from a database bound read+write.
+- **Fixed** (WGSL emulator): an element read out of a constructed `array<T, N>(…)` keeps its type, so a swizzle or
+  member read on it compiles (it read garbage, or NaN); an array sized by a named constant starts as that many
+  zeros (it started empty); `textureStore` takes the array-layer form.
+- **Fixed** (WGSL emulator): a shift of an i32 keeps its sign. WGSL makes every shift amount a u32, and the emulator
+  sent any shift with a u32 operand through its unsigned helpers: `>>` filled with zeros where WGSL sign-extends
+  (`-1 >> 1u` was 2147483647, not -1), and `<<` handed a scalar back unsigned (`-1 << 1u` was 4294967294), in scalar,
+  vector and compound forms alike.
+- **New:** the `water_surface` playground: a cup, a puddle, a lake and an ocean in one scene, with wind, rain,
+  click-to-splash and per-pass GPU timings.
+
+### Saving skips a component flagged transient
+
+- **Fixed:** a component carrying `COMPONENT_SERIALIZATION_TRANSIENT_FIELD` is left out of a save in a
+  dataset where no entity has a `SerializationMetadata`. `BinaryBufferSerializer` gave up on the
+  missing type before it read the component's own flag, so the component was written, and a load
+  made a second copy of one that is rebuilt at runtime.
+
+### Cloth over animated joints: a hold, not a bit
+
+A garment's joints and the clips that key them both want a joint's offset, and the two sides flipped
+one `GPUStateAuthority` bit without each other. The bit was also never what stopped a clip: no GPU
+pass reads it.
+
+- **Fixed:** a cape simulates under a clip that keys its bones. A bound clip wrote the joint's row
+  on the GPU every frame, after the CPU's flush, so cloth's write-back never reached the screen
+  there. The clip's bindings for a joint cloth holds are now muted.
+- **Fixed:** a joint whose clip was unregistered while cloth held it is no longer frozen once the
+  garment goes. A clip that starts while cloth holds a joint no longer cuts off cloth's write-back,
+  and one that stops no longer writes its last pose over cloth's offset. A rig re-seeded while
+  seeded gives its joints back when it goes, and `ClothWorld#reseed` gives them back at once, so a
+  rig removed or refused before its next seeding leaves no joint held.
+- **Fixed:** a joint a hold has let go of with a clip still bound shows what the exact evaluation
+  says. A clip faded out over it resolved to the rest from before the hold, or to the holder's pose
+  when the clip bound, rather than the offset the holder left. And what the holder wrote just before
+  letting go never reached the row, so the axes no clip keys kept its previous pose. Neither did an
+  offset announced in the frame a clip first binds the joint.
+  `GPUSceneRows#mark_handover` is new: the one write of an offset past the bit, as the GPU takes it.
+- **New:** `GPUStateAuthority#held`, `gpu_authority_hold`, `gpu_authority_unhold`,
+  `gpu_authority_held` and `GPU_AUTHORITY_EVENT_HOLD_CHANGE`: a CPU writer holds a component against
+  the GPU. `gpu_authority_grant` does not set a held bit, and the GPU writer takes the component back
+  when the hold ends. `t64_evaluate_world` and `T64WorldCache` answer a held level with its offset
+  (`t64_evaluate_local`), as the GPU shows it.
+- **Breaking:** `ClothInstance#revoked_joints` is `held_joints`, and holds every joint the rig
+  drives.
+
+### IK: goals on bones, frame FABRIK, limits and contacts from physics
+
+The ECS IK is rebuilt on `engine/ecs/ik/PLAN.md`. A goal sits on the bone it moves, the tree is the
+`TransformAttachment` hierarchy, joint limits are the physics `Joint` on each bone, and ground contact
+comes from a physics cast.
+
+- **New:** `IKGoal` on the effector bone - `target` and `chain_root` entities, `position_weight`,
+  `rotation_weight` - solved by `IKGoalSystem`: frame FABRIK over the goals whose paths share a bone,
+  and the analytic two-bone solve for a lone path of three bones, whose knee takes its hinge from the
+  physics `Joint` on it. IK holds the bones it poses (`gpu_authority_hold`), so a clip keying them is
+  muted and the GPU row, `t64_evaluate_world`, sockets and cloth anchors read IK's offset; each
+  tick's pose starts from the clips, never from that offset. A goal goes when its target or a bone of
+  its path is destroyed, and gives its bones back as they were authored.
+- **New:** `frame_fabrik_solve` over a `FrameFabrikProblem`: frame FABRIK on typed arrays, allocating
+  nothing per solve. Every solved joint is a frame, so a branch keeps its children's offsets. Weight 0
+  gives the pose no goal gives, the pose is continuous in the weight, and the solve stops on joint
+  movement.
+- **New:** `two_bone_path_solve` and `joint_hinge_mid_axis` (the knee's `mid_axis` from its
+  `Joint`, its bend side from asymmetric limits), `frame_fabrik_limit_from_joint`, and in core
+  `swing_twist_clamp_array` and `swing_twist_compose_array`: IK keeps each bone inside the box a
+  `Joint` with `swingTwist` allows.
+- **New:** `ContactProbe` and `ContactProbeSystem` (physics): a ray, or a sphere cast, from a
+  reference entity, placing the probe's entity at the hit, turned as the reference and tilted to the
+  surface, and passing through the character's own colliders. A foot's target, a decal, an AI.
+- **Changed:** `swing_twist_error` and `swing_twist_error_array` moved to
+  `core/geom/3d/quaternion/swing_twist_error.js`; `solve_constraints.js` no longer exports them.
+- **Changed:** `AnimationSystem` and `AnimationGraphSystem` declare that they write `Animation` and
+  `AnimationGraphController`, so a system reading them (IK) runs after them.
+- **Breaking:** `InverseKinematics`, `IKConstraint`, `InverseKinematicsSystem`, `IKProblem`,
+  `IKSolver`, the `"2BIK"` and `"1BSA"` solvers (`TwoBoneInverseKinematicsSolver`,
+  `OneBoneSurfaceAlignmentSolver`), `ik_probe_terrain_contact`, `ik_bone_chain`,
+  `ik_write_local_rotation`, `InverseKinematicsSerializationAdapter` and its upgrader are gone, and
+  the engine's serialization registry no longer registers them. **A save containing an
+  `InverseKinematics` component now fails to load entirely: the binary deserializer cannot skip an
+  unknown type.**
+
+### Two-bone IK lands the effector on the target
+
+The two-joint solver (`two_joint_ik`, behind the ECS foot IK) missed reachable targets.
+
+- **Fixed:** a target off the plane the limb bends in is reached. The hip's two corrections were
+  composed in the wrong order, as the listing in the reference the solver follows composes them;
+  on a 0.92 m leg, targets 11 and 23 cm away were missed by 1.6 and 14 mm.
+- **Fixed:** a target within a centimetre of full reach is reached, and one beyond it straightens
+  the limb toward it. The reach was clamped 0.01 short of the bones' span, so a foot set down at
+  the edge of its reach stopped above the ground.
+- **Fixed:** a target on the far side of the root from the effector - an arm hanging down reaching
+  straight up - is reached. The swing's axis was the cross product of two rays along one line, so
+  the limb bent to the right reach and never turned, a metre off on a 0.92 m leg.
+- **Fixed:** the mid joint bends about its own hinge, whichever way it faces and however its frame
+  is oriented. The solver took the bend axis from the mid joint's local -Z, which is right only for
+  a rig whose -Z lies in the bend plane on the knee's side: a knee bending toward +Z missed a target
+  10 cm up by 119 mm, and bone frames yawed 30 and 90 degrees missed by 8 and 59 mm. A knee animated
+  a little past straight is brought round to the side its hinge bends it (it missed by 18 mm), and
+  a hinge that is not square to the bones is solved exactly.
+- **Breaking:** `two_joint_ik(a, b, c, t, mid_axis, a_gr, b_gr, a_lr, b_lr)`. `eps` is gone (it
+  followed the target), and `mid_axis` takes its place: the mid joint's hinge in its own frame, of
+  unit length, about which a positive turn straightens the joint - ozz-animation's convention.
+
+### Screen-space reflections
+
+- **New:** `Renderer.ssr.tile_denoising_enabled` opts into 8×8 coverage tiles with a two-tile
+  halo. Stationary, constant radiance without ray support, uncertainty or changing history can
+  skip spatial filtering and temporal neighborhood statistics. Reprojection validation and
+  history age still run. It defaults to `false`; profile the scene and device before enabling it.
+- **Fixed:** the reflection lab uploads changes to mirror roughness. Its spatial measurement,
+  and the variance lab's capture and reference, recognize the tiled denoising passes.
+
+### Shadow casting
+
+- **Changed:** shadow casters are drawn by their front faces, as the main view draws them, in every
+  shadow type — cascades, virtual shadow maps, spot and point lights. Back-face casting on top of the
+  shadow pass's rasterizer slope bias had left every shadow a texel or so short of where its caster
+  meets the ground. A one-sided surface now casts from the side it shows.
+- **Changed:** a point light's receiver depth bias is a world offset toward the light of a texel of
+  its map at the receiver, scaled by the surface's slope, in place of a flat 1e-4 of its range, which
+  front-face casters speckled through.
+
+### Virtual shadow maps
+
+A directional light's shadow from a clipmap of pages drawn on demand
+(`shade/renderer/shadow/vsm/PLAN.md`). Cascades stay the default.
+
+- **New:** `Renderer.feature_virtual_shadow_maps`. Each shadow-casting sun gets 12 levels of 64×64
+  pages of 128 texels around the camera, from a 1 cm finest texel, in a pool of 30×30 slots in the
+  shadow atlas. Pages are drawn as the main view's pixels ask for them and as moving casters make
+  them stale, at most `Renderer.shadow_virtual_page_budget` a frame (default 8, shared between suns).
+  Covers for pixels with nothing resident above them come first, then stale and missing pages by
+  the importance of the pixels asking × frames waited. A pixel's importance is its weight under the
+  automatic exposure's metering mask, now a shared chunk (`chunk_screen_importance`): full over most
+  of the screen, less toward its edges. `shadow_virtual_lod_bias` and `shadow_virtual_first_texel_size`
+  tune the levels. Every reader of the sun's shadow — surface lighting, volumetrics, water — samples
+  it through the light database it already binds.
+- **New:** casters that moved are found on the GPU, by what changed rather than what they are: a
+  mesh row whose transform, world box, geometry or material changed since the last frame, and a
+  skinned mesh whose joints' skin matrices did. The pages under them are marked stale in a compute
+  pass, and the marks wait on the GPU until a readback takes them.
+- **New:** the playground `src/shade/playground/vsm/`: a courtyard and a crowd, the cascades for an
+  A/B, overlays for the serving level, the resolution deficit and page edges, an inset of the pool,
+  a clipmap panel, and `verify()`, which checks the GPU's page table against the CPU's.
+- **New:** `VTPhysicalSlots`, the slot bookkeeping `VTPhysicalCache` now extends;
+  `GPUAnimationManager#get_skin_joint_count`; `SKINNING_BINDING_STRUCT.skin_matrix_count`.
+- **Fixed:** a receiver past a shadow map's far plane read shadowed against a texel nothing was drawn
+  into. It now reads lit there, and shadowed by anything drawn.
+- **Fixed:** the GPU database's WGSL serde reads and writes `i32` and `vec2i`–`vec4i` fields, and
+  `read_wgsl_type_value` returns negative signed vector components as negatives.
+- **Breaking:** `shadow/map/csm/CSM_SHADOWMAP_STRUCT.js` is
+  `shadow/map/DIRECTIONAL_SHADOWMAP_STRUCT.js`, with a `virtual_map` field.
+- **Removed:** the earlier virtual shadow map prototype, which nothing reached:
+  - `GPUViewShadowMaps`, `VirtualShadowmapRenderer`, `GPUVirtualShadowTextureResidence`;
+  - `vsm_tile_allocation_pipeline`, `vsm_residence_pipeline`, `vms_pipeline_compute_coarse_bounds`,
+    `render/vms_render_tiles`;
+  - `decode_tile_address`, `debug_inspect_coarse_bounds_buffer`, `debug_inspect_residence_buffer`;
+  - `VSM_UNIFORMS_STRUCT`, `VSM_RESIDENCE_WORKGROUP_TILE_RESOLUTION`;
+  - `light/GPUViewLightContext`.
+
+### Water surface and optics
+
+Stages of `WATER_OPTICS_PLAN_2026_10_02.md`.
+
+- **New:** water is a real mesh. A primitive GPU wave simulation (a damped linear wave equation on a
+  512² grid over each body, wave speed √(g·d) from the terrain depth, so waves slow in shallows and
+  reflect from the shore) writes a vertex buffer behind a surface interface the production simulation
+  will replace. `WaterWaves` (wind speed and direction) drives it; a body
+  without one is calm. `WaterSystem.splash(entity, position, radius, strength)` kicks the surface.
+- **Removed:** the analytic optical normal and the shore wave shading: the surface's geometry supplies
+  its normals. `Water.opticalNormalStrength`, `opticalNormalScale`, `waveSpeed`, `waveAmplitude`
+  and `waveFrequency` no longer reach the renderer.
+- **Breaking:** `Water` is physical authoring data: `level`, `ior` (default 1.333), `roughness`
+  (default 0.02, formerly `reflectionRoughness`) and `medium`, a `ParticipatingMedium` — the same
+  description the path tracer, fog and glass read. `color`, `shoreColor`, `shoreDepthTransition`,
+  `scattering`, `extinction` and the optical-normal and wave fields are gone. The binary adapter is at
+  version 3; the v2→v3 upgrader keeps level, IOR and roughness and gives old levels the default
+  medium in place of their uncalibrated colours.
+- **New:** water media tools in `shade/renderer/medium/water/`: presets (`water_medium_preset`, from
+  swimming pool to turbid river), a bio-optical model from chlorophyll, CDOM and minerals, Jerlov
+  types, an inversion from a target deep colour and clarity distance, and the spectral-to-RGB fit
+  they all end in. The default is clear open ocean, chlorophyll 0.3 mg/m³.
+  `participating_medium_to_json` / `serialize_participating_medium` store a medium.
+- **New:** the water's colour is light, not paint: the sun, refracted and shadowed by the cascaded
+  shadow map, and the sky the active GI mode reports, sent back up the refracted view ray by the water
+  column with every order of scattering — Lee's shallow-water model with QAA's deep-water reflectance,
+  which takes the medium's phase functions through its backscattering. Against a Monte Carlo slab
+  oracle it is within 0.82–1.49 in deep water across the presets; turbid water reads brown, clear water
+  blue. Light leaving the water crosses the surface by exact Fresnel and the n² law, so a
+  floor seen through water reads about half as bright as it would dry. Reflections that miss on
+  screen fall back to IBL or Brick4, whichever the renderer runs, as SSR's do.
+  `GPUWaterRenderer.settings.inscatter_segments` (default 4) sets the steps of the in-scatter.
+- **Fixed:** the WGSL emulator read a component of `refract`'s result as an absent property, so
+  `refract(...).y` was NaN on the CPU and a number on every device.
+- **New:** what is seen through water was lit through it. Surface shading stays unaware of water;
+  the water optics pass rebuilds each submerged receiver's irradiance dry and under the water — the
+  sun refracted and attenuated by Gordon's diffuse attenuation, shadowed, the GI mode's sky through
+  the diffuse Fresnel transmittance — and scales the receiver by the ratio, so floors darken and lose
+  red with depth. It costs nothing outside water-covered pixels. A lamp's light and emission are
+  scaled by the same ratio, and lit particles under the surface get no downwelling yet.
+- **Changed:** a water surface is its mesh and nothing else: the water passes read no height map and no
+  terrain, so bodies of any number and scale — an ocean, a mountain lake, a cup on a table — draw the
+  same way. Shore water fades in by its depth over the scene behind it, and where nothing is seen
+  through the water it reads as deep, to where its clearest channel keeps a thousandth.
+
+### Participating media in the path tracer
+
+The path tracer and the bakes that trace with it carry light through participating media — one
+volume system for water, fog, clouds and glass (`PATH_TRACED_MEDIA_PLAN_2026_10_02.md`). A scene
+with no medium and no participating-media volume renders as it did.
+
+- **New:** `ParticipatingMedium` (`shade/renderer/medium/`) describes what fills a region: RGB
+  absorption in 1/m and up to four scattering lobes, each with its own phase function
+  (`PhaseHenyeyGreenstein`, `PhaseCornetteShanks`, `PhaseRayleigh`, `PhaseDraine`,
+  `PhaseWaterMolecular`, `PhaseFournierForand`, `PhaseJendersieDeon`). `StandardShadeMaterial.medium`
+  names the medium inside a closed surface; the resident material table the ray passes read carries
+  its slot (`INDIRECT_MATERIAL_STRUCT.medium`, in former padding) and a media table beside it.
+- **New:** a material with a medium is a refracting interface into it, with probability
+  `transmission_factor`: exact Fresnel at the ratio of the two sides' `ior_factor`, total internal
+  reflection, and the (n_from / n_to)² that radiance carries across. Media nest and overlap by
+  `ParticipatingMedium.priority` — water inside a glass inside a tank, water modelled into the wall
+  holding it. A path starting inside a medium, an underwater camera or probe, finds it. Without a
+  medium, transmission stays thin-walled.
+- **New:** inside media and the scene's participating-media volumes, paths scatter and are absorbed
+  (free flight against per-channel majorants, hero-channel spectral MIS over RGB), light is sampled
+  from every scattering point, and shadow rays are attenuated by what they cross, an index-matched
+  (`ior_factor` 1) boundary included. `playground/path_traced_media/` holds the device checks:
+  Beer-Lambert through a slab and through glass with every internal reflection summed, an
+  underwater camera, white furnaces and shadows through media, each against its closed form.
+- **New:** light reaches a surface or a scattering point through one smooth refracting interface —
+  the sun on the bottom of a pool, a lamp behind a window of water — by manifold next-event
+  estimation (Hanika et al. 2015): Newton steps on Snell's law find where the light refracts, and the
+  beam's spreading and the surface's curvature (its interpolated normals) weigh it, so waves throw
+  caustics. Every light type; at most 8 steps and 16 ray casts a connection and 4 connections a
+  path. A step that overshoots — a low sun seen from under water — is shortened; a mesh between the
+  surface and the interface (an index-matched box in the water) is passed; far from the origin the
+  solve settles for what f32 resolves. Through flat water it meets the closed form to 0.1% for the sun
+  from 30 to 85 degrees and for a lamp overhead. A surface under water facing away from a low sun is
+  lit by its refracted light, and a surface inside a medium reflects by the ratio of its index to the
+  medium's. `path_traced_media`'s scenes take 18 and 15 ms a 512×512 frame on an RTX 4090.
+- **Not yet:** light through two refracting interfaces — through a glass sphere, in and out — still
+  reaches nothing behind them directly, nor light through a normal-mapped surface as its normal map
+  bends it: connections walk the vertex normals. Where waves overlap enough that several points
+  refract the same light to the same receiver, the one found stands for all. Past a path's fourth
+  connection, light behind an interface is lost to it: an estimated 18–22% of the sunlight scattered
+  in a milky sphere, 31–55% in deep water of albedo 0.9–0.99. A spot's cone, and a surface in air lit
+  through water by a light in it, are judged along the straight line. Interfaces are smooth whatever
+  the material's roughness, and alpha on a medium-bounding surface is ignored. `serialize_scene`
+  keeps a material's `ior_factor` but not its `medium`, nor the scene's participating-media
+  volumes: a saved scene loads with its water and glass thin-walled. Every loop a path runs
+  has a fixed limit, so no thread can
+  hold its group: 32 scattering events, 16 interface events (the first 4 about the interpolated
+  normal, the rest about the triangle's, which lets out light a tessellated sphere would otherwise
+  trap by total internal reflection near its outline), 8 pass-throughs, 64 collisions and 64 volume
+  pieces a flight — 32 separate volumes on one ray, past which the rest of it is taken as one piece
+  and soon cut. What a limit drops is light: 0.1% at the outline of a 5,000-triangle glass sphere
+  in a white furnace, 0.5% of a scattering glass sphere (0.7% at its outline).
+- **Fixed:** the path tracer's specular bounce weighed what it reflects by `F termV / (termV +
+  termL)`, which drops the NoL·NoV term of the VNDF weight G2 / G1: a smooth surface's reflections
+  carried half their light, a rough one's somewhat less. A black glass tile reflecting an emitter
+  read 0.020 against Fresnel's 0.040; it reads 0.03998.
+- **Fixed:** a participating-media volume scaled to nothing on an axis put every point of the world
+  inside it (the first in the scene) or became a copy of the volume before it; it is left out.
+- **Faster:** the path tracer's light selection walks only the pages lights occupy — they are
+  packed from row 0 — instead of every page the light tables could hold, twice per light sample.
+  In `path_traced_media`'s scene without media, 7.0 → 4.8 ms a 256×256 tile on an RTX 4090.
+- **Breaking:** a shader importing `chunk_render_trace_path` binds the resident media table as the
+  uniform `media` (`MEDIA_TABLE_STRUCT`, `GPUResidentMaterialContext.buffer_media`) beside
+  `materials`.
+- **New WGSL:** `F_dielectric` (exact unpolarized Fresnel with total internal reflection),
+  `sample_henyey_greenstein_cos`, `sample_draine`, and the Fournier-Forand phase function with its
+  sampler and `fournier_forand_parameters_from_backscatter`. `sample_draine_cos` is deprecated: its
+  closed form loses the distribution for small g and large alpha (CDF error 0.09 at g = 0.1,
+  alpha = 250; total below g = 0.003). `select_light_importance` takes a zero normal for a point with no
+  surface, inside a medium, and weighs every light by its irradiance there alone.
+- **Breaking:** a scene's participating-media volumes are rows of its scene database
+  (`participating_media_volumes`), which the froxel volumetrics read through
+  `chunk_participating_media_volumes_iterate`, so the ray passes can read them with no binding of their
+  own. `GPUSceneVolumetrics` takes that table in its constructor and no longer has `table` or
+  `metadata_buffer`; the froxel media build and far-field scattering passes bind `scene_database`
+  instead of `scene_volumes` and `scene_volumetrics_metadata`.
+
+### Shadows: the cascade count is a runtime setting
+
+`Renderer.shadow_cascade_count` (default 3) sets how many cascades a directional light's shadow map is
+split into, and may change at any time. A change rebuilds every directional map with the new count in
+the same frame; for the two frames its caster range takes to be measured again, a rebuilt map's near
+planes are its view slices' own, so casters between the light and a slice can drop out of it. The count
+does not change a cascade's resolution — 1536 for every cascade, see "HZB mip 0" above — and every cascade
+is a rect in the shared shadow atlas, so a count the atlas cannot fit leaves the light unshadowed
+(with a console error each frame) rather than shrinking anything.
+
+- **Faster:** a shaded pixel reads a directional light's cascades one at a time, as it tests them,
+  instead of copying all of them out of the light database first. Measured on an RTX 4090 (Chrome,
+  D3D12) at 1898×926, `volumetrics_froxel`'s "Volume edge" view, eight paired rounds at three
+  cascades: deferred shading 217 → 80 µs, volumetrics lighting 63 → 52 µs — about 0.15 ms of a
+  2.5 ms frame — with the shadow maps and the picture unchanged.
+- **Fixed:** turning shadows off now frees the shadow records along with the maps, so no
+  `shadow_directional` record names cascade rows that have been given back.
+- **Breaking:** `SHADOWMAP_CSM_CASCADE_COUNT` is gone (`SHADOWMAP_CSM_DEFAULT_CASCADE_COUNT` is the
+  default). In the light database, `shadow_directional` is now a range — `{first_cascade,
+  cascade_count}` — over a new `shadow_cascade` table, one row per cascade holding its atlas rect, its
+  projection and its caster range (`CSM_CASCADE_STRUCT`); the `shadow_csm_caster_range` table and
+  `CSM_CASTER_RANGE_STRUCT` are gone, and `CSM_CASTER_RANGE_UNKNOWN` moved to `CSM_CASCADE_STRUCT.js`.
+  WGSL calling `shadowmap_csm_compute_cascade_blended` passes the database and the range instead of a
+  cascade array, and gets back `shadow_cascade` rows. `DirectionalLightShadowmap` takes its cascade
+  count in its constructor and names its rows by `first_cascade` (was `caster_row`);
+  `GPUSceneShadowmapContext.caster_range_table` is `cascade_table`.
+
+### The CPU particle system is removed
+
+`ParticleEffect` + `GPUParticleEmitterSystem` is meep's particle system. The CPU one it replaced —
+the `ParticleEmitter` component, `ParticleEmitterSystem` and the `particular` engine under them,
+deprecated since 3.22.0 and 3.30.0 respectively — is gone, with nothing left to read its data.
+
+- **Breaking: a save or level holding a `ParticleEmitter` no longer loads.** Its adapter and
+  upgrader are unregistered, and the binary format cannot skip a type it has no adapter for, so the
+  whole load fails with `No serialization adapter found for 'ParticleEmitter'` rather than dropping
+  the component. Re-author such content as `ParticleEffect` before upgrading.
+- **Removed:** `ParticleEmitter` and all of `engine/graphics/particles/particular/`;
+  `ParticleEmitterSystem`, its `ParticleExtension`, the `ParticleEmitterSystem3` alias and the
+  `GPUParticularRenderer` that drew it; `shader_particle_render.js`, the blended billboard pipeline
+  only that renderer used — so, as was already true of the GPU particles, nothing draws particles
+  under `ShadeTransparencyMode.MBOIT` or with transparency off; and the `Sprite` component with
+  `SpriteSystemPE` (deprecated in 3.33.0), whose only renderer was a one-particle emitter.
+- **Removed from `engine/animation`:** `shutdownParticleEmitter` and
+  `stopEmitterAndNotifyOnceFinished`, so `stopEntityAndNotifyWhenStopped` waits on trails and audio
+  only; `removeEntityGenericEffect` and `removeEntityWithMeshParticlesEffect`, which spawned legacy
+  smoke puffs; and `removeEntityWithEffect`'s `emitter` option — it still shrinks the entity away and
+  plays the sound, and spawns nothing.
+- **Moved, not removed**, since nothing about them is particular to particles:
+  `distribute_points_on_indexed_triangles` to `engine/graphics/geometry/`, `lut_to_sampler` to
+  `engine/graphics/texture/sampler/`, `MovingBoundingBox` to `core/geom/3d/aabb/`, and the
+  `RGB_LUT_INFERNO`, `RGB_LUT_TURBO`, `RGB_LUT_VIRIDIS` and `RGBA_LUT_HEATMAP_IR` colour maps to
+  `core/math/lookup/`. `ParameterLookupTable` already lived in `core/math/lookup/`; the re-exports at
+  its old particle path are gone.
+- **Editor:** both editor shells (`editor/prototypeEditorShell.js` and the scene editor) register
+  `GPUParticleEmitterSystem` in place of the CPU system. The "Particle Emitter" template is now
+  "Particle Effect" and places the particle editor's starter plume, and `ParticleEffect` entities
+  get the positioned marker and the entity-list icon. The legacy emitter's inspectors, its
+  emission-shape symbol and `ParticleEmitterRebuildProcess` are gone. There is no dedicated
+  `ParticleEffect` inspector yet; the reflection inspector shows its scalar fields.
+
+Migrating: register `new GPUParticleEmitterSystem(graphics, scene, assetManager)` — unlike the CPU
+system it takes the Shade scene its emitters are placed in — and author effects as `ParticleEffect`
+(`shade/renderer/particles/DESIGN.md`). An emitter with several layers becomes one entity per layer,
+since an effect has one texture and one rate; a one-shot (`emissionImmediate`) is
+`GPUParticleEmitterSystem#burst(entity, count)`.
+
+### Networking: smooth by default
+
+A game that wires `NetworkSession` the obvious way now renders smoothly at any display rate. Drawn at
+144 Hz on a 60 Hz step, the previous tree left 58% of drawn frames of a predicted player — and of
+everything on the host — not moving at all, then jumping a step; now no view stalls or doubles a
+frame on a clean link, with packets arriving the way a browser delivers them. The design is in
+`engine/network/SMOOTHNESS_DESIGN.md`, the summary in the network README's "Smooth by default".
+
+- **Breaking: `NetworkSession.tick(dt)` is deprecated and does nothing** (it warns once). The session
+  runs on the `EntityManager`'s fixed step — `entity_manager.update(dt)`, which the engine loop
+  already calls, drives it. Remove the call; code that drove a session without an engine loop must
+  call `entity_manager.update(dt)` instead. `tick_rate_hz`, when given, now sets the engine's
+  `fixedUpdateStepSize`; omitted, the session uses the engine's step.
+- **Behaviour change: what arrives from the network is applied as the next fixed step opens**, not
+  when the transport delivers it. A browser delivers packets whenever its event loop gets to them —
+  usually between a frame's render blend and its draw — and applying them there drew most client
+  frames unblended. Code (tests, mostly) that delivers packets and then reads the result must run a
+  step of the receiving engine in between. A transport's lost connection is reported in order after
+  the packets that preceded it. `connect()` for a peer id first takes whatever the id's previous
+  transport still held, so a reconnect is never refused by a drop that has not been read yet.
+- **Behaviour change: the session's timers run on the engine's frame time** — the render playout,
+  idle reaping and the grace window all advance with the `dt` given to `entity_manager.update`, not
+  with `performance.now()`. A paused engine pauses them; an engine driven by hand drives them.
+- **Replication says how each component is drawn, and how a client corrects it**, with two methods
+  and no optional parameters: `replicate_interpolated(C, interpoland, correction)` blends `C` with
+  the given `Interpoland`, its record layout and a Linear blend; `replicate_discrete(C, correction)`
+  shows each state as it lands. `correction` is a `Correction` (`network/correction`): how the
+  difference between the host's state and the prediction is compared and carried into the present.
+  Given: `HOST_VALUE_CORRECTION` (take the host's value, for what a client does not predict),
+  `POSE_CORRECTION` and `VELOCITY_CORRECTION` (`network/adapters`); a game writes its own for its
+  own components. For `Transform64`, `replicate_transform64(session)` in `network/adapters` is
+  `replicate_interpolated(Transform64, POSE_INTERPOLAND, POSE_CORRECTION)`. `replicate()` is
+  deprecated: it keeps its meaning (`replicate(C)` discrete, `replicate(C, adapter)` blended over the
+  component's replication layout), corrects by the host's value, and warns once. **Breaking:** a component blended
+  between ticks, by either, must have `copy(other)` — its simulated value is held with it while a
+  blend is drawn over it; held through the wire's layout, it came back rounded every step. The
+  interpolands of one session's components must have distinct type ids; `start()` checks.
+- **Behaviour change: networked entities are interpolated without being asked.** The session adds an
+  `InterpolationSystem` if the engine has none and attaches (or adapts) an `Interpolated` on every
+  networked entity, by role: the local fixed-step timeline on the host and for what a client owns,
+  the network's render-delayed playout for the rest.
+- **Behaviour change: an interpolated entity is simulated at the fixed step.** `InterpolationSystem`
+  now records and restores by itself, for every `Interpolated` entity, not only physics bodies: when a
+  step opens, every value a render blend displaced is put back — and so is anything written over the
+  blend since. A write between steps is a write to a drawn pose. To change the simulation between
+  steps, set `Interpolated.snap` (a teleport: shown at once, and blending resumes from it —
+  `PhysicsSystem.setPose` does this), or call `InterpolationSystem.restore()` (or
+  `session.normalize_if_dirty()`) first and write the truth. A render-rate read of an interpolated
+  `Transform64` returns the drawn pose. This was already the rule for interpolated physics bodies;
+  it is now the rule for every interpolated entity, and it is what keeps a render-phase writer
+  (`ClingToTerrainSystem` on a blended pose) from leaking the blend's lag into the simulation.
+  `PhysicsSystem.interpolationLog` is deprecated and ignored (warns once); remove the assignment.
+- **Breaking: the blend fraction is passed in an array.** `BinaryInterpolationAdapter.interpolate(
+  out_buffer, source, first_offset, second_offset, blend, blend_offset)` reads it at
+  `blend[blend_offset]`, and `InterpolationLog.interpolate` takes the same `blend, blend_offset` pair
+  where it took `t`. As a number it crossed both calls boxed, 16 bytes a body every frame. An adapter
+  of your own starts with `const t = blend[blend_offset];`.
+- **Behaviour change: clients reconcile by comparison** (`reconcile: 'correct'`, default): the host's
+  state for frame S against the prediction for S; a component that differs is carried into the
+  present by its `Correction` — a pose by its offset, turn in the body's own frame and scale ratio,
+  hidden by a decaying render offset. Pass `reconcile: 'replay'` for the previous rewind + replay. A
+  client now predicts with each sampled input as the host will apply it, after the wire's rounding.
+  New: `correction_count`, `correction_skipped_count`, `onCorrection(entity, frame, component_class,
+  magnitude)`.
+- **Behaviour change: a client sends no input until its host has said which world the client is
+  in.** Each `connect()` holds the client's action stream until the host answers: a
+  `RESUME_ACCEPT` releases all of it, input predicted while cut off included, as before; an
+  `INITIAL_SYNC` drops everything predicted before it, and the client's input starts at the frame
+  the sync sets its counter to — on that connection and on any later one that resumes the same
+  world. A host that resynced a client used to apply the input the client had predicted, while cut
+  off, on the world the snapshot replaced — late and all at once, carrying the player on from where
+  the snapshot had just put it — and a predicting client's first input, sampled before its first
+  sync on a world of its own, cost it a correction as it joined. The wire is unchanged. See the
+  network README's "Connecting, and coming back".
+- **Fixed: a peer could make the host send it the whole world every tick.** The host answered every
+  `RESUME_HELLO`, and answered one claiming a session it held no record of — any connected peer can
+  send one — with a fresh `INITIAL_SYNC`. A small packet each tick kept the host serializing and
+  sending its world each tick: with 500 entities, some 600 times the bytes the peer sent. The host
+  now answers a connection's `RESUME_HELLO` once and ignores any later one on it (ignores, not
+  kicks: a datagram can arrive twice), and sends a connection its `INITIAL_SYNC`, copies against
+  loss included, once — when it takes the connection for a fresh peer, as it binds it or after
+  refusing its claim to resume — however many `RESUME_HELLO`s follow. So a client readmitted past
+  its grace gets the two copies a new one does, not the two more a reject used to add; and a
+  reconnect that lands on a connection the host still holds, rather than on a new one, is not sent
+  the world again. The wire is unchanged.
+- **Fixed: a peer could make the host re-send a fragmented message hundreds of times over.** A
+  `NACK_FRAGMENT` re-sent a chunk as often as it named it, and may name one 255 times; the host
+  answers three NACKs per message. With 500 entities, NACKs for the two `INITIAL_SYNC`s cost the host
+  about 340 times the bytes the peer sent, some 55 serialized worlds per connection. A NACK now
+  re-sends each chunk of the message at most once, and nothing for an index the message does not
+  have, so repair costs at most three copies of a message the host chose to send. The other way
+  round, a receiver asked for every chunk a fragment claimed its message had: one empty fragment
+  claiming 255 drew a NACK for 254 each round, some fifty times its size. A NACK now asks for no more
+  chunks than its message has delivered; a message that has lost more than that is asked for the
+  rest over the following rounds. A chunk that is really lost is still asked for and re-sent. The
+  wire is unchanged.
+- **Behaviour change: the host publishes what its simulation changed** at the end of each step
+  (`publish_changes: true`, default) and applies late input in the current frame instead of rolling
+  back (`late_input: 'apply'`, default; `'rollback'` restores it). Publishing never writes the wire's
+  quantised value back into the host's state, and sends nothing an action already carried.
+- **Breaking: peer ids are `[0, 252]`.** 253 is now `SENDER_RECORDED`, the provenance of a record
+  written by `SimActionExecutor.record()` — state published, not applied — which a rollback replay
+  carries over unchanged instead of dropping.
+- New: `System.openFixedStep()` / `closeFixedStep()` — phases bracketing each fixed step, for a system
+  that frames the step (the interpolation system settles, the network opens and closes its frame);
+  `NetworkSystem`'s `driver` (`open_step`, `close_step`, `frame`) for driving a bare `NetworkPeer` on
+  the engine's clock; `EntityManager.fixedStepTimeScale`; `InterpolationSystem.settle()`,
+  `restore()`, `correct()`, `allocateSourceId()`; `InterpolationLog.rewrite()`,
+  `latest_tick_at_or_before()`, `ensure_ticks()`; `ServerAuthoritativeServer.begin_tick()` /
+  `end_tick()`, `open_frame`, `onBeforeTickClose`, `late_input`; `ServerAuthoritativeClient.begin_tick()`
+  / `end_tick()`, `auto_reconcile`, `reconcile()`; `SimActionExecutor.record()`,
+  `on_component_written`; `SmoothingState.absorb_body_orientation_correction()`,
+  `render_body_orientation()`, `is_settled()`, time-paced `decay(entity, dt)`; `PredictionHistory`;
+  `DeferredTransport`; `LoopbackTransport.deliver_next()`; `NetworkPeer.hold_outbound()` /
+  `release_outbound()`.
+- Wire: a new `FRAME_MARKER` packet (type 13) replaces the client's empty per-tick keep-alive. Older
+  peers drop it as an unknown type; without it the host reads an input-less client's buffer depth
+  as zero and asks it to run fast.
+- Fixed: network writes to `Transform64` are announced (mesh placement follows only announced
+  transforms) — the network announces every in-place write through the component's replication
+  adapter, `BinaryClassSerializationAdapter.announce(dataset, entity)` (new; nothing by default), and
+  `TransformReplicationAdapter` announces a Transform64; a custom Transform64 wire adapter has to as
+  well; a record is never sent back to the peer it came from (a client echoed the host's
+  state back to it every tick, and the host applied it for client-owned entities); the playout no
+  longer starts one frame behind the stream; the network timeline holds across frames that carried
+  no change instead of showing the newest state early; an entity spawned during a fixed step is
+  interpolated from its birth tick (GAP-036); the interpolation system runs before pose readers such
+  as the camera;
+  an authoritative state arriving after a newer one no longer corrects the present a second time;
+  a resync no longer compares against predictions made for the world it replaced; a change the
+  simulation made after an action wrote the same component in that step is published; the
+  interpolation truth is held losslessly (not through a wire adapter's rounding); an entity id
+  reused within the log's history does not blend from the previous owner's records; a log grown past
+  its logical capacity keeps every tick; a scale difference is reconciled; the prediction comparison
+  tolerates Float32 rounding at any distance from the origin; an action whose `apply` throws leaves
+  neither a half-written record nor a half-applied write, and a listener that throws on a write's
+  announcement cannot leave the frame half-written; a host input that fails to apply is reported and
+  skipped instead of leaving the frame open, and a `begin_tick` that fails part-way closes the frame
+  it opened; a client that reconnects after its host's grace has run out is resynced once — the
+  `RESUME_REJECT` that can trail the host's snapshot no longer throws away the token the snapshot
+  issued (a link lost before the next copy arrived then cost the client its session) or reports a
+  second reconnection, and the copies of an `INITIAL_SYNC` the host sends against loss are no
+  longer applied over a world the client is already predicting on (a correction just after every
+  join and resync).
+
+- **Virtual geometry: a `deflate` page codec**, id `2` on the frame header — one bare raw DEFLATE
+  stream per page through native `CompressionStream`/`DecompressionStream`, no zlib or gzip
+  wrapper. It stores a container in fewer bytes than LZ4 — 1.369x against 1.295x over the pages of
+  a 240×120 torus — for about four and a half times the decode, 126 MB/s of decoded output against
+  562. `format_version` and `min_reader_version` are unchanged: a codec is a per-asset capability
+  gate, and a reader without a decoder for one refuses the asset rather than misreading it.
+- **Breaking default:** `VGeoBuildOptions.codec` and `VGeoWriteOptions.codec` are now
+  `VGEO_CODEC_DEFLATE`, so `vgeo_build` and `gltf_to_vgeo` write deflate unless told otherwise. A
+  build happens once and a fetch happens forever, so the denser side of the trade is what goes in
+  unasked. **A container converted from here on opens only in a reader carrying the deflate
+  decoder** — older readers refuse it cleanly rather than misreading it, but they do refuse it. Pass
+  `VGEO_CODEC_LZ4` or `--codec lz4` for a container whose pages arrive during play, where that
+  decode is a page's arrival cost rather than a build's. `codec_level` applies to LZ4 only and now
+  does nothing under the default codec.
+- **Async API change:** the platform offers its zlib only as a stream, so the virtual-geometry
+  functions that touch a page blob now return promises: `vgeo_build`, `vgeo_write_container`,
+  `vgeo_validate_container`, `vgeo_read_page`, `vgeo_encode_frame_blob` and
+  `vgeo_decode_frame_blob`. Await them. `VGeoContainerReader`, `VGeoPageFetcherCore` and the page
+  worker were already asynchronous and are unchanged at their own boundaries.
+- New in `core/binary/compression`: `compress_bytes` (the mirror of `decompress_bytes`),
+  `decompress_bytes_into` (decompresses into a buffer the caller owns and refuses a stream the
+  moment it would write past it — deflate reaches 1032:1, so checking a length afterwards is an
+  attacker-chosen allocation) and `deflate_decompress_bound`.
+- Replace the `pako` dependency with native `DecompressionStream` (Node >= 24 and browsers with
+  shipping WebGPU support).
+- **Async API change:** `PNGReader.parse()`, `decodeChunk()` and `decodePixels()`, `png_inflate`,
+  `png_chunk_decode_iTXt`, `png_chunk_decode_zTXt`, USD's `decode_png`, `ktx2_read`, and
+  `texel_data_from_ktx2` now return promises. Await their results and handle failures as rejections.
+  Keep input bytes unchanged and do not reuse a PNG reader until its operation settles. The image
+  worker and glTF loader retain their existing asynchronous interfaces.
+- PNG pixels retain their bad-Adler32 compatibility fallback. Compressed PNG metadata and KTX2
+  ZLIB levels remain strict. Native decoding also rejects trailing compressed-stream data and
+  gzip data supplied where the file format requires zlib.
+
+### Trails draw inside the transparency pipeline
+
+A `Trail3D` used to be blended over the finished frame after transparency had resolved, tested
+against the opaque scene alone — so a trail behind a transparent card, a glass pane or a cloud of
+smoke was drawn on top of it. It is now drawn through AVBOIT beside the transparent meshes and the
+GPU particles, and composites against both by depth, order-independently. Design and verification:
+the AVBOIT ledger, entry 22.
+
+- **Behaviour change: trails composite against transparency.** A trail is hidden and tinted by the
+  transparent surfaces and particles in front of it and hides what is behind it, within AVBOIT's own
+  limits (two surfaces in one depth slice blend rather than sort; a trail thinner than a voxel of the
+  1/8-resolution volume hides what is behind it by only about the share of the voxel it covers —
+  steadily, as it moves, not in blocks: its splat is multisampled and weighted by coverage, AVBOIT
+  ledger entry 24). Opacity is unchanged — both faces
+  of the tube still draw. Trails now also take the volumetric fog at their depth, which they did not
+  before. Fog of war covers them as it did.
+- **Behaviour change: what is drawn at `AfterTransparency` now lands over trails.** Trails used to be
+  the last content extension there; they are resolved before that phase now, so path display, the
+  selection highlight and the deprecated CPU `ParticleEmitterSystem` draw over a trail whatever its
+  depth, where they used to draw under it. The GPU particles, being in the pipeline with it, sort
+  against it properly.
+- **Behaviour change: trails are not drawn under `ShadeTransparencyMode.MBOIT`**, nor with
+  transparency off — the same as the GPU particles. MBOIT is the legacy mode.
+- **Cost:** a frame with a live trail runs the transparency pipeline even when nothing else in it is
+  transparent — its fixed passes (occupancy, warp, integration, resolve) where there used to be one
+  blended pass; of the order of 0.3 ms at 720p on light content (AVBOIT ledger, entry 17). A trail
+  also shares the pipeline's 128 depth slices with every transparent surface on screen, as an emitter
+  does: a long one spanning a deep range makes the slices coarser for all of them while it is in
+  view. One outside the view frustum costs nothing of either.
+- **Deprecated: `TrailExtension`** (`engine/graphics3/Trail3DSystem.js`) draws nothing and warns once
+  when constructed. It was the system's own `AfterTransparency` extension; nothing needs to register
+  it. Kept so that imports of it still link; the removal candidate for the next major.
+- New: `Renderer.add_transparency_channel(channel)`, `remove_transparency_channel(channel)` and
+  `transparency_channel_count()`, and the same three on `GraphicsEngine`, which holds channels across
+  a restart as it holds extensions. A channel is an `AVBOITSideChannel` — what an extension cannot be:
+  something drawn inside the transparency pipeline rather than over it. Registering one twice keeps
+  one. It may implement the new, optional `avboit_is_empty()`, and is left out of any frame in which it
+  says so; under MBOIT or with transparency off, channels are not consulted at all.
+- New: `DynamicMeshAVBOITChannel` (`shade/renderer/dynamic/`) draws a `DynamicMeshBatch` as such a
+  channel — straight alpha, unlit, fogged, depth-tested against the opaque scene and never written. It
+  owns the batch's GPU buffers: `release(geometry)` for a mesh gone for good, `destroy()` for all.
+- Fixed, on the way: dynamic-mesh GPU buffers are dropped and made again when the device changes. A
+  `GraphicsEngine` stopped and started under systems that keep running — an `Engine` with an external
+  `EntityManager` — used to go on writing and binding path display's, debug draw's and trails'
+  buffers made on the old device: a validation error that loses the frame's commands, on every frame
+  that had one of them to draw.
+- Internal: `GPUDynamicMeshRenderer`'s buffers and upload are `GPUDynamicMeshResidencyTable` now, and
+  its vertex pull is `chunk_dynamic_mesh_vertex`; the particle side channel's coverage clamp,
+  contribution routing, box depth interval and slice marking are shared chunks. These moves change
+  nothing on screen for path display, debug draw or the particles.
+
+### Rendering
+
+- **Fixed: AVBOIT striped transparent surfaces tilted away from the camera.** Over another transparent
+  layer such a surface occluded itself through the neighbouring voxel columns, by an amount that depended on
+  where each pixel sat in its voxel: an 8-pixel sawtooth, from about 30° at 1080p, 3–5 sRGB codes on the
+  device at 45–60°. The lookup now looks a voxel's width of the fragment's own depth change further toward
+  the camera (`avboit_footprint_bias`, capped at the coarsest slicing's bias); a tilted surface is not
+  occluded by what lies within that band in front of it, the depth the volume cannot tell from the surface
+  itself. AVBOIT ledger entry 26.
+- **Breaking (transparency channels):** a channel whose fragments splat into the volume adds
+  `avboit_footprint_bias` to its lookup: `avboit_sample_transmittance` and
+  `avboit_integral_depth_coordinate` take a `footprint_bias`, `0` for a fragment that writes nothing into
+  the volume.
+- **New:** the AVBOIT warp tries virtual resolutions between octaves, so the occupied slices fill more of
+  the budget: 1.28–1.43× finer depth slices on average where the warp halves, 1.68× in the bonfire, for
+  about a microsecond per resolution tried. `Renderer.avboit.warp_steps_per_octave`, 4 by default; 1
+  halves as before. AVBOIT ledger entries 27 and 29.
+- **Faster:** the AVBOIT warp build is one workgroup instead of one invocation, with subgroup reductions
+  and a subgroup scan for the LUT: 3–9 µs on an RTX 4090 where it took 22.5–136 µs (317 µs with
+  `warp_steps_per_octave` 4 over fragmented occupancy), bit-exact. AVBOIT ledger entry 28.
+- **Fixed: a soft particle standing on a floor occluded what was behind it while drawn faded.** The AVBOIT
+  splat read the soft fade at its voxel's top-left pixel; on a floor at a distance that pixel is a good part
+  of the fade range farther away, and the volume recorded up to 2.4× the coverage the draw used. It now
+  averages four reads over the voxel's footprint.
+- **Fixed: a view with nothing opaque to draw never cleared its depth or visibility buffer.** A scene
+  with no opaque and no alpha-tested geometry — an empty one, one holding only transparent surfaces,
+  one whose last mesh was just removed — drew over whatever the renderer's own targets last held,
+  since they outlive the frame. A removed mesh went on hiding what had stood behind it; solid dynamic
+  meshes (`GPUDynamicMeshRenderer.opaque`) failed the depth test against their own depth from two
+  frames earlier and vanished from the third frame on. Shadow maps rasterize the same way: a shadow
+  view with nothing to draw left its rectangle of the atlas as it found it, and a point light's cube
+  faces as the texture pool handed them over. Such a view now costs one clear, where its first draw
+  would have cleared.
+- **Breaking: `GPUDynamicMeshRenderer.graph_draw` returns `{ color, depth }`**, not the colour handle.
+  An extension publishes both: `scene.color = drawn.color; view.depth = drawn.depth;`
+  (RENDERER_CONTRACT §6). With `opaque` set the pass writes the scene depth, and when only the colour
+  came back, every later reader of `ViewTextures.depth` read a version the draw had superseded —
+  depth of field, motion blur, the NSS upscaler, the next extension. A development build refused
+  such a frame at compile. With `opaque` left false the depth comes back as it went in, and
+  publishing it changes nothing.
+- **Faster: a `DynamicMesh` draw costs a fraction of what it did on the CPU.** Each draw used to take
+  a transient uniform buffer, a copy and a bind group of its own every frame — twice over for a trail,
+  whose AVBOIT splat and draw each made their own. The draws' constants now go up as a table: one
+  transient buffer and one write per 1,024 draws, sized to one of five classes so that a mesh count
+  changing every frame does not keep making buffers, and read by both AVBOIT passes. A draw names its
+  row by its `first_instance` and binds its geometry's group, which lasts until the geometry outgrows
+  its buffers. Every row is still written every frame. Measured with 1,500 animated meshes at
+  1280×720 on an RTX 4090, stripped of asserts, paired, CPU per frame: 4.3–4.6 ms to 1.3–1.4 opaque,
+  4.1–4.9 to 1.3 blended, 9.8–11.4 to 2.0–2.5 through AVBOIT; 5,000 blended meshes, 20 ms to 2.2–2.4;
+  50, about the same (0.82–1.00 of before). The pictures are bit-identical. No change in the GPU's
+  time on the passes could be seen past the per-run noise of its clocks.
+- **Breaking, for anything that builds its own pipeline on `DYNAMIC_MESH_RESOURCES` or draws a
+  `GPUDynamicMeshResidency` itself:** the resources are two groups, `DYNAMIC_MESH_BIND_GROUP_DRAWS`
+  (`camera`, and `draws`, the table) and `DYNAMIC_MESH_BIND_GROUP_GEOMETRY` (`vertices`,
+  `indices`). `dynamic_mesh_vertex` and `dynamic_mesh_avboit_vertex` take the draw's row after the
+  vertex index — pass them `@builtin(instance_index)`. The AVBOIT splat's and draw's own groups moved
+  up one: `DYNAMIC_MESH_AVBOIT_SPLAT_BIND_GROUP_PASS` is 2, `DYNAMIC_MESH_AVBOIT_SPLAT_BIND_GROUP_VOLUME`
+  3, `DYNAMIC_MESH_AVBOIT_DRAW_BIND_GROUP_PASS` 2. `GPUDynamicMeshResidency.create_bindings` is gone,
+  and its `draw` takes the draw's row where it took the bind groups. `GPUDynamicMeshDrawList` writes
+  and draws a frame's meshes.
+- New: `GraphicsContext.setPipelineBindGroup`, which sets one group of a pipeline's layout and leaves
+  the others.
+- `SoftwareGPURenderPassEncoder` records where a direct draw starts: `first_vertex` and
+  `first_instance` for `draw`; `first_index`, `base_vertex` and `first_instance` for
+  `drawIndexed`. It used to drop them.
+
+## 4.0.0
+
+**The legacy `SoundEmitter` audio path is retired.** sopra had already been the only renderer for a
+while; what remained was a data model and the translation layer that fed it. Both are gone, and the
+native `AudioEmitter` path is the one the engine registers, serializes, edits and converts into.
+
+### Removed
+
+- **`SoundEmitterSystem`** and `SoundEmitterComponentContext`, **`SoundControllerSystem`**,
+  `loadSoundTrackAsset`, and the editor's `SoundEmitterSymbolicDisplay`.
+- **`SoundEmitterChannels`** — replaced by `SopraDefaultBus`, whose ids are identical
+  (`effects`/`music`/`ambient`, plus `master`). The deprecated `get/setChannelVolume` proxies go with
+  the system; they were 1-line forwards to `sopra.getBusVolume`/`setBusVolume`, which is now the
+  place to read and write a channel's volume.
+- **`SoundEmitter.fadeOutAllTracks` / `stopAllTracks`**, `SoundTrack.on.ended`, the live `time`
+  seek, `setVolumeOverTime`, and both throwing `nodes` getters.
+- **`createSound({track})`** — the legacy `SoundTrack` input. Pass `{url}` or `{event}`.
+
+### Moved
+
+- `SoundEmitter`, `SoundTrack` and `SoundController` — with the v2 adapter and both upgraders — from
+  `engine/sound/ecs/emitter/` and `engine/sound/ecs/` to **`engine/sound/sopra/legacy/`**. They are
+  now frozen, data-only readers: no system links them and nothing plays them. They stay registered in
+  `populateEngineSerializationRegistry` so that saves written before this release still deserialize.
+
+### Added
+
+- **`Renderer.transparency_mode`** and `ShadeTransparencyMode` — selects between the moment-based OIT
+  (`MBOIT`, the previous default) and the new adaptive voxel-based OIT (`AVBOIT`, Drobot SIGGRAPH 2025, now
+  the default) in
+  `shade/renderer/rasterize/native/avboit/`: extinction splatted into a 1/8-resolution voxel volume whose
+  depth axis is adaptively packed onto 128 slices, integrated into a 3D transmittance lookup. Depth-complexity
+  invariant, filters the background per channel for transmissive materials (opt-in through
+  `Renderer.avboit.transmission_tint_from_base_color`), needs no `float32-blendable`. Plan and ledger sit
+  next to the code.
+- **`AudioEventTrigger`** + `AudioEventTriggerSystem` — plays authored events in response to entity
+  events, the native replacement for `SoundController`.
+- **`AudioEmitter.on.ended`** — fires when a direct one-shot finishes on its own, so entity builders
+  can react to a sound ending without reaching into the system.
+- **`convertLegacySoundComponents(dataset, {knownBusIds})`** in `engine/sound/sopra/legacy/` — turns
+  loaded `SoundEmitter`/`SoundController` components into `AudioEmitter`/`AudioEventTrigger`.
+- `AudioEmitter` and `AudioEventTrigger` serialization, registered in the engine registry (which now
+  also populates the sopra and acoustic definition types).
+- An `AudioEmitter` symbolic display and positioned marker in the editor.
+- A graceful-shutdown handler for `AudioEmitter` in `hideEntityGracefully`, and
+  `stopAudioEmitterAndNotifyOnceFinished` in `AnimatedActions`.
+
+### Renamed
+
+- **The transition-era `3` suffix is dropped from every graphics system and from the engine facade.**
+  It marked the 2.x → 3.x renderer port and disambiguated against 2.x classes that no longer exist,
+  so it had stopped distinguishing anything. `GraphicsEngine3` → `GraphicsEngine`; and
+  `AnimationGraphSystem3`, `AnimationSystem3`, `CameraSystem3`, `DebugDrawSystem3`, `DecalSystem3`,
+  `FogOfWarSystem3`, `HighlightSystem3`, `LightSystem3`, `MeshSystem3`, `ParticipatingMediaSystem3`,
+  `ParticleEmitterSystem3`, `PathDisplaySystem3`, `PickingSystem3`, `ShadedGeometrySystem3`,
+  `TerrainSystem3`, `TooltipComponentSystem3`, `Trail3DSystem3`, `VolumetricLightMapSystem3` and
+  `WaterSystem3` each lose theirs. Files move with the classes (`MeshSystem3.js` → `MeshSystem.js`).
+- **Nothing breaks in this release.** Every old module still exists and exports the old name as a
+  deprecated alias *of the same class object*, so `instanceof` and `EntityManager.getSystem` keep
+  working whichever spelling a caller uses. The aliases are the removal candidate for the next major.
+- The directory is **still `engine/graphics3/`**. Dropping its `3` would mean merging into
+  `engine/graphics/`, which is a different and still-live tree; that is a separate change.
+- `graphics3/TerrainSystem` and `ecs/terrain/ecs/TerrainSystem` now share a class name. They are
+  unrelated classes in unrelated modules and nothing imports both, but code that wants both has to
+  alias one.
+
+### Migrating
+
+1. Register `AudioEmitterSystem` and `AudioEventTriggerSystem` in place of `SoundEmitterSystem` and
+   `SoundControllerSystem`. Keep `SoundListenerSystem` — it is untouched by this change.
+   `AudioEmitterSystem` is now the single owner of the per-frame sopra tick and listener pose.
+2. Call `convertLegacySoundComponents(dataset, { knownBusIds: Object.values(SopraDefaultBus) })`
+   after deserializing a save or scene. Without it, loaded legacy components sit inert.
+3. Author new content as `AudioEmitter` (an `EventDescription` per emitter) or `AudioEventTrigger`
+   (rules of `{ startEvent, stopEvent, event }`). A random pick is a `RandomContainerAudioClip`,
+   looping is the clip's loop flag, per-sound volume is `gainDb`, the channel is `busId`.
+4. Swap `SoundEmitterChannels` imports for `SopraDefaultBus`, and channel-volume calls for
+   `getSystem(AudioEmitterSystem).sopra.getBusVolume`/`setBusVolume`.
+5. Drop the `3` from graphics system and `GraphicsEngine` imports (see **Renamed**). Optional in
+   this release — the old spellings still resolve — but they are deprecated.
+
+## 3.1.0
+
+**meep renders on WebGPU. three.js is gone.**
+
+The renderer is **Shade** — GPU-driven, meshlet-clustered, visibility-buffer deferred, clustered
+lighting. See [the renderer contract](src/shade/RENDERER_CONTRACT.md).
+
+Upgrading from 2.x is a breaking change with no compatibility layer. See
+[MIGRATION_2_TO_3.md](MIGRATION_2_TO_3.md).
+
+### Requirements
+
+- **WebGPU**, with `indirect-first-instance`, `float32-blendable`, ≥10 storage buffers per shader
+  stage and ≥32 colour-attachment bytes per sample. Below that the renderer refuses to start with a
+  message rather than degrading.
+- No WebGL fallback, no backend abstraction, no degradation tiers.
+
+### Removed
+
+- **three.js**, and the peer dependency on it. `@types/three` with it.
+- The WebGL renderer and everything only it reached: the forward+ stack, the compositor, frame
+  buffers and post effects, shadow maps, impostor bakers, three materials, the legacy fog of war and
+  glTF loader, the WebGL minimap, `WebGLRendererPool`, `WebGLContextMonitor`.
+- **v0/v1 mesh pipelines** — `Renderable`/`RenderSystem`, `Mesh`/`MeshSystem` — and
+  `MicronRenderPlugin`.
+- **`AnimationSystem`, `AnimationGraphSystem`, the `AnimationGraph` component**, and the ribbon trail
+  path (`Trail2DSystem`, `RibbonX`).
+- **`LightSystem`, `CameraSystem`**, the legacy `ParticleEmitterSystem`.
+- meep's **lightmap, LPG and LPV bake pipelines** and the material-injection layer under them.
+- **DDS and DRACO** support.
+- The **three-material apparatus** — `engine/asset/loaders/material`, `engine/graphics/material`.
+- **`TopoMesh`** and the topology structures around it.
+- The **attachment socket API** — `Attachment`, `AttachmentSystem`, `AttachmentBinding` and its two
+  subclasses, `AttachmentSockets`/`AttachmentSocket`/`BoneAttachmentSocket`/`AttachmentSocketType`,
+  `AttachmentSocketsAssetLoader` and `GameAssetType.AttachmentSockets`. It predated
+  `TransformAttachment` and duplicated it for the non-bone case. The editor's socket gizmo goes with
+  it.
+- The **`Timer` component and `TimerSystem`**, along with `Timer.createTimeoutPromise`. Superseded by
+  `BehaviorSystem`: `DelayBehavior` waits, `ActionBehavior` fires, `DieBehavior` cleans up.
+  `createTimer` keeps its signature and is built on those.
+- **`gl-matrix`** as a dependency.
+- Declaration files are no longer tracked or shipped in the source tree. `npm run generate-types`
+  emits them into `publish/src`.
+
+### Changed
+
+- `GraphicsEngine` → **`GraphicsEngine3`**. The facade is narrow: no `layers`, no
+  `getMaterialManager()`, no renderer camera object.
+- `Mesh` (v1) → **`SGMesh`**. Level binaries carrying the old component were converted; `Mesh.opacity`
+  does not come across.
+- A model file expands into **entities** — `ShadedGeometry` on the nodes that draw — rather than
+  living as a tree inside a component.
+- `Renderer.add_pass` / `remove_pass` → **render extensions**: a declared phase, declared ordering,
+  and typed per-frame records.
+- Bone and socket positions come from **`query_entity_node_world_pose`**, not from a skeleton.
+- Picking is **async and batched** (`PickingQuery`); there is no synchronous entry point.
+- `stats.js` is used by its own name rather than through three's copy.
+- The renderer selection switch is gone — there is one renderer.
+
+### Added
+
+- **Shade**, vendored into `src/shade/`: meshlet geometry, GPU scene database, GPU animation and
+  skinning, clustered lighting, ReSTIR DI, brick4 volumetric GI, virtual geometry (`.vgeo`), virtual
+  textures, TAA/NSS upscaling, dynamic resolution scaling, a path tracer.
+- A **validating software GPU device** (`src/shade/device/mock/`) and a WGSL interpreter, so shader
+  and pipeline behaviour is testable in node without a GPU.
+- **`RENDERER_CONTRACT.md`** — the renderer's public surface, written down for the first time.