lecodes-sdk 0.19.0

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

@@ -0,0 +1,7 @@
+export declare class Registry<T> {
+    private map;
+    set(id: number, value: T): void;
+    get(id: number): T | undefined;
+    delete(id: number): void;
+    has(id: number): boolean;
+}

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

@@ -0,0 +1,29 @@
+/** Runs every pending effect now instead of waiting for the microtask (test/host hook). */
+export declare const flushEffects: () => void;
+export interface Signal<T> {
+    value: T;
+    /** Read without subscribing the current effect/computed. */
+    peek(): T;
+}
+export interface Computed<T> {
+    readonly value: T;
+    /** Read without subscribing the current effect/computed (still recomputes if stale). */
+    peek(): T;
+}
+/**
+ * A reactive value. Reading `.value` inside an `effect`/`computed` (or a function-valued style
+ * prop / `UIText` content) subscribes it; writing `.value` re-runs subscribers (batched — once
+ * per microtask).
+ */
+export declare function signal<T>(initialValue: T): Signal<T>;
+export declare function signal<T = undefined>(): Signal<T | undefined>;
+/** A lazily-cached derived value: recomputes on read after any of its dependencies changed. */
+export declare function computed<T>(fn: () => T): Computed<T>;
+/**
+ * Runs `fn` now and again whenever any signal/computed it read changes (batched per microtask).
+ * Returns a dispose function; an undisposed effect lives for the rest of the app run.
+ */
+export declare function effect(fn: () => void): () => void;
+/** The shape UINode's Element exposes for binding ownership. */
+export interface BindingHost {
+}

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

@@ -0,0 +1,31 @@
+declare class TimeClock {
+    private _scale;
+    private _paused;
+    /** The fixed step: what `updateFixed(dt)` receives, every time, on every machine (1/60). Under
+     *  `scale` the NUMBER of fixed steps per frame changes, never this value. */
+    readonly fixedDt: number;
+    /** Seconds of GAME time since the app started (scaled; stops while paused). */
+    now: number;
+    /** Seconds of wall-clock time since the app started (never stops). */
+    unscaledNow: number;
+    /** This frame's delta in game seconds — what `update(dt)` receives. 0 while paused. */
+    dt: number;
+    /** This frame's wall-clock delta in seconds (the host's frame time, clamped by the engine). */
+    unscaledDt: number;
+    /** Frames dispatched since the app started (counts paused frames too). */
+    frame: number;
+    /** Speed of the game relative to wall-clock: 1 normal, 0.5 half speed, 2 double. Applied to
+     *  `dt`, `now` AND the engines' physics / animation / particle clocks. Negative or NaN → 0. */
+    get scale(): number;
+    set scale(v: number);
+    /** Freeze the game: `dt` reads 0, aspects without `updateWhilePaused` are skipped, the engines'
+     *  simulations stop. `scale` is remembered and restored on resume. */
+    get paused(): boolean;
+    set paused(v: boolean);
+    /** The scale the engines currently run at (0 while paused). */
+    get effectiveScale(): number;
+    private _push;
+}
+/** The game clock — scale / pause the whole game, read `dt` / `now` anywhere. */
+export declare const Time: TimeClock;
+export {};

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

@@ -0,0 +1,19 @@
+import { Vec2, type Vec2Like } from "../math/vec";
+import type { CompAxis, CompWriter } from "../core/compWrite";
+export declare class Camera2D implements CompWriter {
+    private _x;
+    private _y;
+    private _zoom;
+    private _rotation;
+    private readonly sceneId;
+    constructor(sceneId: number);
+    get position(): Vec2;
+    set position(v: Vec2Like);
+    _writeComp(_prop: string, axis: CompAxis, v: number): void;
+    get zoom(): number;
+    set zoom(z: number);
+    get rotation(): number;
+    set rotation(deg: number);
+    screenToWorld(screenX: number, screenY: number): Vec2;
+    worldToScreen(worldX: number, worldY: number): Vec2;
+}

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

