incanto 0.69.0 → 0.71.0

package/dist/2d.d.ts

@@ -1,9 +1,10 @@
-import { c as showBootFailure, i as ParticleSim, o as ParticleView, r as SpatialPose, s as isWebGLAvailable } from "./audio-player-C0j2k-yB.js";
-import { P as Scene$1, S as Scheduler, T as RendererStats, b as Engine, d as PropSchema, jt as Node, n as BehaviorCtor, w as GameStats, x as EngineOptions } from "./behavior-rm8vVzu_.js";
-import { n as DiagnosticSink, t as EditorSwitchOptions } from "./editor-switch-CnIOiyNJ.js";
-import { i as SceneJson, s as JsonObject } from "./schema-B6ugCV1Q.js";
+import { c as showBootFailure, i as ParticleSim, o as ParticleView, r as SpatialPose, s as isWebGLAvailable } from "./audio-player-L8yccdMP.js";
+import { P as Scene$1, S as Scheduler, T as RendererStats, b as Engine, d as PropSchema, jt as Node, n as BehaviorCtor, w as GameStats, x as EngineOptions } from "./behavior-Dcz0fr1S.js";
+import { t as DiagnosticSink } from "./diagnostics-Cu85N3tL.js";
+import { a as SceneJson, s as JsonObject } from "./rng-Bb-IutXB.js";
+import { t as EditorSwitchOptions } from "./editor-switch-CFU9mCec.js";
 import { r as FrameStats } from "./frame-report-DNxDAb1w.js";
-import { t as LoadSceneOptions } from "./loader-DadV2QCT.js";
+import { t as LoadSceneOptions } from "./loader-8-IHvbKD.js";
 import { n as AnimationEntry } from "./sprite-animation-CMr6f1K2.js";
 import { Group, Mesh, Object3D, Scene, Texture } from "three";
 import * as RapierNs from "@dimforge/rapier2d-compat";
@@ -53,6 +54,17 @@ declare class AssetStore2D {
   /** Load status of a declared asset KEY (no '$'), or undefined if unknown. */
   status(key: string): AssetStatus | undefined;
   getTexture(ref: string): Texture;
+  /**
+  * Hand the GPU back.
+  *
+  * `AssetStore3D` has had this since it was written and the 2D twin never got
+  * one, so a game that swapped scenes or unmounted kept every texture it had
+  * ever decoded. `Renderer2D.dispose` walked its scene graph and disposed
+  * `material.map` instead — which frees only what is CURRENTLY drawn (a sheet
+  * loaded and never used stayed resident), and disposes the STORE'S texture
+  * out from under a caller who injected their own store.
+  */
+  dispose(): void;
   getSheet(ref: string): SheetInfo;
   private resolve;
 }
