lecodes-cli 0.18.2 → 0.19.2

package/runtime/sdk/g2/Scene2D.ts

@@ -1,209 +0,0 @@
-// A 2D scene: a draw set + an orthographic Camera2D. Opening a scene asks the host to bring up the
-// 2D engine and starts its RAF loop; only the active scene renders. Grown from the Phase 0 seed.
-
-import { Color, type ColorInput } from "../core/color"
-import { _installAspectFrames, _installTimeScale, _attachSystem, _detachSystem, _detachAllSystems, type Aspect, type AspectCtor, type FieldOf, type TargetOf } from "../core/Aspect"
-import { _bumpNavEpoch, _navSupported, _setCurrent, Presentable, type PresentOptions } from "../ui/presentable"
-import { cx, cy, type Vec2Like } from "../math/vec"
-import type { ClickEvent, TouchStartEvent } from "../runtime/touch"
-import { Camera2D } from "./Camera2D"
-import { node2dRegistry, type Node2D } from "./Node2D"
-import { ensurePointerEvents } from "./touch"
-
-// Route aspect update(dt) through the render-synced native phases (c2dRender early = before physics,
-// late = after animations / before draw), so followers/cameras are in lockstep with the draw. Done from
-// the 2D layer (not core) so a 3D-only bundle never pulls in the 2D bridge. Installed once, lazily on
-// the first Scene2D. On an older wasm without the hooks the installer returns false → setLoop fallback.
-let framesInstalled = false
-const installRenderSyncedFrames = (): void => {
-  if (framesInstalled) return
-  framesInstalled = true
-  _installAspectFrames((early, late) => {
-    if (typeof _creator2d.setEarlyUpdate !== "function") return false
-    _creator2d.setEarlyUpdate(early)
-    _creator2d.setLateUpdate(late)
-    return true
-  })
-  // Time.scale / Time.paused reach the engine's physics + animation clocks (feature-detected).
-  _installTimeScale((scale) => { _creator2d.setTimeScale?.(scale) })
-}
-
-export type Scene2DOptions = {
-  /** Background color — '#10131a', 0x10131a, or [r,g,b]/[r,g,b,a] in 0..1. */
-  background?: ColorInput
-  /** Texture sampling for the 2D renderer: `'nearest'` (default — crisp pixel art) or `'linear'`
-   *  (smooth — for hi-res / non-pixel-art assets). Applied when the scene is opened, so switching
-   *  scenes restores the active scene's choice. NOTE: this is a GLOBAL renderer setting (one sampler
-   *  for ALL textures, not per-texture), so the currently-open scene's filter wins. Omit to leave the
-   *  current setting (engine default is nearest). */
-  filter?: 'nearest' | 'linear'
-}
-
-/** Returned by scene2d.layer(n); chain .ySort() to enable top-down depth sorting for that layer. */
-class LayerHandle {
-  private readonly sceneId: number
-  private readonly layer: number
-  constructor(sceneId: number, layer: number) { this.sceneId = sceneId; this.layer = layer }
-  /** In this layer, lower-on-screen sprites overlap higher ones (top-down feet sorting). */
-  ySort(enabled = true): this {
-    _creator2d.setLayerYSort(this.sceneId, this.layer, enabled)
-    return this
-  }
-}
-
-export class Scene2D implements Presentable {
-  /** Native scene handle. */
-  readonly id: number
-  readonly camera: Camera2D
-
-  private static _active: Scene2D | null = null
-  static get active(): Scene2D | null { return Scene2D._active }
-
-  /** @internal — scene-level pointer listeners (the catch-all; target = hit node or null). */
-  readonly _clickListeners: Array<(ev: ClickEvent<Node2D | null>) => void> = []
-  readonly _touchStartListeners: Array<(ev: TouchStartEvent<Node2D | null>) => void> = []
-
-  /** Texture filter to (re)assert on open(); the sampler is global, so each scene reclaims it. */
-  private readonly _filter?: 'nearest' | 'linear'
-
-  constructor(options: Scene2DOptions = {}) {
-    installRenderSyncedFrames()
-    this.id = _creator2d.createScene()
-    this.camera = new Camera2D(this.id)
-    this._filter = options.filter
-    if (options.background !== undefined) this.background = options.background
-  }
-
-  set background(color: ColorInput) {
-    const [ r, g, b, a ] = Color.toRgba01(color)
-    _creator2d.sceneSetClearColor(this.id, r, g, b, a)
-  }
-
-  /** Address a draw layer to configure it, e.g. scene2d.layer(1).ySort(). */
-  layer(n: number): LayerHandle {
-    return new LayerHandle(this.id, n)
-  }
-
-  /** Topmost visible sprite whose world bounds contain the world point, or null. Body-free
-   *  hit-test for tap/click picking — pair with camera.screenToWorld(). */
-  pick(worldPoint: Vec2Like): Node2D | null {
-    const id = _creator2d.pickSprite(this.id, cx(worldPoint), cy(worldPoint))
-    return id ? node2dRegistry.get(id) ?? null : null
-  }
-
-  /** Scene-level pointer events. The handler fires for every tap/press in the scene, with
-   *  `ev.target` = the hit Physics2D node (or null). On 'touchstart' you can ev.track(...) a drag. */
-  addEventListener(channel: "click", callback: (ev: ClickEvent<Node2D | null>) => void): void
-  addEventListener(channel: "touchstart", callback: (ev: TouchStartEvent<Node2D | null>) => void): void
-  addEventListener(channel: "click" | "touchstart", callback: (ev: any) => void): void {
-    const list = channel === "click" ? this._clickListeners : this._touchStartListeners
-    if (!list.includes(callback)) { list.push(callback); ensurePointerEvents() }
-  }
-  removeEventListener(channel: "click" | "touchstart", callback: (ev: any) => void): void {
-    const list = channel === "click" ? this._clickListeners : this._touchStartListeners
-    const i = list.indexOf(callback)
-    if (i >= 0) list.splice(i, 1)
-  }
-
-  add(...nodes: Node2D[]): this {
-    for (const n of nodes) _creator2d.addEntityToScene(this.id, n.id)
-    return this
-  }
-  remove(...nodes: Node2D[]): this {
-    for (const n of nodes) _creator2d.removeEntityFromScene(this.id, n.id)
-    return this
-  }
-
-  // ---- systems: aspects of the scene (core/Aspect.ts `System<'x', Scene2D>`) ----
-  /** @internal class → instance, the authoritative store (named accessors mirror this). */
-  readonly _systems = new Map<Function, Aspect<any, any, any>>()
-
-  /** Attach (and configure) a system, or reconfigure it if already present. Returns the scene typed
-   *  as now-having it (`scene.system(Hud).hud`). A 3D `System<'x'>` (target Scene) is rejected here. */
-  // `this: Self` (not `Self & Scene2D`): with the intersection TS infers Self = Scene2D and a chain
-  // `scene.system(A).system(B)` loses A's accessor from the result type.
-  system<Self extends TargetOf<A>, A extends Aspect<any, any, any>>(
-    this: Self,
-    ctor: AspectCtor<A>,
-    opts?: Partial<A>,
-  ): Self & FieldOf<A> {
-    return _attachSystem(this as unknown as Scene2D, ctor, opts) as unknown as Self & FieldOf<A>
-  }
-  /** Safe access — undefined if the system isn't attached. */
-  get<A extends Aspect<any, any, any>>(ctor: AspectCtor<A>): A | undefined {
-    return this._systems.get(ctor) as A | undefined
-  }
-  /** Existence check AND type guard: inside `if (scene.has(Hud))`, `scene.hud` is present. */
-  has<A extends Aspect<any, any, any>>(ctor: AspectCtor<A>): this is this & FieldOf<A> {
-    return this._systems.has(ctor)
-  }
-  /** Detach a system (runs its onDetach). Chainable. */
-  removeSystem<A extends Aspect<any, any, any>>(ctor: AspectCtor<A>): this {
-    _detachSystem(this, ctor)
-    return this
-  }
-
-  // ---- Presentable (docs/navigation-presentable-plan.md) ----
-
-  /** @internal presentation lifecycle — fired by the host on present/dismiss (new navigation),
-   *  or synchronously by open()/close() on legacy hosts. */
-  readonly ol: (() => void)[] = []
-  readonly cl: (() => void)[] = []
-  _backButtonCallback?: () => void
-  private _vd?: object
-
-  /** Fires when the scene becomes the visible destination (incl. a pop revealing it). */
-  onOpen(callback: () => void): this {
-    this.ol.push(callback)
-    return this
-  }
-  /** Fires when the scene stops being visible (closed, replaced, or covered by a push). */
-  onClose(callback: () => void): this {
-    this.cl.push(callback)
-    return this
-  }
-  onBackPressed(callback: () => void): this {
-    this._backButtonCallback = callback
-    return this
-  }
-
-  /** @internal stable wire descriptor; hosts hand it back via router onChange (`_p` = this). */
-  _viewDesc(): object {
-    return this._vd ??= { type: "scene2d", sceneId: this.id, _p: this }
-  }
-
-  /** Make this the active scene — shows it as the current destination (replaces a screen /
-   *  another scene; only the active scene renders). */
-  open(options?: PresentOptions): this {
-    _bumpNavEpoch()
-    // Reassert this scene's texture filter (the sampler is global — see Scene2DOptions.filter).
-    if (this._filter !== undefined) _creator2d.setDefaultFilter(this._filter === 'linear')
-    if (_navSupported()) {
-      // The host activates the engine (openScene) as part of presenting the destination.
-      _creatorUI.openView!(this._viewDesc(), options?.transition ?? "none")
-    } else {
-      _creator2d.openScene(this.id)
-      for (const cb of this.ol) cb()
-    }
-    Scene2D._active = this
-    _setCurrent(this)
-    return this
-  }
-  close(): this {
-    _bumpNavEpoch()
-    if (_navSupported()) {
-      _creatorUI.closeView!()
-    } else {
-      _creator2d.closeScene()
-      for (const cb of this.cl) cb()
-    }
-    if (Scene2D._active === this) Scene2D._active = null
-    if (Presentable.current === this) _setCurrent(null)
-    return this
-  }
-  destroy(): void {
-    _detachAllSystems(this)   // systems go first (last-attached first), while the scene still exists
-    this.close()
-    _creator2d.destroyScene(this.id)
-  }
-}