@@ -0,0 +1,134 @@
+import { Aspect } from "../core/Aspect";
+import type { FieldMeta } from "../core/fields";
+import { Vec2, type Vec2Like } from "../math/vec";
+import type { CompWriter } from "../core/compWrite";
+import { PhysicsGroup2D } from "./groups2d";
+import { type Node2D } from "./Node2D";
+/** Where the character's feet are, as reported by the solver after the last step. */
+export type GroundState2D = "ground" | "slope" | "air";
+/** One surface the mover pushed out of this step. `normal` points back at the character. */
+export type Collision2D = {
+    node: Node2D | null;
+    normal: Vec2;
+};
+export declare class CharacterController2D extends Aspect<"controller", Node2D> implements CompWriter {
+    static readonly aspect = "controller";
+    static fields: FieldMeta<CharacterController2D>;
+    private _id;
+    private _gravityScale;
+    private _maxSlope;
+    private _group;
+    private _dropThrough;
+    private _repush;
+    onAttach(): void;
+    onDetach(): void;
+    /** Native character id (0 until attached / no physics support). */
+    get id(): number;
+    /**
+     * 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).
+     *
+     * ONE component = horizontal, the everyday platformer call. TWO = the whole velocity, for free mode
+     * (`gravityScale = 0`); with gravity on, a two-component call fights the ballistic vertical and the
+     * character hangs in the air, so that combination warns once.
+     *
+     * 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): void;
+    move(x: number, y: number): void;
+    move(v: Vec2Like): void;
+    private _warnFree;
+    /** Vertical velocity (world units/s) — LATCHED: gravity works on it, you seed it. `= 700` to jump,
+     *  `+= 300` 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). Does nothing in free mode. `velocity.y = 700` is
+     *  the same channel — pick whichever reads better. */
+    get velocityY(): number;
+    set velocityY(v: number);
+    /**
+     * READ — the velocity the solver ended up with after the most recent step (world units/s, fresh
+     * Vec2): what HAPPENED, not what you asked for. Walking into a wall reads ~0, sliding along one
+     * reads the tangent.
+     *
+     * 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 * 600, 400]          // hit by the blast
+     *     if (thrown) { if (hero.controller.grounded) thrown = false }   // landing ends it
+     *     else hero.controller.move(ix * SPEED)                          // …and this reclaims the axis
+     *
+     * Nothing clears the latch by itself, landing included — a kinematic controller has no friction.
+     * Reading is not the inverse of writing: against a wall the read is ~0 and would cancel the throw.
+     *
+     * `c.velocity.y = 700` (the direct spelling) is a jump — the compiler routes it to the exact
+     * `velocityY` channel via `_writeComp` below — and `c.velocity.x = 300` latches the whole vector
+     * with the measured vertical filling in. A STORED copy is still a copy (`const v = c.velocity`).
+     */
+    get velocity(): Vec2;
+    set velocity(v: Vec2Like);
+    /** Compile-time list (chisel reads it, then strips it) — see CharacterController / core/compWrite.ts. */
+    static _comps: string[];
+    /** True while standing on walkable ground. */
+    get grounded(): boolean;
+    /** Where the feet are after the last step: walkable ground, too-steep ground, or the air. */
+    get groundState(): GroundState2D;
+    /** The surface normal under the feet — for orienting a sprite to a slope, or deciding a slide. */
+    get groundNormal(): Vec2;
+    /** What the character is standing on: a moving platform, a hazard, an ice patch whose `friction`
+     *  the game can read. The engine already carries the character along a kinematic platform. */
+    get groundNode(): Node2D | null;
+    /**
+     * Every surface the mover pushed out of during the last step, with the normal pointing back at the
+     * character. This is what wall jumps and box pushing are written against — a kinematic mover is not
+     * a body, so those contacts do not arrive as 'enter' events.
+     *
+     *     const wall = c.collisions.find(h => Math.abs(h.normal.x) > 0.7)
+     *     if (wall && jumpPressed) c.velocity = [-wall.normal.x * KICK, JUMP]
+     *
+     *     for (const h of c.collisions) h.node?.physics?.applyImpulse([-h.normal.x * PUSH, 0])
+     */
+    get collisions(): Collision2D[];
+    /** Multiplier over the world gravity; default 1. **0 = free mode**: no gravity, no ground, no
+     *  stick-to-floor — a swimmer, a drone, a ladder climber, or a top-down hero, driven by the
+     *  two-component `move()`. */
+    get gravityScale(): number;
+    set gravityScale(v: number);
+    /** Max ground slope (degrees) the character treats as walkable; default 45. Live. */
+    get maxSlope(): number;
+    set maxSlope(v: number);
+    /** Which collision group the character belongs to. Live. */
+    get group(): PhysicsGroup2D | undefined;
+    set group(g: PhysicsGroup2D | undefined);
+    /**
+     * While this names a node, that node's `OneWay2D` surfaces are not solid for this character — how
+     * you drop off a semisolid platform. A plain latch: whoever sets it clears it.
+     *
+     *     if (downPressed && jumpPressed && c.grounded) {
+     *       const platform = c.groundNode
+     *       c.dropThrough = platform
+     *       setTimeout(() => { if (c.dropThrough === platform) c.dropThrough = null }, 200)
+     *     }
+     *
+     * Because it names ONE node, the timeout is not delicate: too long merely means you could have
+     * re-landed on that platform for a moment, and the platform below stays solid either way.
+     */
+    get dropThrough(): Node2D | null;
+    set dropThrough(n: Node2D | null);
+    /**
+     * True while a requested collider resize hasn't taken — you asked to stand up and there is something
+     * overhead. Resizing goes through the `Shape2D` aspect itself:
+     *
+     *     hero.aspect(Shape2D, { capsule: CROUCHED })   // always fits — you are shrinking
+     *     hero.aspect(Shape2D, { 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;
+    private _state;
+}

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

@@ -0,0 +1,91 @@
+import { AspectHost } from "../core/Aspect";
+import type { CompAxis, CompWriter } from "../core/compWrite";
+import { Registry } from "../core/registry";
+import { Vec2, type Vec2Like } from "../math/vec";
+import type { ClickEvent, TouchStartEvent } from "../runtime/touch";
+export { Vec2, type Vec2Like };
+export type Node2DEvents = {
+    /** A looping animation clip wrapped around (fires each loop). */
+    loopReached: (clip: string) => void;
+    /** A non-looping animation clip finished. */
+    completed: (clip: string) => void;
+    /** A physics contact / sensor overlap began (the other node, plus where and how hard). The
+     *  contact's `normal` points AWAY from the other node, so `normal.y > 0.7` reads as "I landed on
+     *  top of it". Sensor overlaps and `exit` carry zeros. */
+    enter: (other: Node2D, contact: Contact2D) => void;
+    exit: (other: Node2D, contact: Contact2D) => void;
+    /** Pointer up over this node's Physics2D shape (a tap/click). */
+    click: (ev: ClickEvent<Node2D | null>) => void;
+    /** Pointer down on this node's Physics2D shape. Call ev.track(...) to capture the drag. */
+    touchstart: (ev: TouchStartEvent<Node2D | null>) => void;
+};
+/** Where a contact happened, delivered as the second argument of 'enter'. `speed` is the approach
+ *  speed at impact (world units/s) — scale an impact sound with it. Zeros on sensor and 'exit'
+ *  events, which have no manifold. */
+export type Contact2D = {
+    point: Vec2;
+    normal: Vec2;
+    speed: number;
+};
+/** id → Node2D, so host callbacks (animation events) route back to the owning JS object. */
+export declare const node2dRegistry: Registry<Node2D>;
+export declare class Node2D extends AspectHost<Node2DEvents> implements CompWriter {
+    /** Native entity handle. */
+    readonly id: number;
+    /** Optional debug/editor name (plain JS data — scene2d files stamp their node names here). */
+    name?: string;
+    protected _x: number;
+    protected _y: number;
+    protected _rotation: number;
+    protected _sx: number;
+    protected _sy: number;
+    protected _layer: number;
+    protected _z: number;
+    protected _visible: boolean;
+    private _pushXf;
+    private _parent;
+    private _children;
+    constructor(internalId?: number);
+    private _pull;
+    get x(): number;
+    set x(v: number);
+    get y(): number;
+    set y(v: number);
+    _writeComp(_prop: string, axis: CompAxis, v: number): void;
+    get position(): Vec2;
+    set position(v: Vec2Like);
+    /** Rotation in degrees (CCW). */
+    get rotation(): number;
+    set rotation(deg: number);
+    get scale(): Vec2;
+    set scale(v: Vec2Like | number);
+    /** Draw layer (int). Higher layers render on top. */
+    get layer(): number;
+    set layer(v: number);
+    /** Intra-layer depth for non-Y-sorted layers (higher z = on top). */
+    get z(): number;
+    set z(v: number);
+    get visible(): boolean;
+    set visible(v: boolean);
+    get parent(): Node2D | null;
+    set parent(p: Node2D | null);
+    get children(): readonly Node2D[];
+    /** Attach children to this node (each keeps its current world transform). Returns this. */
+    add(...children: Node2D[]): this;
+    /** Detach a direct child (reparents it to root, keeping its world transform). Returns this. */
+    remove(child: Node2D): this;
+    /**
+     * Reparent this node. `keepWorld` (default true) recomputes the local transform so the on-screen
+     * position/rotation/scale is unchanged; pass false to keep the local transform and move with the
+     * new parent. Self/descendant parents are rejected natively (no cycles).
+     */
+    setParent(parent: Node2D | null, keepWorld?: boolean): this;
+    /** World-space position (composes all ancestors). */
+    get worldPosition(): Vec2;
+    /** Convert a world-space point into this node's local space (and back). */
+    worldToLocal(p: Vec2Like): Vec2;
+    localToWorld(p: Vec2Like): Vec2;
+    private _syncLocalFromNative;
+    addEventListener<K extends keyof Node2DEvents>(channel: K, callback: Node2DEvents[K]): void;
+    destroy(): void;
+}

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

