lecodes-cli 0.19.0 → 0.20.0

package/runtime/sdk/g2/touch.ts

@@ -1,83 +0,0 @@
-// 2D pointer dispatch + track (drag) system. The host (createViewer2d canvas / Creator2DView) delivers
-// raw pointer phases via _creator2d.setOnPointer; this module hit-tests in the active scene and routes
-// to the struck node and the scene's listeners. Mirrors the 3D gl/touch.ts, but the hit-test is done
-// here (screen→world via the camera, then a physics overlap), not by the host.
-//
-// What can be hit: a node with a Physics2D shape (precise) → its 'touchstart'/'click' events; the
-// active Scene2D always gets the event too (target = the hit node or null). A node listener can call
-// ev.track({ onMove, onEnd, onCancel }) to capture the rest of the gesture (drag/pan).
-
-import { ClickEvent, TouchStartEvent, type TrackHandler } from "../runtime/touch"
-import { Physics2D } from "./Physics2D"
-import { Scene2D } from "./Scene2D"
-import type { Node2D } from "./Node2D"
-
-type Active = { tracker?: TrackHandler, lastX: number, lastY: number }
-const active = new Map<number, Active>()
-
-let registered = false
-/** Register the host pointer callback once, on the first click/touchstart listener (node or scene). */
-export const ensurePointerEvents = (): void => {
-  if (registered) return
-  registered = true
-  _creator2d.setOnPointer((phase, id, x, y) => {
-    if (phase === 0) onDown(id, x, y)
-    else if (phase === 1) onMove(id, x, y)
-    else if (phase === 2) onUp(id, x, y)
-    else onCancel(id)
-  })
-}
-
-// Hit-test: screen (logical px) → world → topmost physics body at the point.
-const hitTest = (scene: Scene2D, sx: number, sy: number): { node: Node2D | null, wx: number, wy: number } => {
-  const w = scene.camera.screenToWorld(sx, sy)
-  return { node: Physics2D.overlapPoint(w), wx: w.x, wy: w.y }
-}
-
-const onDown = (id: number, sx: number, sy: number): void => {
-  const scene = Scene2D.active
-  if (!scene) return
-  const { node, wx, wy } = hitTest(scene, sx, sy)
-  const ev = new TouchStartEvent<Node2D | null>(sx, sy, id)
-  ev.worldX = wx; ev.worldY = wy
-  ev.target = node
-
-  let tracker: TrackHandler | undefined
-  if (node) { node._dispatchEvent("touchstart", ev); tracker = ev._trackHandler }
-  if (!tracker) {
-    for (const l of scene._touchStartListeners.slice()) {
-      l(ev)
-      if (ev._trackHandler) { tracker = ev._trackHandler; break }
-    }
-  }
-  active.set(id, { tracker, lastX: sx, lastY: sy })
-}
-
-const onMove = (id: number, sx: number, sy: number): void => {
-  const a = active.get(id)
-  if (!a) return
-  a.tracker?.onMove?.({ clientX: sx, clientY: sy, deltaX: sx - a.lastX, deltaY: sy - a.lastY })
-  a.lastX = sx; a.lastY = sy
-}
-
-const onUp = (id: number, sx: number, sy: number): void => {
-  const a = active.get(id)
-  active.delete(id)
-  a?.tracker?.onEnd?.({ clientX: sx, clientY: sy, deltaX: a ? sx - a.lastX : 0, deltaY: a ? sy - a.lastY : 0 })
-
-  // A pointer-up is also a click, dispatched at the up location (independent of any track).
-  const scene = Scene2D.active
-  if (!scene) return
-  const { node, wx, wy } = hitTest(scene, sx, sy)
-  const ev = new ClickEvent<Node2D | null>(sx, sy, id)
-  ev.worldX = wx; ev.worldY = wy
-  ev.target = node
-  if (node) node._dispatchEvent("click", ev)
-  for (const l of scene._clickListeners.slice()) l(ev)
-}
-
-const onCancel = (id: number): void => {
-  const a = active.get(id)
-  active.delete(id)
-  a?.tracker?.onCancel?.()
-}

package/runtime/sdk/gl/Camera.ts

