lecodes-sdk 0.20.2 → 1.0.0

package/dist/global.d.ts

@@ -28,11 +28,13 @@ declare global {
   const Color: typeof SDK.Color
   const DateValue: typeof SDK.DateValue
   const DecalSet: typeof SDK.DecalSet
+  const DecalTrail: typeof SDK.DecalTrail
+  const DynamicBone: typeof SDK.DynamicBone
+  const DynamicBoneCollider: typeof SDK.DynamicBoneCollider
   const Feet: typeof SDK.Feet
   const File: typeof SDK.File
   const FollowPath: typeof SDK.FollowPath
   const FormData: typeof SDK.FormData
-  const Gearbox: typeof SDK.Gearbox
   const Geolocation: typeof SDK.Geolocation
   const Geometry: typeof SDK.Geometry
   const Gizmos: typeof SDK.Gizmos
@@ -108,6 +110,7 @@ declare global {
   const Tilemap: typeof SDK.Tilemap
   const Tileset: typeof SDK.Tileset
   const Time: typeof SDK.Time
+  const Tire: typeof SDK.Tire
   const TouchStartEvent: typeof SDK.TouchStartEvent
   const Trail: typeof SDK.Trail
   const Trigger: typeof SDK.Trigger
@@ -200,6 +203,7 @@ declare global {
   const registerEditorTool: typeof SDK.registerEditorTool
   const registerEditorWindow: typeof SDK.registerEditorWindow
   const registerFont: typeof SDK.registerFont
+  const resolveTire: typeof SDK.resolveTire
   const resumeAnimation: typeof SDK.resumeAnimation
   const rot180: typeof SDK.rot180
   const rot270: typeof SDK.rot270
@@ -267,9 +271,16 @@ declare global {
   type DecalSet = SDK.DecalSet
   type DecalSetOptions = SDK.DecalSetOptions
   type DecalSpawnOptions = SDK.DecalSpawnOptions
+  type DecalTrail = SDK.DecalTrail
+  type DecalTrailOptions = SDK.DecalTrailOptions
   type DifferentialMode = SDK.DifferentialMode
   type Displacement = SDK.Displacement
   type DriveLayout = SDK.DriveLayout
+  type DynamicBone = SDK.DynamicBone
+  type DynamicBoneCollider = SDK.DynamicBoneCollider
+  type DynamicBoneColliders = SDK.DynamicBoneColliders
+  type DynamicBoneCurve = SDK.DynamicBoneCurve
+  type DynamicBoneFloor = SDK.DynamicBoneFloor
   type EchoParams = SDK.EchoParams
   type EdgeSlot = SDK.EdgeSlot
   type EditorApi = SDK.EditorApi
@@ -292,7 +303,6 @@ declare global {
   type Gait = SDK.Gait
   type GamepadAxisName = SDK.GamepadAxisName
   type GamepadState = SDK.GamepadState
-  type Gearbox = SDK.Gearbox
   type GeoOptions = SDK.GeoOptions
   type GeoPosition = SDK.GeoPosition
   type GeoWatch = SDK.GeoWatch
@@ -407,6 +417,7 @@ declare global {
   type PlayOptions = SDK.PlayOptions
   type PlaySoundOptions = SDK.PlaySoundOptions
   type Playback = SDK.Playback
+  type Point = SDK.Point
   type PresentOptions = SDK.PresentOptions
   type Presentable = SDK.Presentable
   type PushEvent = SDK.PushEvent
@@ -460,6 +471,8 @@ declare global {
   type StateMachineEvents = SDK.StateMachineEvents
   type StatesDef<C> = SDK.StatesDef<C>
   type SteeringConfig = SDK.SteeringConfig
+  type SteeringDriver = SDK.SteeringDriver
+  type SteeringFeedback = SDK.SteeringFeedback
   type StepHandler = SDK.StepHandler
   type StepWarpOptions = SDK.StepWarpOptions
   type StopOptions = SDK.StopOptions
@@ -485,13 +498,14 @@ declare global {
   type TilemapSourceDef = SDK.TilemapSourceDef
   type Tileset = SDK.Tileset
   type TilesetDef = SDK.TilesetDef
-  type TireCurve = SDK.TireCurve
+  type Tire = SDK.Tire
   type TouchStartEvent<T = any> = SDK.TouchStartEvent<T>
   type Trail = SDK.Trail
   type Transition = SDK.Transition
   type TransitionName = SDK.TransitionName
   type TransitionSpec = SDK.TransitionSpec
   type TransitionTransform = SDK.TransitionTransform
+  type TrianglePick = SDK.TrianglePick
   type Trigger = SDK.Trigger
   type Trigger2D = SDK.Trigger2D
   type UIBottomSheet = SDK.UIBottomSheet
@@ -546,8 +560,6 @@ declare global {
   type WebSocket = SDK.WebSocket
   type Wheel = SDK.Wheel
   type WheelSuspension = SDK.WheelSuspension
-  type WheelTire = SDK.WheelTire
-  type WheelVisual = SDK.WheelVisual
   type With<N, A extends Aspect<any, any, any>> = SDK.With<N, A>
   type __GizmoBuffer = SDK.__GizmoBuffer
   // ---- server globals (available in *.server.ts; using them in client code is a build error) ----

package/dist/types/canvas/Canvas.d.ts

@@ -56,6 +56,8 @@ export declare class Canvas {
     private _surfaceId;
     private _tex2d?;
     private _uiBound;
+    private _lastBakeLen;
+    private _warnedGrowth;
     constructor(width: number, height: number, opts?: {
         pixelRatio?: number;
     });

package/dist/types/gl/DecalSet.d.ts

@@ -24,6 +24,14 @@ export type DecalOptions = {
     fadeIn?: number;
     /** Seconds of fade at the end of `life` (ignored with life 0). Default 0. */
     fadeOut?: number;
+    /** Opacity multipliers at the image's BOTTOM and TOP edge (−Y / +Y), interpolated along it — a
+     *  tire mark that darkens as the slide deepens. Default `[1, 1]`. */
+    gradient?: [number, number];
+    /** Tilt of the image's bottom and top edge, as a unit-space slope (Δy per Δx across the box):
+     *  the edge pivots on the corner of the side it keeps and cuts INTO the box on the other, so two
+     *  boxes can meet on one shared line — what `DecalTrail` uses to mitre its joints. `0` = square.
+     *  Default `[0, 0]`. */
+    caps?: [number, number];
 };
 export type DecalSetOptions = DecalOptions & {
     /** The material — `Material.decal({ map })` by default (`map` below is its shortcut). A custom
@@ -51,8 +59,10 @@ export type DecalSetOptions = DecalOptions & {
     /** HDR boost of the image (0 = none). Default material only. */
     emissive?: number;
     name?: string;
-    /** Coarse draw order, 0 (first) … 7 (last); default 4 — see `Mesh.renderPriority`. Decals are
-     *  blended and sort with the other blended draws of their priority. */
+    /** Coarse draw order, 0 (first) … 7 (last) — see `Mesh.renderPriority`. Default 3: a decal is
+     *  part of the surface it sits on, so it draws before every other blended thing (meshes 4,
+     *  particles 5) — the engine's depth sort compares object centres, and a set spread over the
+     *  level has no useful centre. */
     renderPriority?: number;
 };
 /** `spawn` placement: where the image sits on the surface. */
@@ -99,5 +109,40 @@ export declare class DecalSet extends Node {
     remove(slot: number): this;
     clear(): this;
     private _writePlacement;
-    private _write;
+}
+/** A `DecalTrail`'s look: the strip's width, and what every segment carries. */
+export type DecalTrailOptions = Omit<DecalOptions, "size" | "caps" | "gradient"> & {
+    /** Width of the strip on the surface, world units. */
+    width: number;
+};
+/**
+ * A continuous strip of decals along a path — a tire's skid mark, a dragged body, a tread track.
+ * Feed it points (`add`) as the thing moves; every new point becomes one box-decal SEGMENT from the
+ * previous point, its image's up along the travel, and the joints between segments are MITRED: each
+ * box is cut along the bisector it shares with its neighbour (`caps`), so the strip has no overlaps
+ * darkening the outside of a bend and no wedges of gap on the inside. The opacity given with each
+ * point is interpolated along the segment (`gradient`), so a mark can darken as a slide deepens and
+ * fade as it ends. Segments are the set's decals — same ring, same `max` budget: a set of 900 holds
+ * 900 segments across every trail drawn from it.
+ *
+ * The previous segment is REWRITTEN when the next point arrives (its far cap becomes the shared
+ * mitre), through `DecalSet.update`'s path — a recycled slot is simply left alone by the engine.
+ */
+export declare class DecalTrail {
+    private _prev;
+    private _seg;
+    readonly set: DecalSet;
+    readonly options: DecalTrailOptions;
+    constructor(set: DecalSet, options: DecalTrailOptions);
+    /** Extend the strip to `point` on a surface with `normal`, `opacity` (0..1) at that point. The
+     *  first call after a start / `end()` only anchors the strip. Returns the new segment's slot, or
+     *  −1 when nothing was drawn (the anchor, a point that did not move, no host support). */
+    add(point: Vec3Like, normal: Vec3Like, opacity?: number): number;
+    /** Finish the strip. With a `point`, one last segment runs out to it at opacity 0 — a mark that
+     *  tapers away instead of stopping dead. The next `add` anchors a new strip. */
+    end(point?: Vec3Like, normal?: Vec3Like): this;
+    private _rewrite;
+    /** Write one segment's box: the strip between its joints, extended past each mitred joint by the
+     *  mitre's reach (w/2 · |slope|) so the tilted cap still passes through the joint's centre. */
+    private _box;
 }

package/dist/types/gl/Geometry.d.ts

@@ -25,6 +25,9 @@ export declare class Geometry {
     static box(size?: Vec3Like | number): Geometry;
     static sphere(options?: SphereOptions): Geometry;
     static cylinder(options?: CylinderOptions): Geometry;
+    /** A capsule along Y, centred at the origin: a cylinder `length` long (between the two cap centres)
+     *  with a hemisphere of `radius` on each end — one closed surface, smooth across the seams. */
+    static capsule(options?: CapsuleOptions): Geometry;
     static plane(options?: PlaneOptions): Geometry;
 }
 export type SphereOptions = {
@@ -32,6 +35,15 @@ export type SphereOptions = {
     widthSegments?: number;
     heightSegments?: number;
 };
+export type CapsuleOptions = {
+    radius?: number;
+    /** Distance between the two cap centres (the straight part); 0 = a sphere. Default 1. */
+    length?: number;
+    /** Segments around the axis. */
+    widthSegments?: number;
+    /** Rings per hemisphere (pole to equator). */
+    capSegments?: number;
+};
 export type CylinderOptions = {
     radius?: number;
     radiusTop?: number;

package/dist/types/gl/Lightmap.d.ts

@@ -27,6 +27,13 @@ export type LightmapLoadOptions = {
      *  and its underside does not — the same shading the atlas gives the statics. Before that the volume
      *  was one flat 0.5·E on every face and this knob was the workaround. Kept as a trim. */
     volumeBoost?: number;
+    /** What an OCCLUDER-only static (a prop without lightmap UVs — traced into the receivers' atlas but
+     *  carrying no rect of its own) does in real time. `"baked"` (default): its shadow is in the bake, so
+     *  it stops casting and the shadow pass draws only the movers — on a level of thousands of foliage
+     *  cards that is a third of the GPU frame. `"realtime"`: it keeps casting, which is the only way its
+     *  shadow reaches OTHER non-receiver props (a rock under a tree); the honest fix for that is lightmap
+     *  UVs on the props (`lecodes assets doctor --lightmap-uv`), which makes them receivers. */
+    occluderShadows?: "baked" | "realtime";
 };
 export type LightmapInfo = {
     size: number;
@@ -45,6 +52,8 @@ export type LightmapInfo = {
     applied: number;
     total: number;
     missing: string[];
+    /** Occluder-only statics whose real-time shadow was switched off (`occluderShadows: "baked"`). */
+    occluders: number;
 };
 export type LightmapFiles = {
     data: string;

package/dist/types/gl/Material.d.ts

@@ -159,6 +159,9 @@ export declare class Material {
      *  `metallicFactor`) plus `lightmap`, `lightmapST`, `ambientScale`, `sunStrength` (the sun / IBL terms come from
      *  filament's per-frame uniforms inside the shader). */
     static lightmap(): Material;
+    /** `Material.lightmap()`'s masked twin (`blending: masked`, same shader and parameters): what the engine
+     *  gives a lightmapped model's alpha-MASK materials. The cutoff comes from the glTF material. */
+    static lightmapMasked(): Material;
     /** The terrain splat material (docs/terrain-plan.md §1.5): four albedo (+ normal-map) layers blended by
      *  a control map on the terrain's own grid, per-layer `tiling` (metres per repeat) / `roughness` /
      *  `normalScale` / `triplanar`, lightmap-aware (the same `lightmap` / `lightmapST` block as
@@ -166,6 +169,7 @@ export declare class Material {
      *  unset layer is white and an unbaked terrain is fully lit. */
     static terrain(): Material;
     private static _lmTemplate;
+    private static _lmMaskedTemplate;
     static _lightmapShading: LightmapShading;
     /** Which shader lightmapped models take — a graphics-quality tier, engine-wide. `"full"` is filament's
      *  lit path over the baked atlas (IBL specular, real-time point lights such as a muzzle flash, sun

package/dist/types/gl/Mesh.d.ts

@@ -1,5 +1,5 @@
 import { type Vec3Like } from "../math/vec";
-import { Geometry, type CylinderOptions, type PlaneOptions, type SphereOptions } from "./Geometry";
+import { Geometry, type CapsuleOptions, type CylinderOptions, type PlaneOptions, type SphereOptions } from "./Geometry";
 import { Material } from "./Material";
 import { Node } from "./Node";
 /** Common transform/render options every primitive factory accepts. */
@@ -21,6 +21,10 @@ export declare class Mesh extends Node {
     /** Replace the geometry in place — the node, its transform and its material stay, the vertex and
      *  index buffers are rebuilt. What an editor overlay or a debug drawer redraws with. */
     setGeometry(geometry: Geometry): this;
+    private _renderPriority?;
+    private _culling?;
+    private _castShadows?;
+    private _receiveShadows?;
     /** A Mesh always carries a material (slot 0) — see Node.setMaterial for the slot API. */
     get material(): Material;
     set material(m: Material);
@@ -38,6 +42,8 @@ export declare class Mesh extends Node {
     }): Mesh;
     static sphere(options?: MeshOptions & SphereOptions): Mesh;
     static cylinder(options?: MeshOptions & CylinderOptions): Mesh;
+    /** A capsule along Y (`radius`, `length` between the cap centres) — a character's or a collider's shape in one mesh. */
+    static capsule(options?: MeshOptions & CapsuleOptions): Mesh;
     static plane(options?: MeshOptions & PlaneOptions): Mesh;
     /** Wrap a custom Geometry. */
     static from(geometry: Geometry, options?: MeshOptions): Mesh;

package/dist/types/gl/Model.d.ts

@@ -1,6 +1,34 @@
 import { type FetchResponse } from "../runtime/fetch";
 import { Node } from "./Node";
 import { Animator, type LodMode } from "./animation/Animator";
+/** One polygon under a screen point — what `Model.pickTriangle` returns. `bones` are the vertex's raw
+ *  JOINTS_0 / WEIGHTS_0 pairs (weight > 0; empty = unweighted), `bind` its position in mesh space,
+ *  `world` its skinned position this frame. */
+export interface TrianglePick {
+    /** the Model's root entity, and the mesh node's own entity (0 when the host has no entity for it) */
+    entity: number;
+    node: number;
+    nodeName: string;
+    mesh: string;
+    primitive: number;
+    material: string;
+    /** triangle index within the primitive (index-buffer order), and whether the ray came from behind */
+    triangle: number;
+    backface: boolean;
+    distance: number;
+    point: [number, number, number];
+    bary: [number, number, number];
+    skin: string;
+    vertices: {
+        index: number;
+        bind: [number, number, number];
+        world: [number, number, number];
+        bones: {
+            name: string;
+            weight: number;
+        }[];
+    }[];
+}
 export declare class Model extends Node {
     /** The model's Animator — always present, its clip table = the GLB's embedded clips. Configure
      *  more (external clips, blend spaces, layers) with `model.aspect(Animator, {...})`. */
@@ -31,6 +59,12 @@ export declare class Model extends Node {
     get lod(): LodMode;
     set lod(v: LodMode);
     private static _cullDefault;
+    /** DEBUG: the closest polygon of this model under a screen point (logical px — `Input.mouse.position`,
+     *  a touch event's clientX/Y), tested against the CPU-skinned CURRENT pose, both faces. Names the
+     *  triangle, its three vertices (bind + skinned positions) and their raw bone weights, so a stretched
+     *  or misbound polygon can be traced to its binding. One full CPU skin of the model per call: click-rate
+     *  only. null = miss, or a host without the pick (desktop today). */
+    pickTriangle(screenX: number, screenY: number): TrianglePick | null;
     /** Duplicate this model — a deep copy of the GLB (meshes, skeleton, animation clips), attached to
      *  the same parent and scene and sharing this model's current transform. The clone has its own
      *  independent animation state (reach it via clone.anim). Mirrors this model's culling flag. */

package/dist/types/gl/Particles.d.ts

@@ -116,6 +116,12 @@ type Noise = {
     strength?: number;
     frequency?: number;
     speed?: number;
+    /** How much of the displacement a particle earns with AGE (default 0 = all of it from birth).
+     *  The field is sampled by position, so at 0 every particle born at the same spot is pushed the
+     *  same way and a plume's root wanders off its emitter by up to `strength` metres; at 1 a particle
+     *  is born exactly where the emitter put it and drifts into the field over its life — what you
+     *  want whenever the source is visible (an exhaust pipe, a contact patch, a muzzle). */
+    ramp?: number;
 };
 /** Ground plane for bouncing particles (all render modes). `height` is in the simulation space:
  *  world y with `space: 'world'`, emitter-local y otherwise. */
@@ -169,6 +175,11 @@ export type ParticlesOptions = ParticlesMaterialOptions & {
      *  without this the engine picks who covers whom per frame (smoke popping over a fireball).
      *  Default 0; a fireball wants 2, its smoke 1, a smoke trail -1. */
     order?: number;
+    /** Coarse draw order among ALL blended draws, 0 (first) … 7 (last) — see `Mesh.renderPriority`.
+     *  Default 5: meshes sit at 4 and decals at 3, so smoke covers a car's glass and its skid marks
+     *  whatever the camera does (the engine's depth sort compares object centres, and an emitter's
+     *  centre says nothing about where its cloud is). `order` breaks ties inside one priority. */
+    renderPriority?: number;
     shape?: Shape;
     /** Extra velocity over life (radial burst that decays, axis drift) — see `VelocityOverLife`. */
     velocityOverLife?: VelocityOverLife;
@@ -212,6 +223,8 @@ export declare class Particles extends Node {
     set inheritVelocity(val: number);
     set rateOverDistance(val: number);
     set order(val: number);
+    /** Coarse draw order, 0 … 7 — see `Mesh.renderPriority`. Write-only. */
+    set renderPriority(v: number);
     set velocityOverLife(v: VelocityOverLife);
     set shape(shape: Shape);
     /** (mesh mode) Replace the particle mesh; live particles keep flying as the new shape. */

package/dist/types/gl/Scene.d.ts

@@ -4,7 +4,7 @@ import { Presentable, type PresentOptions } from "../ui/presentable";
 import type { ClickEvent, TouchStartEvent } from "../runtime/touch";
 import type { FetchResponse } from "../runtime/fetch";
 import { Camera } from "./Camera";
-import { SceneAudio } from "./SceneAudio";
+import { SceneAudio } from "./audio/SceneAudio";
 import { type ControlsHandle, type ControlsOptions } from "./controls";
 import { Material } from "./Material";
 import { Node } from "./Node";

package/dist/types/gl/animation/DynamicBone.d.ts

@@ -0,0 +1,173 @@
+import { Aspect } from "../../core/Aspect";
+import type { FieldMeta } from "../../core/fields";
+import { Vec3, type Vec3Like } from "../../math/vec";
+import { Node } from "../Node";
+/** One value for the chain, or `[root, tip]` interpolated down it by depth. */
+export type DynamicBoneCurve = number | readonly [root: number, tip: number];
+/** `'none'`, `'probe'` (a ray from the chain root down against the physics world, every frame), a
+ *  height (a horizontal plane at that world y) or a world point (a plane through it, `floorNormal` up). */
+export type DynamicBoneFloor = "none" | "probe" | number | Vec3Like;
+/** `'auto'` = every DynamicBoneCollider under the model; `'humanoid'` = those plus capsules generated
+ *  on the standard humanoid bones (hips, spine, head, limbs — the Ragdoll's layout); `'none'`; or the
+ *  nodes carrying the colliders to use. */
+export type DynamicBoneColliders = "auto" | "humanoid" | "none" | Node[];
+/** The cloth's OUTSIDE, which makes every collider one-sided: `'none'` = a collider pushes a bone to its
+ *  nearest surface (tails, ropes); `'auto'` = away from the root bone's own axis (a cloak's strips round a
+ *  spine face out from it); a vector = a fixed direction in the root bone's frame (a cape on the back:
+ *  `[0, 0, -1]`). With a side the body is under the cloth by definition: an arm that swung through the
+ *  cape pushes it away, and a bone that ended up inside a capsule leaves it on the outside — never
+ *  through it to be held against the chest from the wrong side. */
+export type DynamicBoneSide = "none" | "auto" | Vec3Like;
+/** A capsule (or a sphere) riding a bone — what dynamic bones stay out of. Attach to a body bone:
+ *  `hips.aspect(DynamicBoneCollider, { radius: 0.12, to: 'Spine' })`. The capsule runs from
+ *  `offset` (the bone's origin by default) to the `to` bone's origin, or to `end` (both in the bone's
+ *  local space); neither = a sphere at `offset`. Picked up by every DynamicBone on the same model
+ *  with `colliders: 'auto'` / `'humanoid'`, or listed explicitly. */
+export declare class DynamicBoneCollider extends Aspect<"dynamicBoneCollider", Node> {
+    static readonly aspect = "dynamicBoneCollider";
+    /** Radius in metres, in the world: the bone's scale does not touch it (`offset` / `end` are in the bone's own units). */
+    radius: number;
+    /** Start of the capsule in the bone's local space (default: the bone's origin). */
+    offset: Vec3Like;
+    /** End of the capsule in the bone's local space (a sphere when neither `end` nor `to` is set). */
+    end?: Vec3Like;
+    /** The bone the capsule reaches (its origin), instead of `end`. */
+    to?: string;
+    static fields: FieldMeta<DynamicBoneCollider>;
+    private _id;
+    private _segment;
+    onAttach(): void;
+    onReconfigure(): void;
+    onDetach(): void;
+}
+export declare class DynamicBone extends Aspect<"dynamicBone", Node> {
+    static readonly aspect = "dynamicBone";
+    /** Only these bones (by name) join the chain — the root always does, a bone left out takes its
+     *  subtree with it. Default: the root's whole subtree. */
+    bones?: string[];
+    /** Depth limit under the root (0 = no limit). */
+    depth: number;
+    /** Particle radius for the collisions, metres. */
+    radius: DynamicBoneCurve;
+    /** 0..1 — how fast a bone returns to the animated shape (per 1/60 s). 0 = a rope, 1 = rigid. */
+    stiffness: DynamicBoneCurve;
+    /** 0..1 — velocity lost per 1/60 s. 0.02 swings like a rope, 0.1 settles like a tail, 0.3 is honey. */
+    damping: DynamicBoneCurve;
+    /** m/s² downward. A hanging rest pose feels none of it (the bone length cancels it); a pose that
+     *  sticks out droops by as much as `stiffness` lets it. */
+    gravity: DynamicBoneCurve;
+    /** Max deviation from the animated direction, degrees per bone (0 = free). */
+    angleLimit: DynamicBoneCurve;
+    /** Relative mass per bone. A bone-length constraint moves its two ends in inverse proportion to
+     *  their masses (the root is kinematic): `[3, 1]` makes a tail's base carry its tip, `1` shares
+     *  evenly like a rope. */
+    mass: DynamicBoneCurve;
+    /** Bones (by name) that ride the animation exactly while their subtrees still simulate: a sheet's
+     *  several roots under one anchor (a cloak's seven strips under the spine), so ONE chain owns them all
+     *  and `link` ties neighbouring strips. */
+    pinned?: string[];
+    /** Metres a PINNED bone may be pushed off its animated place by a collider — a soft pin. Its particle
+     *  collides and takes the edge pushes like a free bone (the strip below hangs from where it IS) and is
+     *  drawn back to the animation when the collider leaves; the bone's local translation follows. A hard
+     *  pin (0) at a capsule's edge made the first free bone below it jitter: the edge push on a segment
+     *  with an immovable end is a lever, and a touch near the root threw the child out. 2–3 cm for a
+     *  cloak's roots under a shoulder capsule. */
+    pinGive: number;
+    /** 0..1 of the character's travel the chain takes rigidly (0 = the full whip on a dash, 1 = it
+     *  moves with the body and only the pose's own motion swings it). */
+    follow: number;
+    /** World wind, m/s². */
+    wind: Vec3Like;
+    /** The BODY'S TURN, ≥ 0. Above 0 the chain lives in the parent bone's ROTATING frame: `damping` acts
+     *  against the body's rigid motion (its travel plus its spin), so a heavily damped cloak RIDES a turn —
+     *  sweeps round with the back — instead of standing in the world while the character spins under it and
+     *  being dragged round after. The turn's inertia comes back as the frame's forces, scaled by this value:
+     *  a centrifugal push `ω² · r` along each bone's animated direction from the axis (the hem, farthest
+     *  from the spine, flies out and, on the chain's length, up). The frame's own physics is built in: the
+     *  whip back when the turn starts and forward when it stops, Coriolis. 1 = the physical push; more = a
+     *  bigger fling. With low damping the frame reproduces a free particle (nothing is counted twice);
+     *  an animation's spine sway is ~1 % of a 900°/s turn. A rotation over 90° in one frame (a respawn
+     *  facing) counts as a snap, not a spin. 0 = the plain translational frame, no turn forces. */
+    spin: number;
+    /** With `spin`: the cloth's INERTIA against the body's turn, seconds — the cloth's own rotation follows the
+     *  body's with this time constant. It falls behind when a turn starts (by about ω·τ: 45° at 900°/s and 0.05),
+     *  rides once caught up, and keeps turning past the back when the body stops (the same angle, eased out over
+     *  τ). Smooth by construction. 0 = glued to the turn; large = the cloth stays in the world while the body spins. */
+    spinInertia: number;
+    /** 0..1 strength of the ties between neighbouring columns at the same depth (a cloak). */
+    link: number;
+    /** 0..1 blend from the animation (0) to the simulation (1). At 0 nothing is simulated and the
+     *  chain re-arms on the animated pose when it comes back. */
+    weight: number;
+    /** Substep rate, Hz (≤ 4 substeps per frame). */
+    rate: number;
+    /** A root jump longer than this in one frame (metres) resets the chain instead of whipping it. */
+    teleport: number;
+    /** What the particles stay above: `'none'`, `'probe'`, a height, or a world point. */
+    floor: DynamicBoneFloor;
+    /** The floor plane's normal when `floor` is a point. */
+    floorNormal: Vec3Like;
+    /** Friction against the floor, a Coulomb coefficient: a resting bone's slide loses up to
+     *  `floorFriction · gravity · dt` of speed per substep (0 = ice, 1 = a rubber sole). While a bone
+     *  rests on the floor or a collider, `stiffness` and `angleLimit` let go of it: the surface's
+     *  reaction outranks the spring, or a hem folded on the floor would run away along it. */
+    floorFriction: number;
+    /** Constraint passes per substep (1..8, default 4). Each pass shares every bone length between its
+     *  ends, so a pull needs passes to travel down a long chain: a long rope may want 8, a short tail is
+     *  fine with 2. */
+    iterations: number;
+    /** What the chain collides with (see DynamicBoneColliders). */
+    colliders: DynamicBoneColliders;
+    /** The cloth's outside — makes the colliders one-sided (see DynamicBoneSide). */
+    side: DynamicBoneSide;
+    /** How firmly `guide()` targets are HELD through the constraint passes, 0..1. At 0 a guide is applied once
+     *  before the passes and the length / link passes may drag the bone back toward its un-guided neighbours
+     *  within the same frame; at 0.5 it is re-pulled after every pass with half its weight (converges with the
+     *  passes), at 1 with its full weight (a target the bone length cannot reach then jitters). */
+    guideHold: number;
+    /** The chain's EDGES collide with the capsules too — every bone segment and every link, not only the bones'
+     *  particles: a capsule thinner than a bone's length (a forearm) no longer passes through the cloth between
+     *  two bones. Off = particles only. */
+    edges: boolean;
+    static fields: FieldMeta<DynamicBone>;
+    private _id;
+    private _chain;
+    private _depths;
+    private _blob;
+    private _sent;
+    private _floorKey;
+    private _colliderKey;
+    private _collidersDirty;
+    private _collidersRef;
+    private _own;
+    private _colliderSet;
+    /** The bones of the chain, the root first. */
+    get chain(): readonly Node[];
+    onAttach(): void;
+    onReconfigure(): void;
+    /** Every field is live: what changed since the last frame is pushed here, before the engine's stage. */
+    update(): void;
+    onDetach(): void;
+    /** Snap the chain onto the animated pose next frame (a teleport, a camera cut). */
+    reset(): void;
+    /** GUIDES: world points the bones' particles are drawn to each substep before the constraints —
+     *  weight 1 = there before them, the rest of the chain hangs, collides and links as before (a cape's
+     *  strips riding the arms). Replaces the previous set; an empty list clears. A late-phase script
+     *  (after the animator, before the engine's chain stage) refreshes it every frame. */
+    guide(rows: readonly {
+        bone: Node;
+        at: Vec3Like;
+        weight: number;
+    }[]): void;
+    /** The particles' world positions (the bones, then the leaves' virtual tips) — for a debug draw. */
+    get particles(): Vec3[];
+    private _collect;
+    private _fill;
+    /** Neighbour links: the bones at the same depth, in tree order, tied pairwise. */
+    private _links;
+    private _sync;
+    private _pushFloor;
+    private _pushColliders;
+    /** Capsules on the standard humanoid bones, sized like the Ragdoll's parts. */
+    private _makeHumanoid;
+}

package/dist/types/gl/{IK.d.ts → animation/IK.d.ts}

@@ -1,7 +1,7 @@
-import { Aspect } from "../core/Aspect";
-import { type Vec3Like } from "../math/vec";
-import { Quat } from "../math/quat";
-import type { Node } from "./Node";
+import { Aspect } from "../../core/Aspect";
+import { type Vec3Like } from "../../math/vec";
+import { Quat } from "../../math/quat";
+import type { Node } from "../Node";
 type Target = Node | Vec3Like;
 /** Two-bone analytic IK (limbs). Attach to the END bone: `foot.aspect(IK.TwoBone, { target })`
  *  solves upper (grandparent) + mid (parent) so the end reaches `target`; `pole` steers the bend

package/dist/types/gl/{Locomotion.d.ts → animation/Locomotion.d.ts}

@@ -1,9 +1,9 @@
-import { Aspect } from "../core/Aspect";
-import { Vec3, type Vec3Like } from "../math/vec";
-import { Animator } from "./animation/Animator";
-import type { FeetOptions } from "./animation/Feet";
-import type { WarpOptions } from "./animation/Warp";
-import type { Node } from "./Node";
+import { Aspect } from "../../core/Aspect";
+import { Vec3, type Vec3Like } from "../../math/vec";
+import { Animator } from "./Animator";
+import type { FeetOptions } from "./Feet";
+import type { WarpOptions } from "./Warp";
+import type { Node } from "../Node";
 /** How fast the character wants to go: the gait picks its clips and its speed. */
 export type Gait = "walk" | "run" | "sprint";
 /** What the engine shows: the idle, a start, the gait loop, a turn while moving, a stop, or a turn on the spot. */

package/dist/types/gl/{AudioSource.d.ts → audio/AudioSource.d.ts}

@@ -1,9 +1,9 @@
-import { Aspect } from "../core/Aspect";
-import type { FieldMeta } from "../core/fields";
-import { type PlaySoundOptions, type Rolloff } from "../audio/audio";
-import type { Sound } from "../audio/Sound";
-import type { Voice } from "../audio/Voice";
-import type { Node } from "./Node";
+import { Aspect } from "../../core/Aspect";
+import type { FieldMeta } from "../../core/fields";
+import { type PlaySoundOptions, type Rolloff } from "../../audio/audio";
+import type { Sound } from "../../audio/Sound";
+import type { Voice } from "../../audio/Voice";
+import type { Node } from "../Node";
 export type AudioCone = {
     /** Degrees of full volume around the node's −Z. */
     inner: number;

package/dist/types/gl/{AudioZone.d.ts → audio/AudioZone.d.ts}

@@ -1,7 +1,7 @@
-import { Aspect } from "../core/Aspect";
-import { type ReverbParams, type ReverbPreset } from "../audio/Bus";
-import { type Vec3Like } from "../math/vec";
-import type { Node } from "./Node";
+import { Aspect } from "../../core/Aspect";
+import { type ReverbParams, type ReverbPreset } from "../../audio/Bus";
+import { type Vec3Like } from "../../math/vec";
+import type { Node } from "../Node";
 export declare class AudioZone extends Aspect<"audioZone", Node> {
     static readonly aspect = "audioZone";
     private _box;

package/dist/types/gl/{SceneAudio.d.ts → audio/SceneAudio.d.ts}

@@ -1,4 +1,4 @@
-import type { Node } from "./Node";
+import type { Node } from "../Node";
 export declare class SceneAudio {
     private _listener;
     private _doppler;

package/dist/types/gl/{NavAgent.d.ts → nav/NavAgent.d.ts}

@@ -1,8 +1,8 @@
-import { Aspect } from "../core/Aspect";
-import type { FieldMeta } from "../core/fields";
-import { Vec3, type Vec3Like } from "../math/vec";
+import { Aspect } from "../../core/Aspect";
+import type { FieldMeta } from "../../core/fields";
+import { Vec3, type Vec3Like } from "../../math/vec";
 import { NavCrowd } from "./NavMesh";
-import type { Node } from "./Node";
+import type { Node } from "../Node";
 export type NavAgentState = "idle" | "moving" | "arrived" | "blocked" | "offmesh";
 export type NavAgentAvoidance = "off" | "low" | "medium" | "high";
 export type NavAgentDrive = "position" | "controller";

package/dist/types/gl/{NavMesh.d.ts → nav/NavMesh.d.ts}

@@ -1,7 +1,7 @@
-import { System } from "../core/Aspect";
-import { Vec3, type Vec3Like } from "../math/vec";
-import type { Node } from "./Node";
-import type { Scene } from "./Scene";
+import { System } from "../../core/Aspect";
+import { Vec3, type Vec3Like } from "../../math/vec";
+import type { Node } from "../Node";
+import type { Scene } from "../Scene";
 export declare const NAV_AGENT: {
     readonly RADIUS: 0;
     readonly HEIGHT: 1;