package/runtime/sdk/g2/Shape2D.ts

@@ -1,259 +0,0 @@
-// A collider shape, as an aspect on a Node2D. PURE GEOMETRY — attaching a Shape2D does not by itself
-// make the node rigid or a sensor; pair it with a Physics2D (rigid body) or a Trigger2D (sensor), both
-// of which require a Shape2D and turn its geometry into a Box2D fixture. The shape is also what pointer
-// picking hits, so a node is clickable once it has a Shape2D + Physics2D/Trigger2D (a body to query).
-//
-//   wall.aspect(Shape2D, { box: [200, 16] }).aspect(Physics2D, { motion: 'static' })
-//   goal.aspect(Shape2D, { circle: 20 }).aspect(Trigger2D)
-//   hero.aspect(Shape2D, { capsule: { from: [0, 6], to: [0, 26], radius: 6 } }).aspect(Physics2D, { motion: 'dynamic' })
-//
-// With no geometry set, Shape2D derives a box from WHAT THE NODE DRAWS — the sprite's size scaled by
-// the node, positioned by its anchor. So `aspect(Shape2D, {})` on a sprite anchored at its feet gives
-// a collider that wraps the art instead of one centred on the pivot (half of it underground), which
-// is why every character used to carry a hand-computed offset.
-//
-// RE-CONFIGURING REBUILDS IT IN PLACE: `node.aspect(Shape2D, { capsule: … })` on a live node swaps the
-// fixture while the body keeps its id, its velocity and its place in the world. That is what makes a
-// crouch (and a live editor edit) possible.
-
-import { Aspect } from "../core/Aspect"
-import { Vec2, cx, cy, type Vec2Like } from "../math/vec"
-import { ALL_GROUPS } from "./groups2d"
-import type { Node2D } from "./Node2D"
-
-/** @internal How an owner (Physics2D / Trigger2D) wants the geometry realised. */
-export type ShapeFixture2D = {
-  sensor: boolean
-  friction: number
-  bounce: number
-  category?: number
-  mask?: number
-  /** Chains carry no mass, so Box2D only accepts them on a static body. */
-  staticBody?: boolean
-}
-
-export class Shape2D extends Aspect<"shape", Node2D> {
-  static readonly aspect = "shape"
-
-  /** Box half-extents [hw, hh] (world units). */
-  box?: Vec2Like
-  /** Circle radius. */
-  circle?: number
-  /** Capsule between two local points, with a radius. */
-  capsule?: { from: Vec2Like, to: Vec2Like, radius: number }
-  /** Thin segment (an edge) between two local points. */
-  segment?: { from: Vec2Like, to: Vec2Like }
-  /** 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[]
-  /**
-   * 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
-   * tangent points Box2D needs at the ends are synthesised here.
-   *
-   * STATIC bodies only (a polyline has no area, so no mass), at least 2 points (4 with `loop`), and it
-   * 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[]
-  /** `chain`: close the contour (an island / a room boundary). Needs at least 4 points. */
-  loop?: boolean
-  /** `chain`: put the solid side on the other side of the line. */
-  flip?: boolean
-  /** 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
-
-  /** @internal Geometry as of the last build — an unchanged signature means nothing to rebuild. */
-  private _sig = ""
-  /** @internal The last resize the CHARACTER refused (backs `controller.resizing`). */
-  _resizeRefused = false
-  /** @internal How the owner asked for it, so a rebuild can replay the same fixture. */
-  private _fx: ShapeFixture2D | null = null
-  private _handle = 0
-
-  /** @internal — the character claimed this shape; record the geometry so a later re-configure is
-   *  compared against it. */
-  _claimedByCharacter(): void { this._sig = this._signature(); this._resizeRefused = false }
-
-  /** @internal — realise this geometry as a fixture on `handle` (a body from Physics2D/Trigger2D). */
-  _addTo(handle: number, fx: ShapeFixture2D): void {
-    this._handle = handle
-    this._fx = fx
-    this._sig = this._signature()
-    this._create()
-  }
-
-  /** @internal — the owner's material changed live; keep it for the next rebuild. */
-  _setMaterial(friction: number, bounce: number): void {
-    if (this._fx) { this._fx.friction = friction; this._fx.bounce = bounce }
-  }
-
-  /** @internal — the owner's filter changed live. */
-  _setFilter(category: number, mask: number): void {
-    if (this._fx) { this._fx.category = category; this._fx.mask = mask }
-  }
-
-  onDetach(): void { this._handle = 0; this._fx = null; this._sig = ""; this._resizeRefused = false }
-
-  /**
-   * 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.
-   */
-  onReconfigure(): void {
-    const sig = this._signature()
-    if (sig === this._sig) return
-
-    // A CharacterController2D owns this shape instead of a body: resizing goes to the mover, which
-    // VALIDATES it (you cannot stand up under a low pipe) and can refuse.
-    if (this.node._xfKind === 1) {
-      const cap = this._capsule()
-      const ok = _creator2d.characterSetCapsule(this.node._xf, cap.x1, cap.y1, cap.x2, cap.y2, cap.radius)
-      // On refusal NOTHING changed — so DON'T commit the signature. The next identical
-      // `aspect(Shape2D, …)` then still sees a difference and retries; committing here would swallow
-      // every retry for good, which is the whole trap in this design.
-      this._resizeRefused = !ok
-      if (ok) this._sig = sig
-      return
-    }
-
-    if (!this._handle || !this._fx) return
-    this._sig = sig
-    _creator2d.physicsClearShapes(this._handle)
-    this._create()
-  }
-
-  /**
-   * @internal — this geometry as a CAPSULE, for CharacterController2D (the mover takes nothing else).
-   * An explicit capsule is used as given; anything else is derived from the drawn rect, so
-   * `aspect(Shape2D, {})` on a sprite gives a capsule that wraps the art.
-   */
-  _capsule(): { x1: number, y1: number, x2: number, y2: number, radius: number } {
-    const ox = this.origin ? cx(this.origin) : 0
-    const oy = this.origin ? cy(this.origin) : 0
-    if (this.capsule) {
-      const { from, to, radius } = this.capsule
-      return { x1: cx(from) + ox, y1: cy(from) + oy, x2: cx(to) + ox, y2: cy(to) + oy, radius }
-    }
-    if (this.circle !== undefined) return { x1: ox, y1: oy, x2: ox, y2: oy, radius: this.circle }
-    let hw = 8, hh = 8, bx = ox, by = oy
-    if (this.box) { hw = cx(this.box); hh = cy(this.box) }
-    else {
-      const a = this._autoBox()
-      hw = a.hw; hh = a.hh
-      if (!this.origin) { bx = a.x; by = a.y }
-    }
-    const radius = Math.min(hw, hh)
-    const half = Math.max(0, hh - radius)
-    return { x1: bx, y1: by - half, x2: bx, y2: by + half, radius }
-  }
-
-  // ---- internals ---------------------------------------------------------------------------------
-
-  private _create(): void {
-    const fx = this._fx!
-    const handle = this._handle
-    const category = fx.category ?? ALL_GROUPS
-    const mask = fx.mask ?? ALL_GROUPS
-    const ox = this.origin ? cx(this.origin) : 0
-    const oy = this.origin ? cy(this.origin) : 0
-
-    if (this.chain) {
-      this._createChain(handle, fx, category, mask, ox, oy)
-    } else if (this.circle !== undefined) {
-      _creator2d.physicsAddCircle(handle, this.circle, ox, oy, fx.friction, fx.bounce, fx.sensor, category, mask)
-    } else if (this.capsule) {
-      const { from, to, radius } = this.capsule
-      _creator2d.physicsAddCapsule(handle, cx(from) + ox, cy(from) + oy, cx(to) + ox, cy(to) + oy, radius,
-                                   fx.friction, fx.bounce, fx.sensor, category, mask)
-    } else if (this.segment) {
-      const { from, to } = this.segment
-      _creator2d.physicsAddSegment(handle, cx(from) + ox, cy(from) + oy, cx(to) + ox, cy(to) + oy,
-                                   fx.friction, fx.bounce, category, mask)
-    } else if (this.polygon) {
-      const pts = new Float32Array(this.polygon.length * 2)
-      this.polygon.forEach((p, i) => { pts[i * 2] = cx(p) + ox; pts[i * 2 + 1] = cy(p) + oy })
-      _creator2d.physicsAddPolygon(handle, pts, this.polygon.length, fx.friction, fx.bounce, fx.sensor, category, mask)
-    } else {
-      // box: explicit half-extents, or "auto" — the rect the node actually draws.
-      let hw = 8, hh = 8, bx = ox, by = oy
-      if (this.box) {
-        hw = cx(this.box); hh = cy(this.box)
-      } else {
-        const auto = this._autoBox()
-        hw = auto.hw; hh = auto.hh
-        if (!this.origin) { bx = auto.x; by = auto.y }   // an explicit origin still wins
-      }
-      _creator2d.physicsAddBox(handle, hw, hh, bx, by, fx.friction, fx.bounce, fx.sensor, category, mask)
-    }
-  }
-
-  /**
-   * Box2D's chain wants the two TANGENT points as extra entries and does not collide on its first or
-   * last edge — pass it your outline verbatim and you lose both end segments (four points give ONE).
-   * So the caller passes only the solid points and the ends are extrapolated here: `p0 + (p0 - p1)`.
-   * A loop needs none of that (every point is interior) but does need 4 of them.
-   */
-  private _createChain(handle: number, fx: ShapeFixture2D, category: number, mask: number, ox: number, oy: number): void {
-    const src = this.chain!
-    const loop = this.loop === true
-    if (src.length < (loop ? 4 : 2)) {
-      throw new Error(`Shape2D chain needs at least ${loop ? 4 : 2} points (got ${src.length})${loop ? " — a closed contour of 3 is a polygon" : ""}`)
-    }
-    if (fx.staticBody === false) {
-      throw new Error("Shape2D { chain } works on a STATIC body only — a polyline has no area, so no mass. Use polygon/box for a dynamic body.")
-    }
-    const order = this.flip === true ? [ ...src ].reverse() : src
-    const p: number[] = []
-    if (!loop) {
-      // leading ghost: mirror the first point across the second
-      p.push(2 * cx(order[0]) - cx(order[1]) + ox, 2 * cy(order[0]) - cy(order[1]) + oy)
-    }
-    for (const v of order) p.push(cx(v) + ox, cy(v) + oy)
-    if (!loop) {
-      const n = order.length
-      p.push(2 * cx(order[n - 1]) - cx(order[n - 2]) + ox, 2 * cy(order[n - 1]) - cy(order[n - 2]) + oy)
-    }
-    _creator2d.physicsAddChain(handle, new Float32Array(p), p.length / 2, loop, fx.friction, fx.bounce, category, mask)
-  }
-
-  // Everything that changes the GEOMETRY, so a re-configure that only touches the material is free.
-  private _signature(): string {
-    const o = this.origin ? `${cx(this.origin)},${cy(this.origin)}` : ""
-    if (this.chain) return `chain:${this.chain.map(v => `${cx(v)},${cy(v)}`).join(";")}|${this.loop}|${this.flip}|${o}`
-    if (this.circle !== undefined) return `circle:${this.circle}|${o}`
-    if (this.capsule) {
-      const { from, to, radius } = this.capsule
-      return `cap:${cx(from)},${cy(from)},${cx(to)},${cy(to)},${radius}|${o}`
-    }
-    if (this.segment) {
-      const { from, to } = this.segment
-      return `seg:${cx(from)},${cy(from)},${cx(to)},${cy(to)}|${o}`
-    }
-    if (this.polygon) return `poly:${this.polygon.map(v => `${cx(v)},${cy(v)}`).join(";")}|${o}`
-    if (this.box) return `box:${cx(this.box)},${cy(this.box)}|${o}`
-    const a = this._autoBox()
-    return `auto:${a.hw},${a.hh},${a.x},${a.y}|${o}`
-  }
-
-  /**
-   * @internal — half-extents and centre of the rect this node DRAWS, in the node's own frame.
-   *
-   * Sprite anchor space is Y-DOWN while the world is Y-up (see docs/conventions.md), so `anchor: [.5, 1]`
-   * ("feet") puts the art ABOVE the origin: its centre sits at +h/2. A node with no sprite falls back
-   * to 8x8 at the origin. This is a SNAPSHOT taken when the fixture is built — growing the sprite later
-   * does not resize the collider; re-configure the aspect to re-measure.
-   */
-  private _autoBox(): { hw: number, hh: number, x: number, y: number } {
-    const n = this.node as { size?: Vec2, anchor?: Vec2, scale?: Vec2 }
-    const size = n.size
-    if (!size || !(size.x > 0) || !(size.y > 0)) return { hw: 8, hh: 8, x: 0, y: 0 }
-    const sx = n.scale ? Math.abs(n.scale.x) : 1
-    const sy = n.scale ? Math.abs(n.scale.y) : 1
-    const w = size.x * sx, h = size.y * sy
-    const ax = n.anchor ? n.anchor.x : 0.5
-    const ay = n.anchor ? n.anchor.y : 0.5
-    return { hw: w * 0.5, hh: h * 0.5, x: (0.5 - ax) * w, y: (ay - 0.5) * h }
-  }
-}