@@ -1,160 +0,0 @@
-// The scene camera — a Node (so position / lookAt / transform all work) plus projection reads and
-// screen↔world ray helpers. Created and attached by Scene. Ported from worker/src/components/Camera.ts.
-
-import { Vec3 } from "../math/vec"
-import { Aspect } from "../core/Aspect"
-import { Node } from "./Node"
-import { Ray } from "./Ray"
-
-/** @internal `camera.follow(node)`: copies the node's world pose onto the camera every LATE frame
- *  (order 1000 — after every other aspect has moved things). One per camera; lives on the target. */
-export class CameraFollowRig extends Aspect<"__cameraFollow"> {
-  static readonly aspect = "__cameraFollow"
-  /** @internal */ _camera!: Camera
-  constructor() { super(); this.updateOrder = 1000 }
-  update(): void {
-    const cam = this._camera
-    cam.position = this.node.worldPosition
-    cam.quaternion = this.node.worldQuaternion
-  }
-}
-
-/** Projection every host starts a scene with (creator-gl scene.cpp / the lite core agree on these). */
-export const CAMERA_DEFAULTS = { fov: 60, near: 0.01, far: 1000 }
-
-export class Camera extends Node {
-  private _sceneId = -1
-  /** Live projection matrix (updated by the host when the viewport/fov changes). */
-  readonly projectionMatrix = new Float32Array(16)
-
-  // Projection the app asked for (host defaults until it does). The host owns the aspect and
-  // re-applies these on every viewport change, so they are set, not maintained.
-  private _fov = CAMERA_DEFAULTS.fov
-  private _near = CAMERA_DEFAULTS.near
-  private _far = CAMERA_DEFAULTS.far
-  /** Stay quiet until the app actually sets something — hosts may be configured with their own
-   *  defaults (the headless core takes a `fov` option) and a blind push would overwrite them. */
-  private _projSet = false
-
-  // Exposure the app asked for (filament's physical defaults until it does): f/16, 1/125 s, ISO 100 =
-  // EV100 15, bright sunlight — what every light intensity in the docs is tuned against.
-  private _exposure = { aperture: 16, shutterSpeed: 1 / 125, iso: 100 }
-  private _ev = 0
-  private _exposureSet = false
-
-  /** @internal — Scene wires the camera to its native scene id + projection callback. */
-  _attach(sceneId: number): void {
-    this._sceneId = sceneId
-    _creator.attachCameraToAR(sceneId, this.id, (mat) => {
-      for (let i = 0; i < 16; i++) this.projectionMatrix[i] = mat[i]
-    })
-    if (this._projSet) this._applyProjection()
-    if (this._exposureSet) this._applyExposure()
-  }
-
-  /** Exposure compensation in stops (default 0): +1 doubles how bright the scene renders, −2
-   *  quarters it. The one exposure knob most games need — a dark interior, a flash of white, or eye
-   *  adaptation when the sun swings into view (drop it, and the sun stays at the display's peak
-   *  while everything else darkens). Scene light follows it; particle `emissive` is post-exposure
-   *  and does not, so a fireball keeps its on-screen brightness. Cheap to animate every frame. */
-  get exposureCompensation(): number { return this._ev }
-  set exposureCompensation(stops: number) {
-    this._ev = Number.isFinite(stops) ? stops : 0
-    this._exposureSet = true
-    this._applyExposure()
-  }
-
-  /** The physical camera: `aperture` in f-stops, `shutterSpeed` in seconds, `iso`, plus the same
-   *  `compensation` in stops — any subset, one call. `camera.setExposure({ iso: 400 })` is two stops
-   *  brighter than the default f/16 · 1/125 · ISO 100. */
-  setExposure(exposure: { aperture?: number, shutterSpeed?: number, iso?: number, compensation?: number }): this {
-    if (exposure.aperture !== undefined) this._exposure.aperture = exposure.aperture
-    if (exposure.shutterSpeed !== undefined) this._exposure.shutterSpeed = exposure.shutterSpeed
-    if (exposure.iso !== undefined) this._exposure.iso = exposure.iso
-    if (exposure.compensation !== undefined) this._ev = exposure.compensation
-    this._exposureSet = true
-    this._applyExposure()
-    return this
-  }
-
-  /** Hosts that predate the call keep the fixed default (older wasm / native builds). */
-  private _applyExposure(): void {
-    if (this._sceneId < 0) return
-    const e = this._exposure
-    _creator.setCameraExposure?.(this._sceneId, e.aperture, e.shutterSpeed, e.iso * 2 ** this._ev)
-  }
-
-  /** Vertical field of view in degrees (default 60) — a smaller angle is a longer lens. */
-  get fov(): number { return _creator.getCameraFov(this._sceneId, 0) }
-  set fov(degrees: number) { this._fov = degrees; this._projSet = true; this._applyProjection() }
-  get horizontalFov(): number { return _creator.getCameraFov(this._sceneId, 1) }
-
-  /** Near clip distance (default 0.01) — nothing closer than this draws. */
-  get near(): number { return this._near }
-  set near(distance: number) { this._near = distance; this._projSet = true; this._applyProjection() }
-
-  /** Far clip distance / view range (default 1000) — geometry past it is culled. Shadows keep
-   *  their own (shorter) range, so a long view distance doesn't cost shadow sharpness. */
-  get far(): number { return this._far }
-  set far(distance: number) { this._far = distance; this._projSet = true; this._applyProjection() }
-
-  /** Set any of fov / near / far in one call: `camera.setProjection({ fov: 45, far: 5000 })`. */
-  setProjection(projection: { fov?: number, near?: number, far?: number }): this {
-    if (projection.fov !== undefined) this._fov = projection.fov
-    if (projection.near !== undefined) this._near = projection.near
-    if (projection.far !== undefined) this._far = projection.far
-    this._projSet = true
-    this._applyProjection()
-    return this
-  }
-
-  /** Hosts that predate the call keep the fixed defaults (older wasm / native builds). */
-  private _applyProjection(): void {
-    if (this._sceneId < 0 || typeof _creator.setCameraProjection !== "function") return
-    _creator.setCameraProjection(this._sceneId, this._fov, this._near, this._far)
-  }
-  private _following: Node | null = null
-  /** The node the camera currently follows (`follow()`), or null. */
-  get following(): Node | null { return this._following }
-
-  /**
-   * Make the camera ride a node: every late frame the camera takes the node's WORLD pose (−Z =
-   * view direction), so movement aspects / animation on that node are camera moves — dolly shots,
-   * a cutscene path, a `CameraPlace` in a scene file. A node carrying a `CameraPlace` also hands
-   * over its projection (fov / near / far). `follow(null)` releases the camera where it is.
-   * One camera per scene: following a new node stops following the previous one.
-   */
-  follow(target: Node | { node: Node, applyTo(camera: Camera): void } | null): this {
-    const node = target === null ? null : target instanceof Node ? target : target.node
-    if (this._following && this._following !== node) this._following.removeAspect(CameraFollowRig)
-    this._following = node
-    if (!node) return this
-    // a CameraPlace on the node (or passed directly) sets the lens too
-    const place = target instanceof Node
-      ? (node as unknown as { cameraPlace?: { applyTo(camera: Camera): void } }).cameraPlace
-      : target as { applyTo(camera: Camera): void }
-    place?.applyTo(this)
-    node.aspect(CameraFollowRig, { _camera: this })
-    this.position = node.worldPosition
-    this.quaternion = node.worldQuaternion
-    return this
-  }
-
-  get displaySize(): [number, number] {
-    const s = _creator.getDisplaySize()
-    return [ s[0], s[1] ]
-  }
-
-  /** World-space ray direction through a screen pixel. */
-  getViewDirection(screenX: number, screenY: number): Vec3 {
-    if (this._sceneId < 0) throw new Error("Camera is not attached to a scene")
-    const v = new Float32Array(3)
-    _creator.getCameraViewDirection(this._sceneId, screenX, screenY, v)
-    return new Vec3(v[0], v[1], v[2])
-  }
-
-  /** A pick ray from the camera through a screen pixel. */
-  getRay(screenX: number, screenY: number): Ray {
-    return new Ray(this.worldPosition, this.getViewDirection(screenX, screenY))
-  }
-}