@@ -161,7 +173,7 @@ declare class Area2D extends PhysicsBody2D {
   * Who is inside RIGHT NOW — the standing answer behind the enter/exit pair.
   * See `Area3D.overlapping`. Empty in a scene with no physics world.
   */
-  overlapping(group?: string): PhysicsBody2D[];
+  overlapping(group?: string | undefined): PhysicsBody2D[];
 }
 /** Dynamic simulated body. */
 declare class RigidBody2D extends PhysicsBody2D {
@@ -174,6 +186,38 @@ declare class RigidBody2D extends PhysicsBody2D {
   restitution: number;
   /** px/s, y-down. Read back every step; write to launch. */
   linearVelocity: number[];
+  /**
+  * rad/s about the z axis — the same sign as `rotation`, which is CLOCKWISE
+  * in this y-down space. Read back every step; write to spin.
+  *
+  * `RigidBody3D` got its `angularVelocity` because "a puzzle builder could
+  * neither launch a spinning body nor read how fast a lever was swinging —
+  * only its angle, differenced by hand". Same sentence, same defect, other
+  * adapter: 2D had `linearVelocity` and no counterpart. `fixedRotation` pins
+  * it at zero.
+  */
+  angularVelocity: number;
+  /**
+  * The other name for `linearVelocity`, because it is the name every skill,
+  * every sibling node and every other engine uses.
+  *
+  * `body.velocity = [0, -400]` is what `incanto-physics-and-input.md` taught
+  * for years. On a plain TS class that assignment SUCCEEDS — it just writes a
+  * stray field nothing reads — so a jump that never happened produced no
+  * error, no warning and nothing to search for. `CharacterBody2D.velocity`
+  * next to `RigidBody2D.linearVelocity` is the kind of near-miss a builder
+  * cannot be expected to notice.
+  *
+  * Scene JSON still names the prop `linearVelocity` and rejects `velocity`
+  * loudly, with the valid keys listed — a hard error corrects itself.
+  */
+  get velocity(): number[];
+  set velocity(v: number[]);
+  /**
+  * Impulse in px·kg/s (y-down) — the 3D twin has had this since it shipped,
+  * and calling it here was a TypeError.
+  */
+  applyImpulse(impulse: [number, number]): void;
 }
 /**
 * Kinematic body on Rapier's character controller. Gravity is NOT applied
@@ -195,6 +239,17 @@ declare class CharacterBody2D extends PhysicsBody2D {
   stickToGround: boolean;
   /** Max climbable slope angle. */
   slopeLimitDeg: number;
+  /**
+  * How high a step this body walks up without jumping, in PIXELS.
+  *
+  * Rapier's character controller does not autostep unless it is asked, and in
+  * 2D nothing asked: a ledge of ANY height — measured, ONE pixel — stopped a
+  * walking body dead, while the mirrored `CharacterBody3D` has cleared 0.35 m
+  * by default since 0.63. The default here is that same 0.35 m at the 2D
+  * world's own scale (100 px = 1 m, which is why gravity defaults to 980).
+  * `0` restores the old behaviour.
+  */
+  stepHeight: number;
   /** @internal Updated by Physics2D.moveAndSlide. */
   _grounded: boolean;
   moveAndSlide(): void;
@@ -263,6 +318,22 @@ declare class Physics2D {
   /** Whether the solver runs at all. False = collider outlines only. */
   private readonly simulate;
   step(dt: number): void;
+  /**
+  * May `candidate` carry `rider`?
+  *
+  * The rule used to be "never a CharacterBody2D", which is the whole CLASS —
+  * and a `CharacterBody2D` animated by POSITION WRITES is the documented
+  * moving-platform path (`Oscillate`, `MoveTo`, `PathFollow`, or a behaviour of
+  * your own). `incanto-physics-and-input.md` promises twice that a character
+  * standing on ANY moving body is carried; it was not, and the rider reported
+  * `isOnFloor() === true` the whole time while sliding off in world space.
+  *
+  * What the guard was really for is a CYCLE: two characters standing on each
+  * other would carry each other forever. So the test is the rider's own
+  * carrier chain, not the type — a platform that is not (transitively) riding
+  * you can carry you.
+  */
+  private canCarry;
   /** @internal Called by CharacterBody2D.moveAndSlide (during tree fixedUpdate). */
   moveAndSlide(node: CharacterBody2D): void;
   /** Rapier debug segments, scaled back to pixels. Null while debugDraw is off. */
@@ -292,7 +363,31 @@ declare class Physics2D {
   /** The bodies currently overlapping `node`. Freed nodes are dropped on read. */
   overlapping(node: PhysicsBody2D): PhysicsBody2D[];
   /**
-  * World-space raycast in PIXELS (y-down). `exclude` skips that body — a
+  * Mass the solver actually uses (collider-derived unless overridden).
+  *
+  * The 3D twin has had this since `CharacterController3D` needed it to size an
+  * impulse; 2D had no way to ask, so a 2D game scaling a push by mass had to
+  * read the AUTHORED `mass` prop and hope it was the number Rapier settled on.
+  */
+  massOf(node: PhysicsBody2D): number;
+  /**
+  * Current solver velocity in px/s (fresher than the node prop mid-step).
+  *
+  * `linearVelocity` is written back once per step, so a behavior reading it
+  * from inside `fixedUpdate` — after a collision, before the write-back — sees
+  * the value from BEFORE the impact. That is exactly when a game wants to know
+  * how hard it hit something.
+  */
+  velocityOf(node: PhysicsBody2D): [number, number];
+  /**
+  * A world-space impulse in px.kg/s (y-down) — the 2D twin of
+  * `Physics3D.applyImpulse`, which the physics skill has documented for both
+  * adapters while only one of them had it.
+  */
+  applyImpulse(node: PhysicsBody2D, impulse: [number, number]): void;
+  /**
+  * World-space raycast in PIXELS (y-down); `dir` may be any length (it is
+  * normalized), so `distance` and `maxLen` are pixels. `exclude` skips that body — a
   * shooter probing from inside its own collider needs it. Sensors (Area2D)
   * never block rays. Returns distance (px), the surface normal, and the hit
   * body — or null.
@@ -303,6 +398,27 @@ declare class Physics2D {
     distance: number;
     normal: [number, number];
     node: PhysicsBody2D | null;
+    point: [number, number];
+  } | null;
+  /**
+  * Sweep a CIRCLE of `radius` from `origin` along `dir` — a thick ray, in
+  * pixels. The 2D twin of `Physics3D.castSphere`.
+  *
+  * 3D has had this since the camera spring arm needed it and 2D never got it,
+  * so the shared `PhysicsQuery` interface declares it OPTIONAL and every 2D
+  * game that wanted a probe with THICKNESS — a shot that must not thread a
+  * one-pixel gap between two tiles, a ledge feeler, a camera that should not
+  * clip a wall it skims — had to fire several thin rays and hope.
+  *
+  * Same filters as `castRay`: sensors never hit, `staticOnly` ignores dynamic
+  * and kinematic bodies, `dir` may be any length. Returns the travel distance
+  * of the circle's CENTRE, or null when the sweep is clear.
+  */
+  castSphere(origin: [number, number], dir: [number, number], radius: number, maxLen: number, exclude?: PhysicsBody2D, opts?: {
+    staticOnly?: boolean;
+  }): {
+    distance: number;
+    node: PhysicsBody2D | null;
   } | null;
   dispose(): void;
   private lastStructure;
@@ -357,6 +473,14 @@ interface CreateGame2DOptions {
   * Attach pointer input (mouse, finger or pen) to the canvas: positions for
   * `input.pointerPosition()`, buttons for `input.mousePressed()`.
   * `{ lockOnClick: true }` captures the cursor — rare in 2D, so it is off.
+  *
+  * Omitted, it is AUTO: attached when the scene contains a `Clickable`, the
+  * same way `physics: 'auto'` turns Rapier on for a scene with bodies. It used
+  * to default OFF, so a board of clickable tiles did nothing when clicked —
+  * with no error, a clean `incanto-check` and a clean audit, while the skill
+  * that introduces the behaviour says it "needs no code at all". Pass `true`
+  * when a behaviour of your own reads `pointerPosition()`; nothing here can
+  * see that.
   */
   pointer?: boolean | {
     lockOnClick?: boolean;
@@ -412,6 +536,20 @@ interface CreateGame2DOptions {
   /** Renderer extras (pixelRatio, antialias, custom asset store). */
   pixelRatio?: number;
   antialias?: boolean;
+  /**
+  * Keep the drawing buffer readable so the canvas can be screenshot.
+  *
+  * WebGL clears it the instant a frame composites, so `toDataURL()` — and
+  * every screenshot built on it — is BLANK without this. Off by default: it
+  * costs a buffer copy per frame and only a run that means to look at the
+  * output should pay for it. `environment.rendering.preserveDrawingBuffer`
+  * does the same from the scene.
+  *
+  * The 2D renderer has always honoured the scene key; only the boot-site
+  * override was 3D-only, so a 2D game whose harness wanted a screenshot had to
+  * edit its scene file to get one.
+  */
+  preserveDrawingBuffer?: boolean;
   resolveScene?: LoadSceneOptions["resolveScene"];
   /** @internal Test seam — replaces the Renderer2D construction. */
   _rendererFactory?: (engine: Engine, canvas: HTMLCanvasElement) => GameRenderer;
@@ -569,6 +707,18 @@ declare class Sprite2D extends Node2D {
   protected resolveTexture(assets: AssetStore2D | null): ResolvedSpriteTexture | null;
   override _staticReady(assets: AssetStore2D | null): boolean;
   override _syncObject2D(assets: AssetStore2D | null): void;
+  /**
+  * The material is PER NODE and nothing freed it.
+  *
+  * The geometry is shared for the process (`UNIT_PLANE`, on purpose), but
+  * every sprite makes its own `MeshBasicMaterial` — and a 2D game that spawns
+  * and frees sprites, which is every 2D game, leaked one per node forever.
+  * The TEXTURE is not touched: it belongs to the asset store and is shared by
+  * every node that names the same key.
+  *
+  * `AnimatedSprite2D` extends this, so it is covered by the same override.
+  */
+  override free(): void;
 }
 //#endregion
 //#region src/2d/nodes/animated-sprite-2d.d.ts
@@ -636,6 +786,8 @@ declare class Camera2D extends Node2D {
   current: boolean;
   /** `zoom` clamped to a positive floor — 0/negative zoom must never produce NaN views. */
   get effectiveZoom(): number;
+  /** The `follow` path already reported as untrackable — cleared by a new one. */
+  private warnedFollow;
   override update(dt: number): void;
   /** View center after clamping the (vw×vh)/zoom view rect inside `limits`. */
   /**
@@ -663,26 +815,6 @@ declare class Camera2D extends Node2D {
 }
 //#endregion
 //#region src/2d/nodes/character-controller-2d.d.ts
-/**
-* Preset controller: drives its PARENT CharacterBody2D from the engine
-* InputMap — JSON-only games get a playable character with zero TypeScript.
-*
-* - `platformer`: x movement + gravity (from the scene `physics.gravity[1]`,
-*   default 980) + jump (`jumpHeight` px → impulse √(2·g·h))
-* - `topDown`: full-axis movement, no gravity
-*
-* ## Why the extra platformer props exist
-*
-* A jump that only works while `isOnFloor()` is true feels BROKEN, and players
-* do not report it as "the coyote time is missing" — they report the game as
-* unresponsive. The whole schema used to be five props, so a JSON-only game got
-* a character that felt wrong and could not drive `AnimatedSprite2D.play('run')`
-* either. `examples/platformer-2d` hand-rolls all of this in a 541-line
-* behavior; these are those constants, as props.
-*
-* Every one defaults to OFF (0 / 1 / false), so an existing scene behaves
-* exactly as before until it asks for something.
-*/
 declare class CharacterController2D extends Node {
   static override readonly typeName: string;
   static readonly props: PropSchema;
@@ -718,6 +850,29 @@ declare class CharacterController2D extends Node {
   * from scene JSON instead of a behavior polling velocities.
   */
   private setState;
+  /** Actions already reported missing, so a per-frame read says it once. */
+  private readonly reportedActions;
+  /**
+  * Read an input action this controller is allowed to be missing.
+  *
+  * The 3D controller has done this since `optional-action.ts` was written —
+  * whose own docstring says "`CharacterController3D` and `GameFlow` wrap every
+  * input read" — and the 2D one did not. So a top-down 2D game, which is the
+  * first thing anyone builds with this node and has no jump key, declared
+  * `move` and got:
+  *
+  * ```
+  * [incanto] /Game/Player/Ctl (CharacterController2D) threw in fixedUpdate —
+  * this node is now SKIPPED. IncantoError: Unknown input action 'jump'.
+  * Declared actions: [move].
+  * ```
+  *
+  * SKIPPED: the character could not move either, and every tool reported the
+  * game as `✗ error in 1/1` with the reason only in the log. Tolerated because
+  * a game with no jump key is the ordinary case; reported because otherwise a
+  * TYPO in `"jumpAction"` looks exactly like a deliberate omission.
+  */
+  private readAction;
 }
 //#endregion
 //#region src/2d/nodes/color-rect-2d.d.ts
@@ -739,6 +894,20 @@ declare class ColorRect2D extends Node2D {
   /** @internal The drawable quad (lazily created under the backing object). */
   _quad(): Mesh;
   override _syncObject2D(assets: AssetStore2D | null): void;
+  /**
+  * The material is PER NODE and nothing freed it.
+  *
+  * The geometry is shared for the process (`UNIT_PLANE`, on purpose — a
+  * `THREE.Sprite` cannot be instanced and this is the discipline that replaces
+  * it), but every rect makes its own `MeshBasicMaterial`, and a 2D game that
+  * spawns and frees — bullets, coins, damage flashes, a level swap — leaks one
+  * GPU program's worth of state per node, forever.
+  *
+  * Four 3D nodes had exactly this and were fixed. These two 2D siblings make a
+  * material on the same line of the same kind of `_quad()` helper, and were
+  * not on that list.
+  */
+  override free(): void;
 }
 //#endregion
 //#region src/2d/nodes/joint-2d.d.ts
@@ -982,6 +1151,21 @@ declare class TileMap2D extends Node2D {
   set cells(value: (string | number[])[]);
   get legend(): Record<string, number>;
   set legend(value: Record<string, number>);
+  private _colors;
+  get colors(): Record<string, string>;
+  set colors(value: Record<string, string>);
+  /**
+  * The colours, in declaration order — a cell's tile index is `COLOR_BASE + i`.
+  *
+  * A synthetic index rather than a second grid: everything downstream (the
+  * collider merge, `tileAt`, `setTile`, the editor's paint tool) already
+  * speaks in indices, and one number per cell keeps it that way.
+  */
+  private palette;
+  /** `legend` plus the colour chars, which is what every cell lookup wants. */
+  private allChars;
+  /** `solid` as INDICES: an entry may name the char that painted the cell. */
+  private solidIndices;
   get solid(): number[];
   set solid(value: number[]);
   opacity: number;
@@ -992,6 +1176,62 @@ declare class TileMap2D extends Node2D {
   static validateJson(node: Node): void;
   /** The parsed index grid (test/tooling hook). */
   grid(): number[][];
+  /**
+  * Which CELL is under this world point — `null` outside the grid.
+  *
+  * The one question a tile game asks constantly and this node could not
+  * answer. `VoxelGrid3D`, the 3D grid, has had `tileAt` since it was written;
+  * the 2D one shipped `grid()` and nothing else, so every mouse-driven tile
+  * game hand-rolled the same arithmetic with the same two traps in it: cell
+  * (0,0) hangs its TOP-LEFT on the origin (so a cell's CENTRE is half a tile
+  * further on), and the origin is the node's WORLD position, not its `position`
+  * prop.
+  *
+  * Composes ancestor POSITIONS, like every other world query in the engine
+  * (`Terrain3D.heightAt`, `Water3D`); `auditScene` reports an ancestor that
+  * scales or rotates one of these, because that moves the picture and not the
+  * answer.
+  */
+  cellAt(worldX: number, worldY: number): [number, number] | null;
+  /**
+  * One cell's size in WORLD pixels — `tileSize` times this node's own scale.
+  *
+  * `scale` is an ordinary `Node2D` prop, the renderer scales the mesh by it,
+  * and `rebuildColliders` has always rebuilt when it changes — so at
+  * `scale: [2, 2]` a tile is 64 px wide on screen AND in physics. These
+  * queries divided by 32 and answered the wrong cell, in silence, which is the
+  * picture and the collider agreeing and the decider disagreeing with both.
+  *
+  * Ancestor scale is not composed here, for the same reason `worldPosition`
+  * does not: every world query in the engine reads its own props and composes
+  * ancestor POSITIONS, and `auditScene` reports an ancestor that scales one.
+  */
+  private scaledTile;
+  /** The atlas index at a cell — `-1` for an empty cell or one off the grid. */
+  tileAt(cx: number, cy: number): number;
+  /**
+  * The CENTRE of a cell, in world pixels — for putting a highlight, a marker
+  * or a spawned enemy on a tile.
+  *
+  * The centre rather than the corner, because that is where a thing goes and
+  * because the corner is the half-tile every hand-rolled version forgets.
+  */
+  worldAt(cx: number, cy: number): [number, number];
+  /**
+  * Write ONE cell, by the character the row holds — dig a tile out, drop a
+  * wall in, flip a switch.
+  *
+  * `cells` are strings and a mutation is not watched, so the documented way to
+  * change a map was to rebuild the whole row by hand
+  * (`row.slice(0, x) + c + row.slice(x + 1)`) and reassign the array. This is
+  * that, once, correctly, and it rebuilds the geometry and the colliders.
+  *
+  * A CHARACTER, not an index: `legend` may map several characters to one tile,
+  * so an index cannot say which of them you meant. `'.'` empties the cell.
+  * Returns false for a cell off the grid, or a numeric row (those hold indices
+  * — assign the row).
+  */
+  setTile(cx: number, cy: number, char: string): boolean;
   override onReady(): void;
   override update(_dt: number): void;
   private rebuildColliders;
@@ -1070,6 +1310,12 @@ interface Renderer2DOptions {
   pixelRatio?: number;
   /** MSAA on the canvas. Defaults to TRUE (Phaser parity). */
   antialias?: boolean;
+  /**
+  * Keep the drawing buffer readable so the canvas can be screenshot — see
+  * `CreateGame2DOptions`. `environment.rendering.preserveDrawingBuffer` does
+  * the same from the scene, and an explicit option here outranks it.
+  */
+  preserveDrawingBuffer?: boolean;
 }
 declare class Renderer2D {
   /**
@@ -1120,6 +1366,7 @@ declare class Renderer2D {
   private readonly engine;
   /** The texture store. Public so `renderer.assets.status(key)` is reachable. */
   readonly assets: AssetStore2D;
+  private readonly ownsAssets;
   private readonly loadedAssetScenes;
   private readonly disconnect;
   private readonly canvas;
@@ -1132,7 +1379,29 @@ declare class Renderer2D {
   /** UI-pass extent from the last render — the space HUD nodes are posed in. */
   private lastUi;
   private lastViewport;
+  /**
+  * The view the LAST render used — and, before there has been one, the
+  * documented default: the whole canvas, centred, at zoom 1.
+  *
+  * It started as `{cx: 0, cy: 0, w: 1, h: 1}`, a one-pixel canvas nobody has,
+  * and `worldFromScreen` answered from it with a straight face. Measured in a
+  * browser on a 960x540 canvas with the camera at (160, 80), before the first
+  * frame: `toWorld(480, 270)` returned `[479.5, 269.5]` — the arithmetic of a
+  * 1x1 window, and a confident number rather than a refusal.
+  */
   private lastView;
+  /**
+  * Has a frame been DRAWN?
+  *
+  * `Renderer3D` refuses every screen-space question until it has one
+  * (`if (!this.lastCamera) return null`, in `pick`, `rayFromScreen` and
+  * `worldFromScreen`); the flat renderer had no equivalent, so the engine-level
+  * `toWorld`/`toScreen` and `pick` answered from a view no frame had used. The
+  * hazard is real in exactly the place agents work: a background tab does not
+  * run rAF, so `await createGame2D(...)` there is followed by any number of
+  * questions with no frame behind them.
+  */
+  private hasRendered;
   /** The world view used by the LAST render (center/zoom/canvas size). */
   view(): View2D;
   /**
@@ -1234,13 +1503,6 @@ interface TileRect {
   w: number;
   h: number;
 }
-/**
-* Normalize the `cells` prop into an index grid. Two author formats:
-* - string rows: `"." `/`" "` = empty, digits `0-9` = tile index, anything
-*   else must be in `legend` (char → index). Unknown chars HARD-fail.
-* - number rows: passed through (`-1` = empty).
-* Ragged rows are right-padded with empty.
-*/
 declare function parseCells(cells: readonly (string | readonly number[])[], legend: Record<string, number>): number[][];
 /**
 * Greedy rectangle merge over the solid cells: maximal horizontal runs,

package/dist/2d.js

@@ -1,9 +1,9 @@
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { t as showBootFailure } from "./boot-failure-CKYrEcGF.js";
-import { t as isWebGLAvailable } from "./webgl-unavailable-Z5_g8x9H.js";
-import { a as AssetStore2D, i as syncTree2D, r as Renderer2D, t as createGame2D } from "./create-game-CwxEDlCm.js";
-import { _ as RigidBody2D, a as parseCells, c as ColorRect2D, d as AnimatedSprite2D, f as Sprite2D, g as PhysicsBody2D, h as CharacterBody2D, i as mergeSolidRects, l as CharacterController2D, m as Area2D, n as UILayer, o as Particles2D, p as Joint2D, r as TileMap2D, s as Label, t as registerNodes2D, u as Camera2D, v as StaticBody2D, y as Node2D } from "./register-DbVArsns.js";
-import { n as enablePhysics2D, t as Physics2D } from "./physics-2d-CF5yyjbj.js";
+import { t as isWebGLAvailable } from "./webgl-unavailable-C8aDbGmR.js";
+import { a as AssetStore2D, i as syncTree2D, r as Renderer2D, t as createGame2D } from "./create-game-CH4kt78v.js";
+import { _ as RigidBody2D, a as parseCells, c as ColorRect2D, d as AnimatedSprite2D, f as Sprite2D, g as PhysicsBody2D, h as CharacterBody2D, i as mergeSolidRects, l as CharacterController2D, m as Area2D, n as UILayer, o as Particles2D, p as Joint2D, r as TileMap2D, s as Label, t as registerNodes2D, u as Camera2D, v as StaticBody2D, y as Node2D } from "./register-BYQCBySi.js";
+import { n as enablePhysics2D, t as Physics2D } from "./physics-2d-FhrXUc6B.js";
 //#region src/2d/library-sprite.ts
 /**
 * What a `CharacterController2D`/`3D` will ask a skin to play, and the clip in