@@ -0,0 +1,24 @@
+import { Aspect } from "../core/Aspect";
+import { type Vec2Like } from "../math/vec";
+import type { Node2D } from "./Node2D";
+export declare class OneWay2D extends Aspect<"oneWay", Node2D> {
+    static readonly aspect = "oneWay";
+    private _normal;
+    private _arc;
+    private _enabled;
+    /** Which side is solid. Default `[0, 1]` — solid from above, i.e. a floor you pass through from
+     *  below. `[1, 0]` is a wall you can only enter from the left. */
+    get normal(): Vec2Like;
+    set normal(v: Vec2Like);
+    /** How far off `normal` an approach still counts as coming from the solid side, in degrees.
+     *  Default 90 — the whole half-plane, which is what a platform wants. */
+    get arc(): number;
+    set arc(v: number);
+    /** Turn the one-way behaviour off, making the surface solid from both sides again. */
+    get enabled(): boolean;
+    set enabled(v: boolean);
+    onAttach(): void;
+    onDetach(): void;
+    onReconfigure(): void;
+    private _push;
+}

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

@@ -0,0 +1,147 @@
+import { Aspect } from "../core/Aspect";
+import { Vec2, type Vec2Like } from "../math/vec";
+import { type Node2D } from "./Node2D";
+import { PhysicsGroup2D } from "./groups2d";
+export type MotionType = "static" | "kinematic" | "dynamic";
+/** A neutral solid surface. Deliberately the same default as 3D `Physics.friction`. */
+export declare const DEFAULT_FRICTION = 0.6;
+export interface PhysicsConfig {
+    /** Gravity in world units/s² (Y-up: down is negative). Default [0, -980]. */
+    gravity?: Vec2Like;
+    /** Pixels per meter — tunes Box2D's internal tolerances; you still author in world units. Default 64.
+     *  Only applies before the world exists (it is a global solver tolerance). */
+    pixelsPerMeter?: number;
+    /** Solver sub-steps per fixed step. Default 4. */
+    subSteps?: number;
+}
+/** Closest raycast hit. */
+export interface RayHit {
+    node: Node2D | null;
+    point: Vec2;
+    normal: Vec2;
+    fraction: number;
+}
+export declare class Physics2D extends Aspect<"physics", Node2D> {
+    static readonly aspect = "physics";
+    private _motion;
+    /** Static (walls, floors), kinematic (script-driven platforms), or dynamic (fully simulated).
+     *  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 _mass;
+    private _friction;
+    private _bounce;
+    private _gravityScale;
+    private _linearDamping;
+    private _angularDamping;
+    private _group;
+    private _repush;
+    private _h;
+    /** Which collision group this body belongs to (see Physics2D.addGroup). Live. */
+    get group(): PhysicsGroup2D | undefined;
+    set group(g: PhysicsGroup2D | undefined);
+    /** Mass in world units. Omitted (or 0) = derived from the collider's AREA, so a big crate really is
+     *  heavier than a small one. Setting it scales the shape-derived mass data, keeping the rotational
+     *  inertia in the same ratio — a lopsided collider still tips the way its geometry says. */
+    get mass(): number;
+    set mass(v: number);
+    /** Surface friction. 0 is frictionless, ~1 grippy; two bodies COMBINE as sqrt(a×b), so the lower
+     *  value wins the argument. Default 0.6 — a neutral solid, matching 3D. */
+    get friction(): number;
+    set friction(v: number);
+    /** Bounciness, 0..1 — the fraction of the approach speed returned on impact. Two bodies combine as
+     *  MAX (the bouncier one wins — the opposite of friction), and below ~64 units/s no bounce is
+     *  applied at all, which is what stops a ball jittering on the floor forever. */
+    get bounce(): number;
+    set bounce(v: number);
+    private _pushMaterial;
+    /** Native physics body id. 0 until attached, or if the build has no physics support. Mirrors 3D `Physics.id`. */
+    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);
+    /** Angular velocity in degrees/second. */
+    get angularVelocity(): number;
+    set angularVelocity(degPerSec: number);
+    /** Per-body gravity multiplier: 1 = full world gravity, 0 = floats, <0 = repelled. */
+    get gravityScale(): number;
+    set gravityScale(scale: number);
+    get linearDamping(): number;
+    set linearDamping(d: number);
+    get angularDamping(): number;
+    set angularDamping(d: number);
+    /** Pause this body — it stops simulating and stops colliding until re-enabled. */
+    set enabled(v: boolean);
+    /** Box2D puts resting bodies to sleep; wake one to make it react to a change you made by hand. */
+    set awake(v: boolean);
+    /** Apply an instantaneous impulse at the centre of mass (never spins the body) and wake it. */
+    applyImpulse(v: Vec2Like): this;
+    /** Apply an impulse at a WORLD point — the lever arm becomes spin. Use this when the push has a real
+     *  point of contact: a bullet's hit point, a blast pushing a prop at its base. */
+    applyImpulseAt(v: Vec2Like, worldPoint: Vec2Like): this;
+    /** Apply a continuous force (world units) and wake the body. */
+    applyForce(v: Vec2Like): this;
+    /** Set the world's gravity / solver settings. OPTIONAL: the world is created on the first body with
+     *  gravity [0, -980], 64 px/m and 4 sub-steps. Calling this later changes gravity LIVE and leaves
+     *  bodies alone. */
+    static configure(config?: PhysicsConfig): void;
+    /** World gravity, live. */
+    static get gravity(): Vec2;
+    static set gravity(g: Vec2Like);
+    private static _gravity;
+    /** Whether this build has physics support (CREATOR_2D_PHYSICS). NOTE: this reports the BUILD, not
+     *  the world — there is nothing else to guard, since the world creates itself. */
+    static get supported(): boolean;
+    /** Render interpolation of body transforms between the fixed 60 Hz steps (global; default on). Turn
+     *  off to save per-frame transform writes when you have many moving bodies / don't need >60 Hz
+     *  smoothness — bodies then advance in discrete steps. */
+    private static _interpolation;
+    static get interpolation(): boolean;
+    static set interpolation(on: boolean);
+    /**
+     * Register a collision group. Groups are SUBTRACTIVE and SYMMETRIC (see groups2d.ts):
+     *
+     *     const player  = Physics2D.addGroup()
+     *     const bullets = Physics2D.addGroup().ignoreSelf().ignore(player)
+     */
+    static addGroup(label?: string): PhysicsGroup2D;
+    /** The implicit group of every body that never named one - name it to exclude "everything else". */
+    static get defaultGroup(): PhysicsGroup2D;
+    /** Closest body hit by the segment, or null. `node` resolves the hit entity. */
+    static raycast(from: Vec2Like, to: Vec2Like, q?: Query2D): RayHit | null;
+    /** Every body along the segment, NEAREST FIRST - a piercing bullet, a laser, "how many walls are
+     *  between us". Capped at 32 hits. */
+    static raycastAll(from: Vec2Like, to: Vec2Like, q?: Query2D): RayHit[];
+    /** Topmost body (solid or sensor) whose shape contains the world point, or null. "Topmost" means
+     *  by DRAW order - layer, then z - so picking agrees with what the player sees. */
+    static overlapPoint(p: Vec2Like, q?: Query2D): Node2D | null;
+    /** Everything within `radius` of a point - an explosion, an aura, an aggro range. */
+    static overlapCircle(centre: Vec2Like, radius: number, q?: Query2D): Node2D[];
+    /** Everything inside an axis-aligned box (centre + HALF-extents) - a room, a camera bound. */
+    static overlapBox(centre: Vec2Like, half: Vec2Like, q?: Query2D): Node2D[];
+    /**
+     * Everything touching a capsule from-to of the given radius. A capsule is the shape a DIRECTED
+     * question has: a beam with width, a sword arc, "does my radius fit through this gap" - none of
+     * which an axis-aligned box can express.
+     *
+     * It is also the SWEPT test: a circle of radius r moving from A to B during a frame sweeps exactly
+     * this capsule, so a fast projectile checked this way cannot tunnel through a thin wall the way two
+     * separate position checks do.
+     */
+    static overlapCapsule(from: Vec2Like, to: Vec2Like, radius: number, q?: Query2D): Node2D[];
+}
+/** Which groups a query may hit, and what to skip. */
+export type Query2D = {
+    /** Only hit bodies in these groups. Omitted = everything. */
+    groups?: PhysicsGroup2D[];
+    /** Skip these nodes - the "don't hit myself" case a ray fired from inside its own body needs. */
+    ignore?: Node2D | Node2D[];
+};

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

