melonjs 20.3.0 → 20.4.0

package/build/input/gamepad.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gamepad.d.ts","sourceRoot":"","sources":["../../src/input/gamepad.ts"],"names":[],"mappings":"AAWA,UAAU,cAAc;IACvB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC;CACtE;AA8UD;;GAEG;AACH,eAAO,MAAM,OAAO;IACnB;;;;;;;;OAQG;;;;;;;;;;;IAYH;;;;;;;;;;;OAWG;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BM,CAAC;AAEX;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,WAAW,CAC1B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE;IAAE,IAAI,EAAE,SAAS,GAAG,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,EACtE,OAAO,EAAE,MAAM,GACb,IAAI,CAuDN;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAKjE;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAEtD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,iBAAiB,EAAE,CAC/B,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,OAAO,CAAC,cAAc,CAAC,KAC5B,IAAiB,CAAC"}
+{"version":3,"file":"gamepad.d.ts","sourceRoot":"","sources":["../../src/input/gamepad.ts"],"names":[],"mappings":"AAWA,UAAU,cAAc;IACvB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC;CACtE;AAsVD;;GAEG;AACH,eAAO,MAAM,OAAO;IACnB;;;;;;;;OAQG;;;;;;;;;;;IAYH;;;;;;;;;;;OAWG;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BM,CAAC;AAEX;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,WAAW,CAC1B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE;IAAE,IAAI,EAAE,SAAS,GAAG,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,EACtE,OAAO,EAAE,MAAM,GACb,IAAI,CAuDN;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAKjE;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAEtD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,iBAAiB,EAAE,CAC/B,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,OAAO,CAAC,cAAc,CAAC,KAC5B,IAAiB,CAAC"}

package/build/input/pointer.d.ts

