lecodes-sdk 2.4.0 → 2.4.2

package/dist/types/core/Aspect.d.ts

@@ -25,8 +25,10 @@ export type With<N, A extends Aspect<any, any, any>> = N & UnionToIntersection<A
  * attach time, keyed by the aspect class's runtime `aspect` name.
  */
 export declare abstract class AspectHost<E extends EventMap = EventMap> extends Emitter<E> {
-    /** Attach (and configure) an aspect, or reconfigure it if already present. Returns the node typed
-     *  as now-having that aspect (so no guard/`?.` is needed afterwards). Rejects a wrong target node. */
+    /** Attach an aspect built from `opts` (a class already on the node is detached first and REBUILT
+     *  from exactly these options — a structural change; a live value is a property write on
+     *  `node.<accessor>`). Returns the node typed as now-having that aspect (so no guard/`?.` is
+     *  needed afterwards). Rejects a wrong target node. */
     aspect<Self extends TargetOf<A>, A extends Aspect<any, any, any>>(this: Self, ctor: AspectCtor<A>, opts?: Partial<A>): Self & FieldOf<A>;
     /** Safe access — undefined if the aspect isn't attached. */
     get<A extends Aspect<any, any, any>>(ctor: AspectCtor<A>): A | undefined;
@@ -107,9 +109,36 @@ export declare abstract class Aspect<K extends string, P = Node, E extends Event
     protected onAttach?(): void;
     /** Release what onAttach acquired. */
     protected onDetach?(): void;
-    /** Called after `node.aspect(Ctor, opts)` re-assigns options on an ALREADY attached aspect (a
-     *  pre-attached one like `model.anim`): rebuild whatever was derived from the options at attach. */
-    protected onReconfigure?(): void;
+    /**
+     * LIVE PROPERTIES. A value the engine must hear about is a get/set pair whose setter stores it and
+     * calls `this.dirty()`; `flush()` then runs ONCE before the next physics step — at the start of
+     * the early phase for a write made since the last frame, right after the early updaters for one
+     * made in an `updateBefore` — however many properties changed, one send. `node.aspect(Ctor, opts)`
+     * and the scene file write the same setters. Before attach a setter only stores (onAttach sends
+     * everything); after detach nothing flushes. A value with a bridge call of its own, or one whose
+     * result the caller reads back at once (a Shape's dimensions: `controller.resizing`), skips the
+     * batch and pushes from its setter.
+     *
+     *   get radius(): number { return this._radius }
+     *   set radius(v: number) { this._radius = v; this.dirty() }
+     *   protected flush(): void { _creator.thingSetTuning(this._id, this._settings()) }
+     */
+    protected dirty(): void;
+    /** Send what the setters changed — see `dirty()`. */
+    protected flush?(): void;
+    /**
+     * A nested config object as a LIVE VIEW: every key of `defaults` becomes an accessor whose setter
+     * stores and calls `this.dirty()`, so `wheel.suspension.stiffness = 2` reaches the engine like any
+     * live property. `value` is taken WHOLE: a key it leaves out is the default, nothing of a previous
+     * object survives (`wheel.suspension = { stiffness: 2 }` is stiffness 2 and the default travel and
+     * damping). Writing `undefined` to a key restores its default. One level deep: a value that is
+     * itself an object is replaced, not watched.
+     *
+     *   private _suspension = this.live(SUSPENSION_DEFAULTS)
+     *   get suspension(): WheelSuspension { return this._suspension }
+     *   set suspension(v: WheelSuspension) { this._suspension = this.live(SUSPENSION_DEFAULTS, v); this.dirty() }
+     */
+    protected live<T extends object>(defaults: T, value?: Partial<T>): T;
     /**
      * GENERATOR aspects: (re)build the derived output under `this.generated` — must be idempotent
      * (clear, then create). Call it from `onAttach()` for play mode; a class opting in with

package/dist/types/g2/OneWay2D.d.ts

@@ -19,6 +19,5 @@ export declare class OneWay2D extends Aspect<"oneWay", Node2D> {
     set enabled(v: boolean);
     onAttach(): void;
     onDetach(): void;
-    onReconfigure(): void;
     private _push;
 }

package/dist/types/g2/Physics2D.d.ts

@@ -28,10 +28,14 @@ export declare class Physics2D extends Aspect<"physics", Node2D> {
      *  Default "dynamic", and LIVE: freeze a crate into `'static'`, hand a ragdoll to `'dynamic'`. */
     get motion(): MotionType;
     set motion(m: MotionType);
-    /** Lock rotation (essential for platformer characters). */
-    fixedRotation: boolean;
-    /** Continuous collision for fast-moving bodies (projectiles). */
-    bullet: boolean;
+    private _fixedRotation;
+    /** Lock rotation (essential for platformer characters). Live. */
+    get fixedRotation(): boolean;
+    set fixedRotation(v: boolean);
+    private _bullet;
+    /** Continuous collision for fast-moving bodies (projectiles). Live. */
+    get bullet(): boolean;
+    set bullet(v: boolean);
     private _mass;
     private _friction;
     private _bounce;
@@ -63,8 +67,6 @@ export declare class Physics2D extends Aspect<"physics", Node2D> {
     get id(): number;
     onAttach(): void;
     onDetach(): void;
-    /** Re-applying options (`node.aspect(Physics2D, {…})`) pushes the live ones through. */
-    onReconfigure(): void;
     /** Linear velocity in world units/second (fresh Vec2 on read). */
     get velocity(): Vec2;
     set velocity(v: Vec2Like);

package/dist/types/g2/Scene2D.d.ts

@@ -53,7 +53,7 @@ export declare class Scene2D implements Presentable {
     /** class → instance, the authoritative store (named accessors mirror this). Kept in the public
      *  types: it is what makes a Scene2D a `SystemHost` there. */
     readonly _systems: Map<Function, Aspect<any, any, any>>;
-    /** Attach (and configure) a system, or reconfigure it if already present. Returns the scene typed
+    /** Build a system from `opts` (a class already on the scene is detached and built afresh). Returns the scene typed
      *  as now-having it (`scene.system(Hud).hud`). A 3D `System<'x'>` (target Scene) is rejected here. */
     system<Self extends TargetOf<A>, A extends Aspect<any, any, any>>(this: Self, ctor: AspectCtor<A>, opts?: Partial<A>): Self & FieldOf<A>;
     /** Safe access — undefined if the system isn't attached. */

package/dist/types/g2/Shape2D.d.ts

@@ -1,26 +1,48 @@
 import { Aspect } from "../core/Aspect";
+import type { FieldMeta } from "../core/fields";
 import { type Vec2Like } from "../math/vec";
 import type { Node2D } from "./Node2D";
 export declare class Shape2D extends Aspect<"shape", Node2D> {
     static readonly aspect = "shape";
+    private _box?;
+    private _circle?;
+    private _cap?;
+    private _segment?;
+    private _polygon?;
+    private _chain?;
+    private _loop?;
+    private _flip?;
+    private _origin?;
     /** Box half-extents [hw, hh] (world units). */
-    box?: Vec2Like;
+    get box(): Vec2Like | undefined;
+    set box(v: Vec2Like | undefined);
     /** Circle radius. */
-    circle?: number;
+    get circle(): number | undefined;
+    set circle(v: number | undefined);
     /** Capsule between two local points, with a radius. */
-    capsule?: {
+    get capsule(): {
         from: Vec2Like;
         to: Vec2Like;
         radius: number;
-    };
+    } | undefined;
+    set capsule(v: {
+        from: Vec2Like;
+        to: Vec2Like;
+        radius: number;
+    } | undefined);
     /** Thin segment (an edge) between two local points. */
-    segment?: {
+    get segment(): {
+        from: Vec2Like;
+        to: Vec2Like;
+    } | undefined;
+    set segment(v: {
         from: Vec2Like;
         to: Vec2Like;
-    };
+    } | undefined);
     /** Convex polygon, up to 8 local points (a convex hull is computed — a CONCAVE outline silently
      *  becomes its hull; use `chain` for those). */
-    polygon?: Vec2Like[];
+    get polygon(): Vec2Like[] | undefined;
+    set polygon(v: Vec2Like[] | undefined);
     /**
      * A polyline of connected segments — the one shape that expresses a long CONCAVE surface (rolling
      * terrain, a cave wall) in one piece, seam-free. Pass only the points that should be solid; the
@@ -30,22 +52,28 @@ export declare class Shape2D extends Aspect<"shape", Node2D> {
      * must not self-intersect. It is ONE-SIDED: solid on the right of the point order — walk the points
      * so that the solid material is on your right, or set `flip`.
      */
-    chain?: Vec2Like[];
+    get chain(): Vec2Like[] | undefined;
+    set chain(v: Vec2Like[] | undefined);
     /** `chain`: close the contour (an island / a room boundary). Needs at least 4 points. */
-    loop?: boolean;
+    get loop(): boolean | undefined;
+    set loop(v: boolean | undefined);
     /** `chain`: put the solid side on the other side of the line. */
-    flip?: boolean;
+    get flip(): boolean | undefined;
+    set flip(v: boolean | undefined);
     /** The collider's centre relative to the node, in world units. Applies to EVERY kind — it
      *  translates a capsule's / segment's / polygon's / chain's points too, unlike the old `offset`. */
-    origin?: Vec2Like;
+    get origin(): Vec2Like | undefined;
+    set origin(v: Vec2Like | undefined);
+    /** Scene-editor inspector: the geometry fields (accessors, so they are listed here by name). */
+    static fields: FieldMeta<Shape2D>;
     private _handle;
     onDetach(): void;
     /**
-     * Re-configuring the aspect swaps the fixture in place — same body, same id, same velocity, same
-     * position. Nothing happens when the geometry is unchanged, so re-applying the same options in a
-     * loop is free.
+     * A dimension was written: swap the fixture in place — same body, same id, same velocity, same
+     * position. Nothing happens when the signature is unchanged, so writing the same dimensions every
+     * frame is free.
      */
-    onReconfigure(): void;
+    private _changed;
     private _create;
     /**
      * Box2D's chain wants the two TANGENT points as extra entries and does not collide on its first or

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

@@ -34,8 +34,9 @@ export interface TrianglePick {
     }[];
 }
 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, {...})`. */
+    /** The model's Animator — always present, its clip table = the GLB's embedded clips. Add to it
+     *  with `model.anim.addClip(name, clip)` (external clips), `model.anim.addLayer()`; set its fields
+     *  (`model.anim.speed = 1.5`) — never `model.aspect(Animator, …)`, which would build a fresh one. */
     readonly anim: Animator;
     constructor(internalId: number | Handle);
     /** Does this model cast a real-time shadow? Unlike Mesh (one renderable) a GLB is a whole

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

@@ -194,7 +194,7 @@ export declare class Scene implements Presentable {
     /** class → instance, the authoritative store (named accessors mirror this). Kept in the public
      *  types: it is what makes a Scene a `SystemHost` there. */
     readonly _systems: Map<Function, Aspect<any, any, any>>;
-    /** Attach (and configure) a system, or reconfigure it if already present. Returns the scene typed
+    /** Build a system from `opts` (a class already on the scene is detached and built afresh). Returns the scene typed
      *  as now-having it (`scene.system(Hud).hud`). A `System<'x', Scene2D>` is rejected here. */
     system<Self extends TargetOf<A>, A extends Aspect<any, any, any>>(this: Self, ctor: AspectCtor<A>, opts?: Partial<A>): Self & FieldOf<A>;
     /** Safe access — undefined if the system isn't attached. */

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

@@ -27,23 +27,34 @@ export type DynamicBoneSide = "none" | "auto" | Vec3Like;
  *  with `colliders: 'auto'` / `'humanoid'`, or listed explicitly. */
 export declare class DynamicBoneCollider extends Aspect<"dynamicBoneCollider", Node> {
     static readonly aspect = "dynamicBoneCollider";
+    private _radius;
     /** 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;
+    get radius(): number;
+    set radius(v: number);
+    private _offset;
     /** Start of the capsule in the bone's local space (default: the bone's origin). */
-    offset: Vec3Like;
+    get offset(): Vec3Like;
+    set offset(v: Vec3Like);
+    private _end?;
     /** End of the capsule in the bone's local space (a sphere when neither `end` nor `to` is set). */
-    end?: Vec3Like;
+    get end(): Vec3Like | undefined;
+    set end(v: Vec3Like | undefined);
+    private _to?;
     /** The bone the capsule reaches (its origin), instead of `end`. */
-    to?: string;
+    get to(): string | undefined;
+    set to(v: string | undefined);
+    private _oneSided;
     /** ONE-SIDED: the cloth belongs on the chain's `side` of this capsule (see DynamicBone.side). While the capsule
      *  moves away from that side it puts a bone it has run into over to the side instead of carrying it — an arm
      *  under a cape may push the cape back, never drag it forward round the body. Needs a `side` on the DynamicBone. */
-    oneSided: boolean;
+    get oneSided(): boolean;
+    set oneSided(v: boolean);
     static fields: FieldMeta<DynamicBoneCollider>;
     private _id;
     private _segment;
     onAttach(): void;
-    onReconfigure(): void;
+    /** A field changed: re-describe the capsule to the engine. Every field is live. */
+    protected flush(): void;
     onDetach(): void;
 }
 export declare class DynamicBone extends Aspect<"dynamicBone", Node> {
@@ -51,43 +62,68 @@ export declare class DynamicBone extends Aspect<"dynamicBone", Node> {
     /** Whether this host simulates dynamic bones. False, never a throw, on Web Lite and in headless
      *  tests; there the aspect attaches, warns once, and `chain` stays empty. */
     static get supported(): boolean;
+    private _bones?;
     /** 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[];
+    get bones(): string[] | undefined;
+    set bones(v: string[] | undefined);
+    private _depth;
     /** Depth limit under the root (0 = no limit). */
-    depth: number;
+    get depth(): number;
+    set depth(v: number);
+    private _radius;
     /** Particle radius for the collisions, metres. */
-    radius: DynamicBoneCurve;
+    get radius(): DynamicBoneCurve;
+    set radius(v: DynamicBoneCurve);
+    private _stiffness;
     /** 0..1 — how fast a bone returns to the animated shape (per 1/60 s). 0 = a rope, 1 = rigid. */
-    stiffness: DynamicBoneCurve;
+    get stiffness(): DynamicBoneCurve;
+    set stiffness(v: DynamicBoneCurve);
+    private _damping;
     /** 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;
+    get damping(): DynamicBoneCurve;
+    set damping(v: DynamicBoneCurve);
+    private _gravity;
     /** 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;
+    get gravity(): DynamicBoneCurve;
+    set gravity(v: DynamicBoneCurve);
+    private _angleLimit;
     /** Max deviation from the animated direction, degrees per bone (0 = free). */
-    angleLimit: DynamicBoneCurve;
+    get angleLimit(): DynamicBoneCurve;
+    set angleLimit(v: DynamicBoneCurve);
+    private _mass;
     /** 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;
+    get mass(): DynamicBoneCurve;
+    set mass(v: DynamicBoneCurve);
+    private _pinned?;
     /** 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 — neighbours in THIS order, so list the strips round the ring
      *  (front-left … back … front-right); the front stays open. */
-    pinned?: string[];
+    get pinned(): string[] | undefined;
+    set pinned(v: string[] | undefined);
+    private _pinGive;
     /** 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;
+    get pinGive(): number;
+    set pinGive(v: number);
+    private _follow;
     /** 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;
+    get follow(): number;
+    set follow(v: number);
+    private _wind;
     /** World wind, m/s². */
-    wind: Vec3Like;
+    get wind(): Vec3Like;
+    set wind(v: Vec3Like);
+    private _spin;
     /** 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
@@ -98,47 +134,74 @@ export declare class DynamicBone extends Aspect<"dynamicBone", Node> {
      *  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;
+    get spin(): number;
+    set spin(v: number);
+    private _spinInertia;
     /** 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;
+    get spinInertia(): number;
+    set spinInertia(v: number);
+    private _link;
     /** 0..1 strength of the ties between neighbouring columns at the same depth (a cloak). */
-    link: number;
+    get link(): number;
+    set link(v: number);
+    private _weight;
     /** 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;
+    get weight(): number;
+    set weight(v: number);
+    private _rate;
     /** Substep rate, Hz (≤ 4 substeps per frame). */
-    rate: number;
+    get rate(): number;
+    set rate(v: number);
+    private _teleport;
     /** A root jump longer than this in one frame (metres) resets the chain instead of whipping it. */
-    teleport: number;
+    get teleport(): number;
+    set teleport(v: number);
+    private _floor;
     /** What the particles stay above: `'none'`, `'probe'`, a height, or a world point. */
-    floor: DynamicBoneFloor;
+    get floor(): DynamicBoneFloor;
+    set floor(v: DynamicBoneFloor);
+    private _floorNormal;
     /** The floor plane's normal when `floor` is a point. */
-    floorNormal: Vec3Like;
+    get floorNormal(): Vec3Like;
+    set floorNormal(v: Vec3Like);
+    private _floorFriction;
     /** 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;
+    get floorFriction(): number;
+    set floorFriction(v: number);
+    private _iterations;
     /** 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;
+    get iterations(): number;
+    set iterations(v: number);
+    private _colliders;
     /** What the chain collides with (see DynamicBoneColliders). */
-    colliders: DynamicBoneColliders;
+    get colliders(): DynamicBoneColliders;
+    set colliders(v: DynamicBoneColliders);
+    private _side;
     /** The cloth's outside — makes the colliders one-sided (see DynamicBoneSide). */
-    side: DynamicBoneSide;
+    get side(): DynamicBoneSide;
+    set side(v: DynamicBoneSide);
+    private _guideHold;
     /** 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;
+    get guideHold(): number;
+    set guideHold(v: number);
+    private _edges;
     /** 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;
+    get edges(): boolean;
+    set edges(v: boolean);
     static fields: FieldMeta<DynamicBone>;
     private _id;
     private _chain;
@@ -154,9 +217,10 @@ export declare class DynamicBone extends Aspect<"dynamicBone", Node> {
     /** 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;
+    /** Every field is live: a write marks the chain dirty and what changed is pushed here, once, before
+     *  the next step (the floor and the collider list are each keyed, so a point written every frame
+     *  costs one compare). */
+    protected flush(): void;
     onDetach(): void;
     /** Snap the chain onto the animated pose next frame (a teleport, a camera cut). */
     reset(): void;

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

@@ -21,7 +21,6 @@ declare abstract class Chain<Name extends string> extends Aspect<Name, Node> {
     get error(): number;
     onAttach(): void;
     onDetach(): void;
-    onReconfigure(): void;
     protected params(): Float32Array;
     /** Push the description to the engine (a no-op until attached). */
     protected abstract push(): void;

package/dist/types/gl/nav/NavAgent.d.ts

@@ -68,7 +68,6 @@ export declare class NavAgent extends Aspect<"agent", Node, NavAgentEvents> {
     private _target;
     /** velocity-driven (`move`) rather than target-driven */
     private _steering;
-    private _dirty;
     private _faceX;
     private _faceZ;
     private _retryAt;
@@ -77,7 +76,9 @@ export declare class NavAgent extends Aspect<"agent", Node, NavAgentEvents> {
     private _near;
     private _slow;
     onAttach(): void;
-    onReconfigure(): void;
+    /** A parameter changed: push the agent's params to the crowd (a no-op until it has a slot —
+     *  `_join` sends them with the add). */
+    protected flush(): void;
     onDetach(): void;
     /** Walk to a point. False = no walkable polygon near it (or no navmesh) — the current target stays. */
     goTo(target: Vec3Like): boolean;

package/dist/types/gl/physics/Physics.d.ts

@@ -45,11 +45,10 @@ export declare class Physics extends Aspect<"physics", Node> implements CompWrit
      * `1`, ice `0.02`. A Vehicle's tires read the GROUND body's value, so this is the single number
      * that decides how well a car corners.
      *
-     * Change it at runtime by re-configuring — `floor.aspect(Physics, { friction: 0.02 })` (an ice
-     * patch) — or by assigning `floor.physics.friction = 0.02`; either way the setter pushes the new
-     * surface to the live body at once. (chisel keeps an instance setter whose name appears as an
-     * object-literal key anywhere in the bundle, so the config-object route survives tree-shaking
-     * even when no code reads `.friction`.)
+     * Live: `floor.physics.friction = 0.02` (an ice patch) pushes the new surface to the body at
+     * once. (chisel keeps an instance setter whose name appears as an object-literal key anywhere in
+     * the bundle, so `aspect(Physics, { friction })` at build survives tree-shaking even when no code
+     * reads `.friction`.)
      */
     get friction(): number;
     set friction(v: number);

package/dist/types/gl/physics/Shape.d.ts

@@ -1,4 +1,5 @@
 import { Aspect } from "../../core/Aspect";
+import type { FieldMeta } from "../../core/fields";
 import { type Vec3Like } from "../../math/vec";
 import type { Node } from "../Node";
 /** Which geometry a Shape uses — the one-of the fields below encode (see `_build`'s order). */
@@ -26,29 +27,49 @@ export type ShapeFit = {
 };
 export declare class Shape extends Aspect<"shape", Node> {
     static readonly aspect = "shape";
+    private _box?;
+    private _sphere?;
+    private _cylinder?;
+    private _capsule?;
+    private _mesh?;
+    private _heightfield?;
+    private _origin?;
+    private _raycast;
     /** Box half-extents [hx, hy, hz] (world units). */
-    box?: Vec3Like;
+    get box(): Vec3Like | undefined;
+    set box(v: Vec3Like | undefined);
     /** Sphere radius. */
-    sphere?: number;
+    get sphere(): number | undefined;
+    set sphere(v: number | undefined);
     /** Cylinder aligned on Y: half-height + radius. */
-    cylinder?: {
+    get cylinder(): {
         halfHeight: number;
         radius: number;
-    };
+    } | undefined;
+    set cylinder(v: {
+        halfHeight: number;
+        radius: number;
+    } | undefined);
     /** Capsule aligned on Y: half-height of the cylinder section + radius. */
-    capsule?: {
+    get capsule(): {
         halfHeight: number;
         radius: number;
-    };
+    } | undefined;
+    set capsule(v: {
+        halfHeight: number;
+        radius: number;
+    } | undefined);
     /** The node's own triangles (a Mesh's geometry or a Model's GLB, world scale applied).
      *  `true` = exact triangle mesh — static/kinematic bodies, triggers, characters' ground and picking
      *  only (a dynamic body can't be a triangle mesh; Physics throws). `'convex'` = convex hull of the
      *  vertices, works for dynamic bodies too. A Model uses its bind pose (skinned parts skipped). */
-    mesh?: boolean | "convex";
+    get mesh(): boolean | "convex" | undefined;
+    set mesh(v: boolean | "convex" | undefined);
     /** The node's terrain (`Terrain.create(...).node`) as a Jolt height field — the exact drawn grid,
      *  holes included (docs/terrain-plan.md). Static / kinematic / picking / character ground only,
      *  like `mesh: true`. `terrain.commit()` pushes edits into the live shape. */
-    heightfield?: boolean;
+    get heightfield(): boolean | undefined;
+    set heightfield(v: boolean | undefined);
     /**
      * The shape's centre, relative to the node's origin — world units in the node's ROTATED frame
      * (the node's scale is ignored, exactly like the explicit dimensions above). Default [0, 0, 0].
@@ -62,20 +83,24 @@ export declare class Shape extends Aspect<"shape", Node> {
      * you would expect. With no `origin` an auto shape (`{}`) still centres itself on the node's own
      * mesh bounds — only explicit dimensions sit on the pivot by default.
      */
-    origin?: Vec3Like;
-    /** Whether pointer rays can hit this shape (click / touchstart). Default true. */
-    raycast: boolean;
+    get origin(): Vec3Like | undefined;
+    set origin(v: Vec3Like | undefined);
+    /** Whether pointer rays can hit this shape (click / touchstart). Default true. Live, at once. */
+    get raycast(): boolean;
+    set raycast(v: boolean);
+    /** Scene-editor inspector: the geometry fields (accessors, so they are listed here by name). */
+    static fields: FieldMeta<Shape>;
     private _shapeId;
     private _bodyId;
     /** Centre the "auto" box measured for itself — used when `origin` isn't set explicitly. */
     private _autoOrigin;
-    /** Geometry props as of the last build (see onReconfigure). */
+    /** Geometry props as of the last build (see _changed). */
     private _sig;
     onAttach(): void;
     onDetach(): void;
-    /** Re-configuring (`node.aspect(Shape, { origin })`) rebuilds the geometry when a dimension, the
-     *  kind or the origin changed, and re-applies pickability. The body keeps its id and velocity. */
-    onReconfigure(): void;
+    /** A dimension, the kind or the origin was written: rebuild the geometry when it actually changed.
+     *  The body keeps its id and velocity. */
+    private _changed;
     /**
      * Measure the node's rendered geometry and size the collider to it — the code half of the scene
      * editor's "Fit to mesh". Keeps the current kind unless one is passed; `auto` becomes an explicit