@@ -0,0 +1,72 @@
+import { type ColorInput } from "../core/color";
+import { type Aspect, type AspectCtor, type FieldOf, type TargetOf } from "../core/Aspect";
+import { Presentable, type PresentOptions } from "../ui/presentable";
+import { type Vec2Like } from "../math/vec";
+import type { ClickEvent, TouchStartEvent } from "../runtime/touch";
+import { Camera2D } from "./Camera2D";
+import { type Node2D } from "./Node2D";
+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. */
+declare class LayerHandle {
+    private readonly sceneId;
+    private readonly layer;
+    constructor(sceneId: number, layer: number);
+    /** In this layer, lower-on-screen sprites overlap higher ones (top-down feet sorting). */
+    ySort(enabled?: boolean): this;
+}
+export declare class Scene2D implements Presentable {
+    /** Native scene handle. */
+    readonly id: number;
+    readonly camera: Camera2D;
+    private static _active;
+    static get active(): Scene2D | null;
+    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?;
+    constructor(options?: Scene2DOptions);
+    set background(color: ColorInput);
+    /** Address a draw layer to configure it, e.g. scene2d.layer(1).ySort(). */
+    layer(n: number): LayerHandle;
+    /** 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;
+    /** 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;
+    removeEventListener(channel: "click" | "touchstart", callback: (ev: any) => void): void;
+    add(...nodes: Node2D[]): this;
+    remove(...nodes: Node2D[]): this;
+    /** 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. */
+    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. */
+    get<A extends Aspect<any, any, any>>(ctor: AspectCtor<A>): 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>;
+    /** Detach a system (runs its onDetach). Chainable. */
+    removeSystem<A extends Aspect<any, any, any>>(ctor: AspectCtor<A>): this;
+    readonly cl: (() => void)[];
+    _backButtonCallback?: () => void;
+    private _vd?;
+    /** Fires when the scene becomes the visible destination (incl. a pop revealing it). */
+    onOpen(callback: () => void): this;
+    /** Fires when the scene stops being visible (closed, replaced, or covered by a push). */
+    onClose(callback: () => void): this;
+    onBackPressed(callback: () => void): 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;
+    close(): this;
+    destroy(): void;
+}
+export {};

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

@@ -0,0 +1,58 @@
+import { Aspect } from "../core/Aspect";
+import { type Vec2Like } from "../math/vec";
+import type { Node2D } from "./Node2D";
+export declare 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;
+    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.
+     */
+    onReconfigure(): void;
+    private _create;
+    /**
+     * 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;
+    private _signature;
+}