package/runtime/sdk/g2/Sprite.ts

@@ -1,89 +0,0 @@
-// A textured 2D node. Cheap setters proxy straight to the native sprite; the data lives in
-// creator-2d. Sprite-sheet animation is no longer built in — attach the SpriteAnimation aspect:
-//   new Sprite({ texture }).aspect(SpriteAnimation, { size: [32, 48], idle: [0,1,2,3] }).anim.play('idle')
-
-import { Color, type ColorInput } from "../core/color"
-import { Vec2, type Vec2Like } from "../math/vec"
-import { Canvas, isCanvas } from "../canvas/Canvas"
-import { Node2D } from "./Node2D"
-import type { Texture2D } from "./Texture2D"
-
-/** Anything that can back a sprite: a texture, or a Canvas (baked to a texture on assign). */
-export type TextureSource = Texture2D | Canvas
-
-export type SpriteOptions = {
-  texture?: TextureSource
-  /** Pivot, [0,0] = top-left .. [1,1] = bottom-right. Use [0.5, 1] (feet) for Y-sorted depth. */
-  anchor?: Vec2Like
-  /** World size; defaults to the texture's pixel dimensions. */
-  size?: Vec2Like
-  /** Normalized UV sub-rect [u0,v0,u1,v1]. */
-  frame?: [number, number, number, number]
-  /** Tint multiplied with the texture. */
-  color?: ColorInput
-  opacity?: number
-  layer?: number
-  position?: Vec2Like
-}
-
-export class Sprite extends Node2D {
-  private _texture?: Texture2D
-  private _anchor = new Vec2(0.5, 0.5)
-  private _color: ColorInput = 0xffffff
-  private _opacity = 1
-  private _flipX = false
-  private _flipY = false
-  private _size: Vec2 | null = null
-
-  constructor(options: SpriteOptions = {}) {
-    super()
-    if (options.texture) this.texture = options.texture
-    if (options.size) this.size = options.size
-    if (options.anchor) this.anchor = options.anchor
-    if (options.frame) this.frame = options.frame
-    if (options.color !== undefined) this.color = options.color
-    if (options.opacity !== undefined) this.opacity = options.opacity
-    if (options.layer !== undefined) this.layer = options.layer
-    if (options.position) this.position = options.position
-  }
-
-  get texture(): Texture2D | undefined { return this._texture }
-  set texture(t: TextureSource | undefined) {
-    const tex = isCanvas(t) ? t.texture() : t   // a Canvas bakes to a texture on assign
-    this._texture = tex
-    if (!tex) return
-    _creator2d.setSprite(this.id, tex.id) // native resets UV + size to the full (pixel) texture
-    // A Canvas is authored in LOGICAL units but baked at logical × pixelRatio, so default the sprite's
-    // WORLD size to the canvas's LOGICAL size — pixelRatio then only affects crispness, not on-screen
-    // size. (A plain texture keeps the native default: the texture's pixel dimensions.)
-    if (!this._size && isCanvas(t)) this._size = new Vec2(t.width, t.height)
-    if (this._size) _creator2d.setSpriteSize(this.id, this._size.x, this._size.y)
-  }
-
-  /** Current world size: explicit override if set, else the texture's pixel dimensions (a Canvas-backed
-   *  sprite defaults to the canvas's LOGICAL size, so pixelRatio is crispness only, not size). */
-  get size(): Vec2 { return this._size ?? (this._texture ? new Vec2(this._texture.width, this._texture.height) : new Vec2(0, 0)) }
-  set size(v: Vec2Like) { this._size = new Vec2(v); _creator2d.setSpriteSize(this.id, this._size.x, this._size.y) }
-
-  get anchor(): Vec2 { return this._anchor.clone() }
-  set anchor(v: Vec2Like) { this._anchor = new Vec2(v); _creator2d.setSpriteAnchor(this.id, this._anchor.x, this._anchor.y) }
-
-  /** Set the UV sub-rect (normalized). */
-  set frame(uv: [number, number, number, number]) { _creator2d.setSpriteFrame(this.id, uv[0], uv[1], uv[2], uv[3]) }
-  /** Set the sub-rect in texture pixels. */
-  setFramePx(px: number, py: number, pw: number, ph: number): this {
-    _creator2d.setSpriteFramePx(this.id, px, py, pw, ph)
-    return this
-  }
-
-  get color(): ColorInput { return this._color }
-  set color(c: ColorInput) { this._color = c; const [ r, g, b ] = Color.toRgb01(c); _creator2d.setSpriteColor(this.id, r, g, b) }
-
-  get opacity(): number { return this._opacity }
-  set opacity(a: number) { this._opacity = a; _creator2d.setSpriteOpacity(this.id, a) }
-
-  get flipX(): boolean { return this._flipX }
-  set flipX(v: boolean) { this._flipX = v; _creator2d.setSpriteFlip(this.id, v, this._flipY) }
-  get flipY(): boolean { return this._flipY }
-  set flipY(v: boolean) { this._flipY = v; _creator2d.setSpriteFlip(this.id, this._flipX, v) }
-}