package/runtime/sdk/gl/CameraPlace.ts

@@ -1,52 +0,0 @@
-// CameraPlace: "the camera as a place". A scene has ONE camera (`scene.camera`); a CameraPlace marks
-// a node as somewhere that camera can be — with the lens it uses there. Nothing is created engine-
-// side (no second camera, no ABI): it is a pose + a projection record on any node: an empty, an
-// empty mounted on a bone (`mount:`), a node a path aspect moves (a dolly shot), a model node.
-//
-//   • In a scene FILE that runs (`open()` / `load()`), the `active: true` place drives
-//     `scene.camera` (exactly `scene.camera.follow(node)`); exactly one per file.
-//   • Inside a prefab or an `instantiate()`d subtree a place is inert DATA — the hosting scene
-//     owns its camera. The host reads it (`inst.nodes.eye.get(CameraPlace)` → world pose + fov)
-//     or anchors on it (`inst.alignTo(inst.nodes.eye)`).
-//   • From code: `scene.camera.follow(dolly.get(CameraPlace))` — a cutscene shot; `follow(null)`
-//     releases.
-//   • Edit mode: draws an anchored frustum gizmo (the editor's camera preview reads the same place).
-// See docs/scene-camera-place-plan.md.
-
-import { Aspect } from "../core/Aspect"
-import type { FieldMeta } from "../core/fields"
-import { Gizmos } from "../scene/gizmos"
-import type { Camera } from "./Camera"
-import type { Node } from "./Node"
-
-export class CameraPlace extends Aspect<"cameraPlace", Node> {
-  static readonly aspect = "cameraPlace"
-  /** Vertical field of view in degrees (default 60) — smaller is a longer lens. */
-  fov = 60
-  /** Near clip distance. */
-  near = 0.01
-  /** Far clip distance = view range. */
-  far = 1000
-  /** The place that drives `scene.camera` when the file declaring it RUNS. Exactly one per file;
-   *  ignored inside prefabs / instantiated subtrees (the host scene owns its camera). */
-  active = false
-  /** Aspect ratio of the frustum gizmo only (the real aspect is the viewport's). */
-  static fields: FieldMeta<CameraPlace> = {
-    fov: { label: "FOV", min: 1, max: 179, step: 1 },
-    near: { min: 0.001, max: 10, step: 0.01 },
-    far: { min: 1, max: 100000, step: 1 },
-    active: { label: "Active camera" },
-  }
-  static editor = { rebuild: true }
-
-  /** Copy this place's projection onto a camera (`camera.follow(place)` does it for you). */
-  applyTo(camera: Camera): void {
-    camera.setProjection({ fov: this.fov, near: this.near, far: this.far })
-  }
-
-  /** Edit mode: the frustum marker (−Z = view), anchored on the node so it follows drags live and
-   *  clicking it selects the node. Play mode never calls this. */
-  rebuild(): void {
-    Gizmos.frustum(this.fov, { node: this.node, color: this.active ? "#ffffff" : "#9aa3b2" })
-  }
-}