@@ -135,10 +135,6 @@ declare class Pointer extends Bounds {
      */
     locked: boolean;
     bind: (number | null)[];
-    /**
-     * @ignore
-     */
-    constructor(x?: number, y?: number, w?: number, h?: number);
     /**
      * initialize the Pointer object using the given Event Object
      * @param event - the original Event object

package/build/input/pointer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pointer.d.ts","sourceRoot":"","sources":["../../src/input/pointer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAUhD;;GAEG;AACH,cAAM,OAAQ,SAAQ,MAAM;IAC3B;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;;;OAKG;IACH,KAAK,EAAE,YAAY,GAAG,UAAU,GAAG,UAAU,GAAG,SAAS,CAAC;IAE1D;;;OAGG;IACM,IAAI,EAAE,MAAM,CAAM;IAE3B;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;;OAGG;IACH,SAAS,EAAE,OAAO,CAAC;IAEnB;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAE9B;;OAEG;IACH,YAAY,EAAE,OAAO,CAAC;IAEtB;;OAEG;IACH,MAAM,EAAE,OAAO,CAAC;IAGhB,IAAI,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;IAExB;;OAEG;gBACS,CAAC,GAAE,MAAU,EAAE,CAAC,GAAE,MAAU,EAAE,CAAC,GAAE,MAAU,EAAE,CAAC,GAAE,MAAU;IAyCtE;;;;;;;;OAQG;IACH,QAAQ,CACP,KAAK,EAAE,KAAK,EACZ,KAAK,GAAE,MAAU,EACjB,KAAK,GAAE,MAAU,EACjB,OAAO,GAAE,MAAU,EACnB,OAAO,GAAE,MAAU,EACnB,SAAS,GAAE,MAAU,GACnB,IAAI;CAqEP;AAED,eAAe,OAAO,CAAC"}
+{"version":3,"file":"pointer.d.ts","sourceRoot":"","sources":["../../src/input/pointer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAWhD;;GAEG;AACH,cAAM,OAAQ,SAAQ,MAAM;IAC3B;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;;;OAKG;IACH,KAAK,EAAE,YAAY,GAAG,UAAU,GAAG,UAAU,GAAG,SAAS,CAAC;IAE1D;;;OAGG;IACM,IAAI,EAAE,MAAM,CAAM;IAE3B;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;;OAGG;IACH,SAAS,EAAE,OAAO,CAAC;IAEnB;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAE9B;;OAEG;IACH,YAAY,EAAE,OAAO,CAAC;IAEtB;;OAEG;IACH,MAAM,EAAE,OAAO,CAAC;IAGhB,IAAI,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;IA+CxB;;;;;;;;OAQG;IACH,QAAQ,CACP,KAAK,EAAE,KAAK,EACZ,KAAK,GAAE,MAAU,EACjB,KAAK,GAAE,MAAU,EACjB,OAAO,GAAE,MAAU,EACnB,OAAO,GAAE,MAAU,EACnB,SAAS,GAAE,MAAU,GACnB,IAAI;CAqEP;AAED,eAAe,OAAO,CAAC"}

package/build/input/pointerevent.d.ts

@@ -1,11 +1,5 @@
-import type Application from "../application/application.ts";
 import type { Vector2d } from "../math/vector2d.ts";
 import Pointer from "./pointer.ts";
-/**
- * reference to the active application instance
- * @ignore
- */
-export declare let _app: Application;
 /**
  * the default target element for pointer events (usually the canvas element in which the game is rendered)
  */

package/build/input/pointerevent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pointerevent.d.ts","sourceRoot":"","sources":["../../src/input/pointerevent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,+BAA+B,CAAC;AAE7D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAepD,OAAO,OAAO,MAAM,cAAc,CAAC;AAoBnC;;;GAGG;AACH,eAAO,IAAI,IAAI,EAAE,WAAW,CAAC;AAqiB7B;;GAEG;AACH,eAAO,IAAI,kBAAkB,EAAE,WAAW,GAAG,IAAW,CAAC;AAEzD;;GAEG;AACH,eAAO,MAAM,OAAO,EAAE,OAAiC,CAAC;AAExD;;GAEG;AACH,eAAO,IAAI,MAAM,EAAE,OAAe,CAAC;AAEnC;;;;GAIG;AACH,eAAO,IAAI,kBAAkB,EAAE,MAAM,GAAG,SAAS,CAAC;AAElD;;;GAGG;AACH,wBAAgB,eAAe,IAAI,OAAO,CAEzC;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,IAAI,OAAO,CAE7C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAY1E;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC7B,OAAO,EAAE,iBAAiB,EAC1B,KAAK,CAAC,EAAE,MAAM,GACZ,IAAI,CAEN;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,CAanD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAGnD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,oBAAoB,CACnC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,GAAG,EACX,QAAQ,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,GAAG,IAAI,GAC5C,IAAI,CAsCN;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAClC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,GAAG,EACX,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,GAAG,IAAI,GAC7C,IAAI,CAiCN;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,GAAG,GAAG,IAAI,CAMzD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAO5C;AAED;;;GAGG;AACH,wBAAgB,eAAe,IAAI,OAAO,CAMzC"}
+{"version":3,"file":"pointerevent.d.ts","sourceRoot":"","sources":["../../src/input/pointerevent.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAepD,OAAO,OAAO,MAAM,cAAc,CAAC;AA6kBnC;;GAEG;AACH,eAAO,IAAI,kBAAkB,EAAE,WAAW,GAAG,IAAW,CAAC;AAEzD;;GAEG;AACH,eAAO,MAAM,OAAO,EAAE,OAAiC,CAAC;AAExD;;GAEG;AACH,eAAO,IAAI,MAAM,EAAE,OAAe,CAAC;AAEnC;;;;GAIG;AACH,eAAO,IAAI,kBAAkB,EAAE,MAAM,GAAG,SAAS,CAAC;AAElD;;;GAGG;AACH,wBAAgB,eAAe,IAAI,OAAO,CAEzC;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,IAAI,OAAO,CAE7C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAY1E;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC7B,OAAO,EAAE,iBAAiB,EAC1B,KAAK,CAAC,EAAE,MAAM,GACZ,IAAI,CAEN;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,CAanD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAGnD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,oBAAoB,CACnC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,GAAG,EACX,QAAQ,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,GAAG,IAAI,GAC5C,IAAI,CAsCN;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAClC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,GAAG,EACX,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,GAAG,IAAI,GAC7C,IAAI,CAiCN;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,GAAG,GAAG,IAAI,CAMzD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAO5C;AAED;;;GAGG;AACH,wBAAgB,eAAe,IAAI,OAAO,CAMzC"}

package/build/lang/deprecated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deprecated.d.ts","sourceRoot":"","sources":["../../src/lang/deprecated.js"],"names":[],"mappings":"AA0JA;;;;;;;;GAQG;AACH,4CAHW,OAAO,QAsBjB;AAED;;;;;;GAMG;AACH,uCAeC;AAhMD;;;GAGG;AACH;IACC;;;;;;;;;OASG;IACH,mBATW,MAAM,UACN,MAAM,cAEd;QAA4B,OAAO;QACN,WAAW;QACX,eAAe;QACf,kBAAkB;QAClB,SAAS;KACxC,EAIA;CACD;AA8BD;;;GAGG;AACH;IACC,0BAA0B;IAC1B,qBADY,GAAG,EAAE,EAIhB;CACD;AAED;;;GAGG;AACH;IACC,0BAA0B;IAC1B,qBADY,GAAG,EAAE,EAIhB;CACD;AAED;;;GAGG;AACH;IACC,0BAA0B;IAC1B,qBADY,GAAG,EAAE,EAIhB;CACD;;+BA9F8B,6CAA6C;6BAC/C,oCAAoC;6BACpC,8CAA8C;wBACnD,yCAAyC"}
+{"version":3,"file":"deprecated.d.ts","sourceRoot":"","sources":["../../src/lang/deprecated.js"],"names":[],"mappings":"AAsJA;;;;;;;;GAQG;AACH,4CAHW,OAAO,QAsBjB;AAED;;;;;;GAMG;AACH,uCAeC;AA5LD;;;GAGG;AACH;IACC;;;;;;;;;OASG;IACH,mBATW,MAAM,UACN,MAAM,cAEd;QAA4B,OAAO;QACN,WAAW;QACX,eAAe;QACf,kBAAkB;QAClB,SAAS;KACxC,EAIA;CACD;AA0BD;;;GAGG;AACH;IACC,0BAA0B;IAC1B,qBADY,GAAG,EAAE,EAIhB;CACD;AAED;;;GAGG;AACH;IACC,0BAA0B;IAC1B,qBADY,GAAG,EAAE,EAIhB;CACD;AAED;;;GAGG;AACH;IACC,0BAA0B;IAC1B,qBADY,GAAG,EAAE,EAIhB;CACD;;+BA1F8B,6CAA6C;6BAC/C,oCAAoC;6BACpC,8CAA8C;wBACnD,yCAAyC"}

package/build/level/gltf/GLTFModel.d.ts

@@ -1,5 +1,4 @@
 /**
- * @classdesc
  * A rig-driven 3D model loaded from an animated glTF/GLB asset. Unlike a static
  * {@link GLTFScene} (which flattens each node into an independent {@link Mesh}),
  * a `GLTFModel` keeps the node **hierarchy** intact so a parent transform
@@ -36,25 +35,6 @@ export default class GLTFModel extends Container {
         castGroundShadow?: boolean | undefined;
         shadowGroundY?: number | undefined;
     });
-    _zSign: number;
-    /** the node hierarchy keyed by glTF node index @ignore */
-    _nodes: any;
-    /** root node indices @ignore */
-    _roots: any;
-    /** glTF node index → its part Mesh instances (one per primitive) @ignore */
-    _meshByNode: {};
-    /** glTF node index → cached rest (bind-pose) local matrix @ignore */
-    _restMatrix: {};
-    /**
-     * glTF node index → its world matrix, a persistent 16-element buffer
-     * recomputed in place every pose (a child reads its parent's buffer
-     * during the DFS, so each node needs its own). Preallocated here so the
-     * per-frame pose path allocates nothing.
-     * @ignore
-     */
-    _world: {};
-    /** name → clip `{ name, duration, channelsByNode, animatedNodes }` @ignore */
-    anim: {};
     /**
      * playback multiplier for the current animation (1 = authored speed).
      * @type {number}
@@ -67,21 +47,6 @@ export default class GLTFModel extends Container {
      * @default false
      */
     animationpause: boolean;
-    /**
-     * a callback fired each time the current animation completes a cycle.
-     * @type {Function}
-     * @default undefined
-     */
-    /** @ignore */
-    current: {
-        name: undefined;
-        time: number;
-        length: number;
-    };
-    /** loop-completion callback (built from the options) @ignore */
-    resetAnim: (() => unknown) | (() => false | undefined) | (() => boolean) | (() => void) | undefined;
-    /** set when a `loop:false` clip has finished its single cycle @ignore */
-    _animDone: boolean;
     /**
      * the names of every animation clip defined by the source asset.
      * @returns {string[]}
@@ -141,52 +106,6 @@ export default class GLTFModel extends Container {
      * @returns {GLTFModel} this, for chaining
      */
     stop(): GLTFModel;
-    /**
-     * Sample the active clip (if any) and propagate world transforms down the
-     * node tree, writing each part mesh's placement. Nodes the current clip does
-     * not animate use their cached rest matrix.
-     * @ignore
-     */
-    /**
-     * Whether this model is still alive.
-     *
-     * `update()` hands control to user code — `onended`, and the completion
-     * callback behind `resetAnim` — and then poses the hierarchy. A callback
-     * that removed the model (a death animation removing its own model is the
-     * obvious case) has had `Renderable.destroy()` run, which releases `pos` to
-     * the pool and leaves it undefined on every part. `_pose()` writes
-     * `mesh.pos`, so it must not run on a torn-down model.
-     *
-     * `pos` and not `ancestor`: a model that was never added to a container is
-     * perfectly poseable, and several callers do exactly that.
-     * @ignore
-     * @returns {boolean} true while the model can still be posed
-     */
-    _isLive(): boolean;
-    _pose(): void;
-    /**
-     * DFS one node: compose its local matrix, multiply by the parent world,
-     * apply to its meshes, recurse into children.
-     * @ignore
-     */
-    _visit(idx: any, parentWorld: any, clip: any, t: any): void;
-    /**
-     * The node's local matrix: sampled TRS when the active clip animates it
-     * (starting from the rest pose, overriding only the animated components),
-     * otherwise the cached rest matrix.
-     * @returns {number[]} 16-element column-major matrix
-     * @ignore
-     */
-    _localMatrix(idx: any, clip: any, t: any): number[];
-    /**
-     * Split a node's world matrix into the renderable placement a {@link Mesh}'s
-     * Camera3d path expects: the translation (scaled, Y/Z-bridged) becomes
-     * `pos`/`depth`, the rotation+scale becomes `currentTransform` (translation
-     * zeroed). Mirrors the static {@link GLTFScene} center-split, recomputed per
-     * frame.
-     * @ignore
-     */
-    _applyWorldToMesh(mesh: any, world: any): void;
 }
 import Container from "../../renderable/container.js";
 import type { AnimationOptions } from "../../renderable/animation.ts";

package/build/level/gltf/GLTFModel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GLTFModel.d.ts","sourceRoot":"","sources":["../../../src/level/gltf/GLTFModel.js"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IACC;;;;;;;;OAQG;IACH,kBARW,MAAM,YAEd;QAAyB,KAAK;QACJ,WAAW;QACX,GAAG;QACH,gBAAgB;QACjB,aAAa;KACxC,EA2LA;IA/KA,eAAoD;IAepD,0DAA0D;IAC1D,YAA8B;IAC9B,gCAAgC;IAChC,YAA8B;IAC9B,4EAA4E;IAC5E,gBAAqB;IACrB,qEAAqE;IACrE,gBAAqB;IACrB;;;;;;OAMG;IACH,WAAgB;IA+FhB,8EAA8E;IAC9E,SAAc;IAiBd;;;;OAIG;IACH,gBAHU,MAAM,CAGO;IAEvB;;;;OAIG;IACH,gBAHU,OAAO,CAGU;IAE3B;;;;OAIG;IAIH,cAAc;IACd;;;;MAAsD;IACtD,gEAAgE;IAChE,oGAA0B;IAC1B,yEAAyE;IACzE,mBAAsB;IAOvB;;;;;OAKG;IACH,qBAJa,MAAM,EAAE,CAMpB;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;;;;;;;;OAeG;IACH,0BAXW,MAAM,YACN,MAAM,cAAU,gBAAgB,iBAChC,OAAO,GACL,SAAS,CAgErB;IAED;;;;;;;;;;;;;OAaG;IACH,YATW,MAAM,YACN,MAAM,cAAU,gBAAgB,GAC9B,SAAS,CAarB;IAED;;;;OAIG;IACH,SAFa,SAAS,CAKrB;IAED;;;;;;OAMG;IACH,QAFa,SAAS,CAarB;IAkDD;;;;;OAKG;IACH;;;;;;;;;;;;;;OAcG;IACH,WAFa,OAAO,CAInB;IAED,cAMC;IAED;;;;OAIG;IACH,4DAqBC;IAED;;;;;;OAMG;IACH,2CAHa,MAAM,EAAE,CAwCpB;IAED;;;;;;;OAOG;IACH,+CASC;CACD;sBAnjBqB,+BAA+B;sCAUhB,+BAA+B"}
+{"version":3,"file":"GLTFModel.d.ts","sourceRoot":"","sources":["../../../src/level/gltf/GLTFModel.js"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IACC;;;;;;;;OAQG;IACH,kBARW,MAAM,YAEd;QAAyB,KAAK;QACJ,WAAW;QACX,GAAG;QACH,gBAAgB;QACjB,aAAa;KACxC,EAgOA;IAnNA;;;OAGG;IACH,eAAoD;IAepD;;;;OAIG;IACH,YAA8B;IAC9B;;;;OAIG;IACH,YAA8B;IAC9B;;;;OAIG;IACH,gBAAqB;IACrB;;;;OAIG;IACH,gBAAqB;IACrB;;;;;;;OAOG;IACH,WAAgB;IA+FhB;;;;OAIG;IACH,SAAc;IAiBd;;;;OAIG;IACH,gBAHU,MAAM,CAGO;IAEvB;;;;OAIG;IACH,gBAHU,OAAO,CAGU;IAE3B;;;;OAIG;IAIH;;;OAGG;IACH;;;;MAAsD;IACtD;;;;OAIG;IACH,oGAA0B;IAC1B;;;;OAIG;IACH,mBAAsB;IAOvB;;;;;OAKG;IACH,qBAJa,MAAM,EAAE,CAMpB;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;;;;;;;;OAeG;IACH,0BAXW,MAAM,YACN,MAAM,cAAU,gBAAgB,iBAChC,OAAO,GACL,SAAS,CAgErB;IAED;;;;;;;;;;;;;OAaG;IACH,YATW,MAAM,YACN,MAAM,cAAU,gBAAgB,GAC9B,SAAS,CAarB;IAED;;;;OAIG;IACH,SAFa,SAAS,CAKrB;IAED;;;;;;OAMG;IACH,QAFa,SAAS,CAarB;IAkDD;;;;;;OAMG;IACH;;;;;;;;;;;;;;;OAeG;IACH,WAFa,OAAO,CAInB;IAED;;;OAGG;IACH,cAMC;IAED;;;;;OAKG;IACH,4DAqBC;IAED;;;;;;;OAOG;IACH,2CAJa,MAAM,EAAE,CAyCpB;IAED;;;;;;;;OAQG;IACH,+CASC;CACD;sBAhmBqB,+BAA+B;sCAUhB,+BAA+B"}

package/build/level/gltf/GLTFScene.d.ts

@@ -1,27 +1,5 @@
+
 /**
- * Fill an {@link InstancedMesh}'s records from an
- * `EXT_mesh_gpu_instancing` node's per-instance TRS arrays.
- *
- * The records are written in the node's own (glTF, Y-up, right-handed)
- * space, **verbatim** — no scene scale, no axis bridge. That is not a
- * simplification but the consequence of where the instance transform sits
- * in the chain the shader evaluates:
- *
- *     clip = projection × view × model(group) × instance × vertex
- *
- * The group's model matrix already carries the scene scale and the Y/Z
- * bridge, and it is applied AFTER the instance transform — so an instance
- * expressed in the same space as the vertices comes out placed correctly.
- * Pre-scaling or pre-bridging the records here applies both twice (which
- * put the first version of this forest 26× too far out, and well outside
- * the far plane).
- * @param {InstancedMesh} mesh - the mesh to fill
- * @param {object} instances - `{count, translation, rotation, scale}`
- * @ignore
- */
-export function fillInstances(mesh: InstancedMesh, instances: object): void;
-/**
- * @classdesc
  * A loadable 3D scene parsed from a glTF / GLB asset. Instances are created
  * and registered with the {@link level} director (usually automatically by
  * the preloader), so a glTF scene loads with the same one-call ergonomics as
@@ -106,27 +84,6 @@ export default class GLTFScene {
         castGroundShadow?: boolean | undefined;
         shadowGroundY?: number | undefined;
     }): void;
-    /**
-     * Add the scene's authored lights — directional, point and spot — (plus a soft ambient fill) to
-     * the world as {@link Light3d} renderables, so the meshes are lit by the
-     * same sun set up in the authoring tool (Blender etc.). Shared by the static
-     * and animated paths. The lights are ordinary world children — the level
-     * director's `container.reset()` removes them on the next load, exactly like
-     * {@link Light2d}, so there's nothing to track or tear down here.
-     * @param {Container} container - the target container the lights are added to
-     * @param {number} zSign - the Y-up→Y-down Z bridge sign (rightHanded → -1)
-     * @param {number} scale - the scene's world scale (positions/ranges follow it)
-     * @param {object} options - the `addTo` options (`lights` toggle)
-     * @ignore
-     */
-    _addLights(container: Container, zSign: number, scale: number, options: object): void;
-    /**
-     * Director cleanup hook (parity with `TMXTileMap.destroy`). Nothing to do —
-     * the meshes and lights are ordinary world children, removed by the
-     * director's `container.reset()` on the next load.
-     * @ignore
-     */
-    destroy(): void;
 }
 import InstancedMesh from "../../renderable/instanced_mesh.js";
 //# sourceMappingURL=GLTFScene.d.ts.map

package/build/level/gltf/GLTFScene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GLTFScene.d.ts","sourceRoot":"","sources":["../../../src/level/gltf/GLTFScene.js"],"names":[],"mappings":"AAuWA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,oCAJW,aAAa,aACb,MAAM,QAwChB;AAvZD;;;;;;;;;;GAUG;AACH;IACC;;OAEG;IACH,qBAFW,MAAM,EAkBhB;IAfA;;;OAGG;IACH,MAFU,MAAM,CAEG;IACnB;;;OAGG;IACH,QAFU,MAAM,CAEI;IACpB;;;OAGG;IACH,MAFU,MAAM,CAEY;IAG7B;;;;OAIG;IACH,cAFa,MAAM,GAAC,SAAS,CAI5B;IAED;;;;OAIG;IACH,qBAEC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACH,iBAhCW,SAAS,YAEjB;QAAyB,KAAK;QACJ,WAAW;QAEX,MAAM;QAQP,mBAAmB;QAQlB,gBAAgB;QAMjB,aAAa;KAIxC,QA4KA;IAED;;;;;;;;;;;;OAYG;IACH,sBANW,SAAS,SACT,MAAM,SACN,MAAM,WACN,MAAM,QAqEhB;IAED;;;;;OAKG;IACH,gBAAY;CACZ;0BAjWyB,oCAAoC"}
+{"version":3,"file":"GLTFScene.d.ts","sourceRoot":"","sources":["../../../src/level/gltf/GLTFScene.js"],"names":[],"mappings":"AAwWA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,oCALW,aAAa,aACb,MAAM,QAyChB;AAzZD;;;;;;;;;GASG;AACH;IACC;;OAEG;IACH,qBAFW,MAAM,EAkBhB;IAfA;;;OAGG;IACH,MAFU,MAAM,CAEG;IACnB;;;OAGG;IACH,QAFU,MAAM,CAEI;IACpB;;;OAGG;IACH,MAFU,MAAM,CAEY;IAG7B;;;;OAIG;IACH,cAFa,MAAM,GAAC,SAAS,CAI5B;IAED;;;;OAIG;IACH,qBAEC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACH,iBAhCW,SAAS,YAEjB;QAAyB,KAAK;QACJ,WAAW;QAEX,MAAM;QAQP,mBAAmB;QAQlB,gBAAgB;QAMjB,aAAa;KAIxC,QA4KA;IAED;;;;;;;;;;;;;OAaG;IACH,sBAPW,SAAS,SACT,MAAM,SACN,MAAM,WACN,MAAM,QAsEhB;IAED;;;;;;OAMG;IACH,gBAAY;CACZ;0BAlWyB,oCAAoC"}

package/build/level/gltf/gltf_sampler.d.ts

@@ -1,49 +1,2 @@
-/**
- * Locate the keyframe interval for time `t` in the (ascending) `times` array.
- * Clamps to the endpoints — glTF animations do not extrapolate beyond their
- * first/last keyframe. Returns the bracketing indices and the 0..1 blend factor.
- *
- * The returned object is **reused** across calls (read/copy its fields
- * immediately; don't retain the reference).
- * @param {ArrayLike<number>} times - keyframe times, ascending
- * @param {number} t - sample time (same units as `times`, i.e. seconds)
- * @returns {{ i0: number, i1: number, alpha: number }} reused result object
- * @ignore
- */
-export function findKeyframe(times: ArrayLike<number>, t: number): {
-    i0: number;
-    i1: number;
-    alpha: number;
-};
-/**
- * Spherical-linear interpolation between two quaternions stored in `values` at
- * component offsets `o0` and `o1`. Picks the shortest arc (sign-flips the second
- * quaternion when the dot is negative) and falls back to normalized-lerp for
- * nearly-parallel inputs (where `sin(theta)` underflows). Result is normalized.
- * @param {ArrayLike<number>} values - flat quaternion buffer (xyzw per key)
- * @param {number} o0 - offset of the first quaternion
- * @param {number} o1 - offset of the second quaternion
- * @param {number} t - blend factor 0..1
- * @param {number[]} out - 4-element [x,y,z,w] result
- * @ignore
- */
-export function slerpQuat(values: ArrayLike<number>, o0: number, o1: number, t: number, out: number[]): number[];
-/**
- * Sample one animation channel at time `t`, writing `channel.stride` components
- * into `out`. Rotation channels (stride 4) use {@link slerpQuat}; translation /
- * scale (stride 3) use component-wise linear interpolation. `STEP` holds the
- * lower keyframe; `CUBICSPLINE` uses the keyframe value (its tangents are
- * ignored — a deliberate Tier-1 approximation, not full spline evaluation).
- * @param {{times: ArrayLike<number>, values: ArrayLike<number>, stride: number, interpolation: string}} channel
- * @param {number} t - sample time in seconds
- * @param {number[]} out - destination, at least `channel.stride` long
- * @returns {number[]} `out`
- * @ignore
- */
-export function sampleChannel(channel: {
-    times: ArrayLike<number>;
-    values: ArrayLike<number>;
-    stride: number;
-    interpolation: string;
-}, t: number, out: number[]): number[];
+
 //# sourceMappingURL=gltf_sampler.d.ts.map

package/build/level/gltf/gltf_sampler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gltf_sampler.d.ts","sourceRoot":"","sources":["../../../src/level/gltf/gltf_sampler.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;GAWG;AACH,oCALW,SAAS,CAAC,MAAM,CAAC,KACjB,MAAM,GACJ;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAkCrD;AAED;;;;;;;;;;;GAWG;AACH,kCAPW,SAAS,CAAC,MAAM,CAAC,MACjB,MAAM,MACN,MAAM,KACN,MAAM,OACN,MAAM,EAAE,YA+ClB;AAED;;;;;;;;;;;GAWG;AACH,uCANW;IAAC,KAAK,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;IAAC,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAC,KAC5F,MAAM,OACN,MAAM,EAAE,GACN,MAAM,EAAE,CAwBpB"}
+{"version":3,"file":"gltf_sampler.d.ts","sourceRoot":"","sources":["../../../src/level/gltf/gltf_sampler.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;GAYG;AACH,oCANW,SAAS,CAAC,MAAM,CAAC,KACjB,MAAM,GACJ;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAmCrD;AAED;;;;;;;;;;;;GAYG;AACH,kCARW,SAAS,CAAC,MAAM,CAAC,MACjB,MAAM,MACN,MAAM,KACN,MAAM,OACN,MAAM,EAAE,YAgDlB;AAED;;;;;;;;;;;;GAYG;AACH,uCAPW;IAAC,KAAK,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;IAAC,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAC,KAC5F,MAAM,OACN,MAAM,EAAE,GACN,MAAM,EAAE,CAyBpB"}

package/build/level/level.d.ts

@@ -1,8 +1,6 @@
 export namespace level {
     /**
      * add a level into the game manager (usually called by the preloader)
-     * @name add
-     * @memberof level
      * @public
      * @param {string} format - level format ("tmx" for Tiled maps, "gltf" / "glb" for 3D scenes)
      * @param {string} levelId - the level id (or name)
@@ -11,76 +9,58 @@ export namespace level {
      */
     function add(format: string, levelId: string, callback?: Function): boolean;
     /**
-     * load a level into the game manager<br>
+     * load a level into the game manager, and return a promise that settles once
+     * it is actually in the world<br>
      * (will also create all level defined entities, etc..)
-     * @name load
-     * @memberof level
-     * @public
+     *
+     * `options.onLoaded` still fires, so the two forms mix freely. An unknown
+     * `levelId` throws SYNCHRONOUSLY rather than rejecting — that is a typo, not
+     * a load failure, and it should not need `await` to surface.
+     * @overload
      * @param {string} levelId - level id
-     * @param {object} [options] - additional optional parameters
-     * @param {Container} [options.container=game.world] - container in which to load the specified level
-     * @param {Function} [options.onLoaded=game.onLevelLoaded] - callback for when the level is fully loaded
-     * @param {boolean} [options.flatten=game.mergeGroup] - (TMX only) if true, flatten all objects into the given container
-     * @param {boolean} [options.setViewportBounds=true] - (TMX only) if true, set the viewport bounds to the map size
-     * @param {number} [options.scale=1] - (glTF/GLB only) pixels per glTF unit applied to the whole scene
-     * @param {boolean} [options.rightHanded=true] - (glTF/GLB only) convert the right-handed (Y-up) source to the engine's Y-down via a rotation rather than a mirror
-     * @param {boolean} [options.lights=true] - (glTF/GLB only) add the scene's authored `KHR_lights_punctual` lights (plus a soft ambient fill) as {@link Light3d} world children; each carries its authored name for `getChildByName` lookups
-     * @param {number} [options.lightIntensityScale] - (glTF/GLB only) multiply each light's authored physical intensity (lux/candela) by this factor instead of normalizing it to 1 — see {@link GLTFScene#addTo}
-     * @param {boolean} [options.castGroundShadow] - (glTF/GLB only) give this scene's meshes a ground shadow ({@link Mesh#castGroundShadow}). Overrides the application's `castGroundShadow` setting for this scene, in both directions; omit it to inherit. As a scene-wide opt-in it skips nodes with no vertical extent — a scene's ground plane is exactly that, and shadowing it with itself smears a blob across the whole floor
-     * @param {number} [options.shadowGroundY] - (glTF/GLB only) world Y of the floor those shadows land on ({@link Mesh#shadowGroundY}); omit it and each blob sits at its own object's base at full strength, which is right for a scene whose props already rest on the ground
-     * @returns {boolean} true if the level was successfully loaded
+     * @param {LevelLoadOptions & { async: true }} options - load options, with `async` set
+     * @returns {Promise<boolean>} resolves `true` once the level is in the world
      * @example
-     * // the game assets to be be preloaded
-     * // TMX maps
-     * let resources = [
-     *     {name: "a4_level1",   type: "tmx",   src: "data/level/a4_level1.tmx"},
-     *     {name: "a4_level2",   type: "tmx",   src: "data/level/a4_level2.tmx"},
-     *     {name: "a4_level3",   type: "tmx",   src: "data/level/a4_level3.tmx"},
-     *     // ...
-     * ];
+     * await me.loader.preload(game.assets);
+     * await me.level.load("a4_level1", { async: true });
+     * // the world is populated here
+     * @category Level
+     */
+    function load(levelId: string, options: LevelLoadOptions & {
+        async: true;
+    }): Promise<boolean>;
+    /**
+     * load a level into the game manager<br>
+     * (will also create all level defined entities, etc..)
      *
-     * // ...
+     * While the game loop is running the load is DEFERRED to a timer, so this
+     * returns before anything is in the world. Sequence follow-up work from
+     * `options.onLoaded`, from an `event.LEVEL_LOADED` listener, or by passing
+     * `async: true` and awaiting the promise that overload returns.
      *
-     * // load a level into the game world
+     * Note that `await me.level.load(id)` without `async: true` does not await
+     * the load: the call returns a boolean, and `await true` resolves at once.
+     * @overload
+     * @param {string} levelId - level id
+     * @param {LevelLoadOptions & { async?: false }} [options] - additional optional parameters
+     * @returns {boolean} `true`
+     * @example
+     * // load a level
      * me.level.load("a4_level1");
-     * ...
-     * ...
-     * // load a level into a specific container
-     * let levelContainer = new me.Container();
-     * me.level.load("a4_level2", {container:levelContainer});
-     * // add a simple transformation
-     * levelContainer.translate(levelContainer.width / 2, levelContainer.height / 2 );
-     * levelContainer.rotate(0.05);
-     * levelContainer.translate(-levelContainer.width / 2, -levelContainer.height / 2 );
-     * // add it to the game world
-     * app.world.addChild(levelContainer);
      *
-     * // load a glTF/GLB scene (preloaded with type "glb") under a Camera3d:
-     * // 50 pixels per glTF unit, authored lux/candela intensities kept at
-     * // a 1/1000 scale instead of being normalized to 1
+     * // load into a specific container
+     * me.level.load("a4_level2", { container: levelContainer });
+     *
+     * // a glTF/GLB scene (preloaded with type "glb") under a Camera3d:
+     * // 50 pixels per glTF unit, authored intensities kept at a 1/1000 scale
      * me.level.load("diorama", { scale: 50, lightIntensityScale: 0.001 });
-     * // …and give every prop in it a ground shadow landing on the floor at y = 0
-     * // (the scene's own ground plane is skipped — it has no height to cast)
-     * me.level.load("diorama", { scale: 50, castGroundShadow: true, shadowGroundY: 0 });
-     * // the authored lights are world children — grab the sun for a day/night cycle
-     * const sun = app.world.getChildByName("Sun")[0];
-     */
-    function load(levelId: string, options?: {
-        container?: any;
-        onLoaded?: Function | undefined;
-        flatten?: boolean | undefined;
-        setViewportBounds?: boolean | undefined;
-        scale?: number | undefined;
-        rightHanded?: boolean | undefined;
-        lights?: boolean | undefined;
-        lightIntensityScale?: number | undefined;
-        castGroundShadow?: boolean | undefined;
-        shadowGroundY?: number | undefined;
-    }): boolean;
+     * @category Level
+     */
+    function load(levelId: string, options?: (LevelLoadOptions & {
+        async?: false;
+    }) | undefined): boolean;
     /**
      * return the current level id<br>
-     * @name getCurrentLevelId
-     * @memberof level
      * @public
      * @returns {string}
      */
@@ -89,69 +69,171 @@ export namespace level {
      * return the current level definition.
      * for a reference to the live instantiated level,
      * rather use the container in which it was loaded (e.g. app.world)
-     * @name getCurrentLevel
-     * @memberof level
      * @public
      * @returns {TMXTileMap|GLTFScene} the current level object (a TMXTileMap for Tiled maps, a GLTFScene for glTF/GLB scenes)
      */
     function getCurrentLevel(): TMXTileMap | GLTFScene;
     /**
-     * reload the current level
-     * @name reload
-     * @memberof level
-     * @public
-     * @param {object} [options] - additional optional parameters
-     * @param {Container} [options.container=game.world] - container in which to load the specified level
-     * @param {Function} [options.onLoaded=game.onLevelLoaded] - callback for when the level is fully loaded
-     * @param {boolean} [options.flatten=game.mergeGroup] - if true, flatten all objects into the given container
-     * @returns {object} the current level
-     */
-    function reload(options?: {
-        container?: any;
-        onLoaded?: Function | undefined;
-        flatten?: boolean | undefined;
-    }): object;
-    /**
-     * load the next level
-     * @name next
-     * @memberof level
-     * @public
-     * @param {object} [options] - additional optional parameters
-     * @param {Container} [options.container=game.world] - container in which to load the specified level
-     * @param {Function} [options.onLoaded=game.onLevelLoaded] - callback for when the level is fully loaded
-     * @param {boolean} [options.flatten=game.mergeGroup] - if true, flatten all objects into the given container
-     * @returns {boolean} true if the next level was successfully loaded
-     */
-    function next(options?: {
-        container?: any;
-        onLoaded?: Function | undefined;
-        flatten?: boolean | undefined;
-    }): boolean;
-    /**
-     * load the previous level<br>
-     * @name previous
-     * @memberof level
-     * @public
-     * @param {object} [options] - additional optional parameters
-     * @param {Container} [options.container=game.world] - container in which to load the specified level
-     * @param {Function} [options.onLoaded=game.onLevelLoaded] - callback for when the level is fully loaded
-     * @param {boolean} [options.flatten=game.mergeGroup] - if true, flatten all objects into the given container
-     * @returns {boolean} true if the previous level was successfully loaded
-     */
-    function previous(options?: {
-        container?: any;
-        onLoaded?: Function | undefined;
-        flatten?: boolean | undefined;
-    }): boolean;
+     * reload the current level, and return a promise that settles once the level is in the world.
+     *
+     * @overload
+     * @param {LevelLoadOptions & { async: true }} options - load options, with `async` set
+     * @returns {Promise<boolean>} resolves `true` once the level is back in the world
+     * @example
+     * await me.level.reload({ async: true });
+     * @category Level
+     */
+    function reload(options: LevelLoadOptions & {
+        async: true;
+    }): Promise<boolean>;
+    /**
+     * reload the current level.
+     *
+     * While the game loop is running the load is deferred to a timer, so this
+     * returns before anything is in the world — see {@link level.load}.
+     * @overload
+     * @param {LevelLoadOptions & { async?: false }} [options] - additional optional parameters
+     * @returns {boolean} `true`
+     * @category Level
+     */
+    function reload(options?: (LevelLoadOptions & {
+        async?: false;
+    }) | undefined): boolean;
+    /**
+     * load the next level, and return a promise that settles once the level is in the world.
+     *
+     * With no level to go to this reports `false` WITHOUT loading anything, and
+     * the promise form resolves `false` rather than rejecting: running out of
+     * levels is an ordinary outcome, not an error.
+     *
+     * @overload
+     * @param {LevelLoadOptions & { async: true }} options - load options, with `async` set
+     * @returns {Promise<boolean>} resolves `true`, or `false` if there is no next level
+     * @example
+     * await me.level.next({ async: true });
+     * @category Level
+     */
+    function next(options: LevelLoadOptions & {
+        async: true;
+    }): Promise<boolean>;
+    /**
+     * load the next level.
+     *
+     * With no level to go to this reports `false` WITHOUT loading anything, and
+     * the promise form resolves `false` rather than rejecting: running out of
+     * levels is an ordinary outcome, not an error.
+     *
+     * While the game loop is running the load is deferred to a timer, so this
+     * returns before anything is in the world — see {@link level.load}.
+     * @overload
+     * @param {LevelLoadOptions & { async?: false }} [options] - additional optional parameters
+     * @returns {boolean} `true` if the next level was loaded, `false` if there is none
+     * @category Level
+     */
+    function next(options?: (LevelLoadOptions & {
+        async?: false;
+    }) | undefined): boolean;
+    /**
+     * load the previous level, and return a promise that settles once the level is in the world.
+     *
+     * With no level to go to this reports `false` WITHOUT loading anything, and
+     * the promise form resolves `false` rather than rejecting: running out of
+     * levels is an ordinary outcome, not an error.
+     *
+     * @overload
+     * @param {LevelLoadOptions & { async: true }} options - load options, with `async` set
+     * @returns {Promise<boolean>} resolves `true`, or `false` if there is no previous level
+     * @example
+     * await me.level.previous({ async: true });
+     * @category Level
+     */
+    function previous(options: LevelLoadOptions & {
+        async: true;
+    }): Promise<boolean>;
+    /**
+     * load the previous level.
+     *
+     * With no level to go to this reports `false` WITHOUT loading anything, and
+     * the promise form resolves `false` rather than rejecting: running out of
+     * levels is an ordinary outcome, not an error.
+     *
+     * While the game loop is running the load is deferred to a timer, so this
+     * returns before anything is in the world — see {@link level.load}.
+     * @overload
+     * @param {LevelLoadOptions & { async?: false }} [options] - additional optional parameters
+     * @returns {boolean} `true` if the previous level was loaded, `false` if there is none
+     * @category Level
+     */
+    function previous(options?: (LevelLoadOptions & {
+        async?: false;
+    }) | undefined): boolean;
     /**
      * return the amount of level preloaded
-     * @name levelCount
-     * @memberof level
      * @public
      * @returns {number} the amount of level preloaded
      */
     function levelCount(): number;
 }
+/**
+ * Options accepted by every level-loading call.
+ *
+ * `async` is the switch that decides what the call HANDS BACK: leave it out and
+ * you get the boolean these calls have always returned, set it and you get a
+ * promise that settles once the level is actually in the world. Everything else
+ * behaves identically either way, `onLoaded` included.
+ *
+ * Awaiting a call WITHOUT `async: true` is not an error, but it is not a wait
+ * either: the call hands back a boolean, and `await true` resolves immediately.
+ * While the loop is running the load is deferred onto a timer, so it has NOT
+ * happened by the time such an `await` resumes. Pass the flag when you mean to
+ * await.
+ */
+export type LevelLoadOptions = {
+    /**
+     * - container in which to load the specified level
+     */
+    container?: Container;
+    /**
+     * - callback for when the level is fully loaded, called in both forms
+     */
+    onLoaded?: Function;
+    /**
+     * - return a promise that settles once the level is in the world, instead of a boolean
+     */
+    async?: boolean;
+    /**
+     * - (TMX only) if true, flatten all objects into the given container
+     */
+    flatten?: boolean;
+    /**
+     * - (TMX only) if true, set the viewport bounds to the map size
+     */
+    setViewportBounds?: boolean;
+    /**
+     * - (glTF/GLB only) pixels per glTF unit applied to the whole scene
+     */
+    scale?: number;
+    /**
+     * - (glTF/GLB only) convert the right-handed (Y-up) source to the engine's Y-down via a rotation rather than a mirror
+     */
+    rightHanded?: boolean;
+    /**
+     * - (glTF/GLB only) add the scene's authored `KHR_lights_punctual` lights (plus a soft ambient fill) as {@link Light3d} world children
+     */
+    lights?: boolean;
+    /**
+     * - (glTF/GLB only) multiply each light's authored physical intensity by this factor instead of normalizing it to 1
+     */
+    lightIntensityScale?: number;
+    /**
+     * - (glTF/GLB only) give every mesh in the scene a ground shadow; omit to inherit the application's `castGroundShadow` setting (on by default)
+     */
+    castGroundShadow?: boolean;
+    /**
+     * - (glTF/GLB only) world Y the ground shadows land on
+     */
+    shadowGroundY?: number;
+};
 import TMXTileMap from "./tiled/TMXTileMap.js";
 import GLTFScene from "./gltf/GLTFScene.js";
 //# sourceMappingURL=level.d.ts.map