package/runtime/sdk/gl/CharacterController.ts

@@ -1,238 +0,0 @@
-// A character controller, as an aspect on a 3D Node, backed by Jolt's CharacterVirtual — a kinematic
-// collide-and-slide controller (NOT a rigid body: no bouncing/tipping, crisp control, built-in stair
-// stepping + slope handling). Requires a Shape (a capsule is recommended) and does NOT use Physics.
-//
-//   const hero = new Mesh(capsuleGeometry(), material)
-//     .aspect(Shape, { capsule: { halfHeight: 0.6, radius: 0.3 } })
-//     .aspect(CharacterController)
-//   setLoop(() => hero.controller.move((Input.key('KeyD') ? 1 : 0) - (Input.key('KeyA') ? 1 : 0) * SPEED,
-//                                      (Input.key('KeyS') ? 1 : 0) - (Input.key('KeyW') ? 1 : 0) * SPEED))
-//   Input.on('keydown', e => { if (e.code === 'Space' && hero.controller.grounded) hero.controller.velocityY = 7 })
-//
-// The two halves of the velocity have different NATURES, so they have different channels:
-//
-//   • HORIZONTAL — `move(x, z)`, world units/s, a PER-FRAME COMMAND. A walking character's horizontal
-//     velocity is muscle-driven and not conserved: stop pushing, stop moving. So the command expires
-//     each frame — no call this frame means standing still, and releasing the keys needs no explicit
-//     zero. It is latched for the whole frame, so every physics sub-step of that frame sees it.
-//   • VERTICAL — `velocityY`, LATCHED ballistic state. Gravity integrates into it in the engine;
-//     you seed it for a jump / dash / bounce pad / explosion (`velocityY = 7`, `velocityY += 3`).
-//     There is deliberately no ground check: coyote time, double jumps and wall jumps all need
-//     the caller's own condition.
-//
-// `velocity` reads back what the solver ENDED UP with after the last step (post-collision) — walk into
-// a wall and it reads ~0 even though you commanded 5. Everything runs on the engine's fixed clock, so
-// the aspect has no per-frame update: a character costs zero JS work per frame.
-//
-// FREE MODE — `gravityScale = 0` turns the character into a swimmer / flyer / drone: no gravity, and
-// (because Jolt would otherwise snap it down to the floor it passes over) no stick-to-floor and no
-// stair walking either. There the vertical is muscle-driven too, so `move()` takes all three
-// components and the whole velocity becomes a per-frame command.
-//
-// ROTATION AND SCALE stay the node's: the engine writes only the position, so a rig can be yawed and
-// scaled directly instead of needing a child node for the visuals (a capsule is symmetric about its up
-// axis, so its yaw is physically irrelevant either way).
-//
-// CROUCHING goes through the Shape aspect (`node.aspect(Shape, { capsule: … })`) — see `resizing`.
-//
-// Note: it collides with solid bodies but PASSES THROUGH triggers, and (v1) is not itself detected by
-// triggers and isn't pointer-pickable while active.
-
-import { Aspect } from "../core/Aspect"
-import type { FieldMeta } from "../core/fields"
-import { Vec3, cx, cy, cz, type Vec2Like, type Vec3Like } from "../math/vec"
-import type { CompAxis, CompWriter } from "../core/compWrite"
-import { Shape } from "./Shape"
-import type { Node } from "./Node"
-
-/** Where the character's feet are, as reported by the solver after the last step. */
-export type GroundState = "ground" | "slope" | "unsupported" | "air"
-
-// Index = JPH::EGroundState (0 OnGround / 1 OnSteepGround / 2 NotSupported / 3 InAir).
-const GROUND_STATES: readonly GroundState[] = ["ground", "slope", "unsupported", "air"]
-
-const scratch = new Float32Array(3)
-let warnedFreeMove = false
-
-export class CharacterController extends Aspect<"controller", Node> implements CompWriter {
-  static readonly aspect = "controller"
-
-  // Both tunables are accessor-backed (they write through to the engine), and describeFields only
-  // enumerates own enumerable fields — so the inspector is told about them explicitly. The default
-  // VALUES still come from a fresh instance through the getters; this only supplies the keys.
-  static fields: FieldMeta<CharacterController> = {
-    gravityScale: { editor: "number", min: 0, step: 0.1, label: "Gravity scale" },
-    maxSlope: { editor: "number", min: 0, max: 89, step: 1, label: "Max slope°" },
-  }
-
-  private _charId = 0
-  private _gravityScale = 2
-  private _maxSlope = 45
-
-  onAttach(): void {
-    if (!_creator.physicsHasSupport || !_creator.physicsHasSupport()) return
-    const shape = this.node.get(Shape)
-    if (!shape) {
-      throw new Error("CharacterController requires a Shape aspect (a capsule is recommended) — add it first: node.aspect(Shape, { capsule: {…} }).aspect(CharacterController)")
-    }
-    if (shape._isTriangleMesh) {
-      throw new Error("CharacterController needs a convex Shape (capsule recommended) — { mesh: true } is a triangle mesh; use { mesh: 'convex' } or a capsule")
-    }
-    const shapeId = shape._claim() // the character owns the shape; it is not a rigid body
-    // Read the options through their PUBLIC accessors, never the `_backing` fields: chisel drops an
-    // accessor pair whose name is only ever an object-literal key, and then
-    // `aspect(CharacterController, { gravityScale: 0 })` silently leaves the default in place (the
-    // character keeps falling instead of entering free mode). One property read here keeps the pair.
-    this._charId = _creator.characterCreate(this.node.id, shapeId, this.maxSlope)
-    if (!this._charId) return
-    _creator.characterSetGravityScale(this._charId, this.gravityScale)
-    this.node._xf = this._charId   // routes node.position / .x / .y / .z / .matrix writes to the character
-    this.node._xfKind = 1
-  }
-
-  onDetach(): void {
-    if (this._charId) { _creator.characterDestroy(this._charId); this._charId = 0 }
-    this.node._xf = 0
-    this.node._xfKind = 0
-    this.node.get(Shape)?._recreatePickBody()   // hands the routing back to the pick body
-  }
-
-  /** Native character id (0 until attached / no physics support). */
-  get id(): number { return this._charId }
-
-  /**
-   * This frame's movement command, in world units/s — NOT normalized, NOT a per-frame displacement
-   * (that is what Unity's `Move` takes; passing `v * dt` here gives a character 60× too slow).
-   *
-   * Two components = horizontal `(x, z)`, the everyday call. Three = the whole velocity, for free mode
-   * (`gravityScale = 0`); with gravity on, the vertical component fights the ballistic one and the
-   * character barely falls, so that combination warns.
-   *
-   * Sticky only within the frame: the command expires once the engine consumes it. It also **takes the
-   * axis back from a latched `velocity`** — commanding is claiming ownership, which is what keeps the
-   * two horizontal sources from ever fighting.
-   */
-  move(x: number, z: number): void
-  move(v: Vec2Like | Vec3Like): void
-  move(x: number | Vec2Like | Vec3Like, z?: number): void {
-    if (!this._charId) return
-    if (typeof x === "number") { _creator.characterMove(this._charId, x, z ?? 0); return }
-    // cz() is typed for 3-component inputs; a Vec2 legitimately has no `z` and reads undefined here.
-    const third = cz(x as Vec3Like)           // undefined for a Vec2 / 2-tuple / 2-long typed array
-    if (third === undefined) { _creator.characterMove(this._charId, cx(x), cy(x)); return }
-    if (this._gravityScale !== 0 && !warnedFreeMove) {
-      warnedFreeMove = true
-      console.warn("CharacterController.move(): the 3-component form is the FREE-mode command (swimming / flying) and expects gravityScale = 0. With gravity on it overwrites the falling speed every frame, so the character will hang in the air. Use move(x, z) and velocityY for a walking character.")
-    }
-    _creator.characterMoveFree(this._charId, cx(x), cy(x), third)
-  }
-
-  /** Vertical velocity (world units/s) — LATCHED: gravity works on it, you seed it. `= 7` to jump,
-   *  `+= 3` to stack an explosion on top of the current motion. No ground check: guard it yourself
-   *  with `grounded` (or don't, for a double jump). Overridden every frame by a 3-component `move()`.
-   *  `velocity.y = 7` is the same channel — pick whichever reads better. */
-  get velocityY(): number {
-    if (!this._charId) return 0
-    _creator.characterGetVelocity(this._charId, scratch)
-    return scratch[1]
-  }
-  set velocityY(v: number) {
-    if (this._charId) _creator.characterSetVerticalVelocity(this._charId, v)
-  }
-
-  /** Multiplier over the world gravity (`Physics.configure({ gravity })`); default 2, for the snappier
-   *  fall games want. **0 = free mode**: no gravity, no stick-to-floor, no stair stepping — a swimmer
-   *  or a drone, driven by the 3-component `move()`. */
-  get gravityScale(): number { return this._gravityScale }
-  set gravityScale(v: number) {
-    this._gravityScale = v
-    if (this._charId) _creator.characterSetGravityScale(this._charId, v)
-  }
-
-  /** Max ground slope (degrees) the character treats as walkable; default 45. Live. */
-  get maxSlope(): number { return this._maxSlope }
-  set maxSlope(v: number) {
-    this._maxSlope = v
-    if (this._charId) _creator.characterSetMaxSlope(this._charId, v)
-  }
-
-  /**
-   * True while a requested collider resize hasn't taken — you asked to stand up and there is something
-   * overhead. Resizing goes through the `Shape` aspect itself:
-   *
-   *     hero.aspect(Shape, { capsule: CROUCHED })   // always fits — you are shrinking
-   *     hero.aspect(Shape, { capsule: STANDING })   // may be refused under a low ceiling
-   *     if (hero.controller.resizing) …             // still crouched; call it again next frame
-   *
-   * A refusal changes nothing, so the retry is just the same call again — and it is an exact headroom
-   * test against the real capsule, unlike a hand-rolled raycast (a ray is a line; a capsule has girth).
-   * The FEET stay planted across a resize, so the character neither hovers nor sinks.
-   */
-  get resizing(): boolean {
-    return this.node.get(Shape)?._resizeRefused ?? false
-  }
-
-  /** True while standing on walkable ground. */
-  get grounded(): boolean {
-    return this._charId ? _creator.characterGetGroundState(this._charId) === 0 : false
-  }
-
-  /** Where the feet are after the last step: on walkable ground, on too-steep ground, touching
-   *  something that can't support it, or in the air. */
-  get groundState(): GroundState {
-    return this._charId ? (GROUND_STATES[_creator.characterGetGroundState(this._charId)] ?? "air") : "air"
-  }
-
-  /**
-   * READ — the velocity the solver ended up with after the most recent step (world units/s, fresh
-   * Vec3): what HAPPENED, not what you asked for. Walking into a wall reads ~0, sliding along one
-   * reads the tangent. Unlike Unity's synchronous `Move`, our step runs later in the frame, so a read
-   * is up to one frame old — irrelevant for animation speed, fall damage or "am I blocked", which is
-   * what it is for. (Exact wall contact would need a contact normal; the engine has none yet.)
-   *
-   * WRITE — LATCH the whole velocity: a knockback, a wall jump, a launch pad. Unlike `move()` it does
-   * not expire, so the character keeps flying, and gravity still pulls the vertical down into a real
-   * ballistic arc. It stays until `move()` takes the axis back — so a game simply doesn't call
-   * `move()` while the throw lasts, and ends it on its own terms:
-   *
-   *     hero.controller.velocity = [dir.x * 12, 6, dir.z * 12]   // hit by the blast
-   *     // …in the loop:
-   *     if (thrown) { if (hero.controller.grounded) thrown = false }   // landing ends it
-   *     else hero.controller.move(ix * SPEED, iz * SPEED)              // …and this reclaims the axis
-   *
-   * Note nothing clears the latch by itself, landing included — so a thrown character that never gets
-   * a `move()` keeps sliding along the ground (a kinematic controller has no friction).
-   *
-   * Reading is not the inverse of writing: `c.velocity = c.velocity` is NOT a no-op, because the read
-   * reports the measured result (against a wall it is ~0 and would cancel the throw). In flight the
-   * two agree closely, so read-modify-write mid-air behaves as expected.
-   *
-   * `c.velocity.y = 7` (the direct spelling) is a jump — the compiler routes it to the exact
-   * `velocityY` channel via `_writeComp` below, no vector allocated — and `c.velocity.x = 3` latches
-   * the whole vector with the measured velocity filling in the other two, i.e. the read-modify-write
-   * above spelled naturally. A STORED copy is still a copy: `const v = c.velocity; v.y = 7` does nothing.
-   */
-  get velocity(): Vec3 {
-    if (!this._charId) return new Vec3(0, 0, 0)
-    _creator.characterGetVelocity(this._charId, scratch)
-    return new Vec3(scratch[0], scratch[1], scratch[2])
-  }
-  set velocity(v: Vec3Like) {
-    if (this._charId) _creator.characterSetVelocity(this._charId, cx(v), cy(v), cz(v))
-  }
-
-  /** Compile-time list (chisel reads it, then strips it): the getters whose `c.<getter>.<axis> = v`
-   *  spelling is routed to `_writeComp` below. See core/compWrite.ts. */
-  static _comps = [ "velocity" ]
-
-  /** @internal `c.velocity.<axis> = v` compiles to this: the vertical axis is the precise `velocityY`
-   *  channel, any other latches the whole vector with the measured rest. */
-  _writeComp(_prop: string, axis: CompAxis, v: number): void {
-    if (!this._charId) return
-    if (axis === "y") { _creator.characterSetVerticalVelocity(this._charId, v); return }
-    _creator.characterGetVelocity(this._charId, scratch)
-    if (axis === "x") scratch[0] = v
-    else if (axis === "z") scratch[2] = v
-    _creator.characterSetVelocity(this._charId, scratch[0], scratch[1], scratch[2])
-  }
-}