@woosh/meep-engine 2.165.6 → 2.166.0

package/src/engine/EngineConfiguration.d.ts

@@ -1,20 +1,74 @@
-import {AssetLoader} from "./asset/loaders/AssetLoader";
-import {System} from "./ecs/System";
-import {StaticKnowledgeDataTableDescriptor} from "./knowledge/database/StaticKnowledgeDataTableDescriptor";
-import {EnginePlugin} from "./plugin/EnginePlugin";
-
-export class EngineConfiguration {
-    addPlugin(plugin: EnginePlugin): boolean
-
-    addSystem<A, B, C, D, E>(system: System<A, B, C, D, E>): boolean
-
-    addManySystems(...systems: System<any>[]): void
-
-    addDataTable<T>(table: StaticKnowledgeDataTableDescriptor<T>): boolean
-
-    addLoader<T, CTX>(type: string, loader: AssetLoader<T, CTX>): boolean
-
-    hasLoader(type: string): boolean
-
-    apply(engine): Promise<any>
-}
+export class EngineConfiguration {
+    /**
+     * @private
+     * @type {System[]}
+     */
+    private systems;
+    /**
+     * @private
+     * @type {Class<EnginePlugin>[]}
+     */
+    private plugins;
+    /**
+     * Static database
+     * Can contain tables of structured data that the application often works with.
+     * Engine startup will load all tables ensuring that data is ready once startup finishes
+     * Use sparingly, this is not suitable for very large amounts of data as all the data will be in memory and deserialization will stall engine startup
+     * Example: inventory item table, monster table
+     * @private
+     * @readonly
+     * @type {StaticKnowledgeDataTableDescriptor[]}
+     */
+    private readonly knowledge;
+    /**
+     *
+     * @type {Map<string,AssetLoader<any>>}
+     */
+    loaders: Map<string, AssetLoader<any>>;
+    /**
+     *
+     * @param {string} type
+     * @returns {boolean}
+     */
+    hasLoader(type: string): boolean;
+    /**
+     * @template T
+     * @param {string} type
+     * @param {AssetLoader<T>} loader
+     */
+    addLoader<T>(type: string, loader: AssetLoader<T>): boolean;
+    /**
+     * @template T
+     * @param {string} type
+     * @returns {AssetLoader<T>}
+     */
+    removeLoader<T_1>(type: string): AssetLoader<T_1>;
+    /**
+     *
+     * @param {Class<EnginePlugin>} plugin
+     * @returns {boolean}
+     */
+    addPlugin(plugin: Class<EnginePlugin>): boolean;
+    /**
+     *
+     * @param {System} system
+     * @returns {boolean}
+     */
+    addSystem(system: System): boolean;
+    /**
+     * @param {System} systems
+     */
+    addManySystems(...systems: System): void;
+    /**
+     *
+     * @param {StaticKnowledgeDataTableDescriptor} table
+     * @returns {boolean}
+     */
+    addDataTable(table: StaticKnowledgeDataTableDescriptor): boolean;
+    /**
+     *
+     * @param {Engine} engine
+     */
+    apply(engine: Engine): Promise<void>;
+}
+//# sourceMappingURL=EngineConfiguration.d.ts.map

package/src/engine/achievements/AchievementGateway.d.ts

@@ -1,5 +1,17 @@
-export class AchievementGateway {
-    getUnlocked(): Promise<string[]>
-
-    unlock(id: string): Promise<any>
-}
+/**
+ * Base class for implementing achievement system API connectors
+ */
+export class AchievementGateway {
+    /**
+     * Retrieve list of unlocked achievements
+     * @returns {Promise<string[]>} IDs of unlocked achievements
+     */
+    getUnlocked(): Promise<string[]>;
+    /**
+     * Unlock an achievements by ID
+     * @param {String} id
+     * @returns {Promise}
+     */
+    unlock(id: string): Promise<any>;
+}
+//# sourceMappingURL=AchievementGateway.d.ts.map

package/src/engine/achievements/AchievementManager.d.ts

@@ -1,5 +1,4 @@
 export class AchievementManager extends EnginePlugin {
-    id: string;
     /**
      *
      * @type {AchievementGateway|null}

package/src/engine/achievements/AchievementManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AchievementManager.d.ts","sourceRoot":"","sources":["../../../../src/engine/achievements/AchievementManager.js"],"names":[],"mappings":"AA0CA;IAGQ,WAAwB;IAExB;;;OAGG;IACH,SAFU,qBAAmB,IAAI,CAEd;IAEnB;;;OAGG;IACH,SAFU,WAAW,EAAE,CAEN;IAGjB;;;OAGG;IACH,cAFU,eAAa,IAAI,CAEH;IAExB;;;OAGG;IACH,YAFU,aAAW,IAAI,CAEH;IAEtB;;;OAGG;IACH,eAFU,gBAAc,IAAI,CAEH;IAEzB;;;OAGG;IACH,cAFU,eAAa,IAAI,CAEH;IAExB;;;OAGG;IACH,oBAFU,eAAe,CAEkB;IAG3C;;;OAGG;IACH,+BAFU,eAAe,CAE6B;IAEtD;;;OAGG;IACH,+BAFU,eAAe,CAE6B;IAEtD;;;OAGG;IACH,mBAFU,WAAW,CAKpB;IAUD,aAAkB;IAGtB;;;;OAIG;IACH,gCAFY,WAAW,GAAC,SAAS,CAIhC;IAGD;;;OAGG;IACH,yBA6BC;IAED;;;OAGG;IACH,sBAcC;IAED;;;OAGG;IACH,wBAUC;IAGD;;OAEG;IACH,iBAUC;IAED;;OAEG;IACH,mBAMC;IAED,uCAMC;IAED;;;OAGG;IACH,2DAaC;IAED;;;OAGG;IACH,qBAFW,WAAW,QA2FrB;IAED;;;OAGG;IACH,+CAOC;IAED,mCAoDC;IAED,yBASC;IAED,0BAEC;CACJ;6BA1Z4B,2BAA2B;4BAG5B,kBAAkB;4BAxBlB,qCAAqC;4BACrC,sDAAsD"}
+{"version":3,"file":"AchievementManager.d.ts","sourceRoot":"","sources":["../../../../src/engine/achievements/AchievementManager.js"],"names":[],"mappings":"AA0CA;IAKQ;;;OAGG;IACH,SAFU,qBAAmB,IAAI,CAEd;IAEnB;;;OAGG;IACH,SAFU,WAAW,EAAE,CAEN;IAGjB;;;OAGG;IACH,cAFU,eAAa,IAAI,CAEH;IAExB;;;OAGG;IACH,YAFU,aAAW,IAAI,CAEH;IAEtB;;;OAGG;IACH,eAFU,gBAAc,IAAI,CAEH;IAEzB;;;OAGG;IACH,cAFU,eAAa,IAAI,CAEH;IAExB;;;OAGG;IACH,oBAFU,eAAe,CAEkB;IAG3C;;;OAGG;IACH,+BAFU,eAAe,CAE6B;IAEtD;;;OAGG;IACH,+BAFU,eAAe,CAE6B;IAEtD;;;OAGG;IACH,mBAFU,WAAW,CAKpB;IAUD,aAAkB;IAGtB;;;;OAIG;IACH,gCAFY,WAAW,GAAC,SAAS,CAIhC;IAGD;;;OAGG;IACH,yBA6BC;IAED;;;OAGG;IACH,sBAcC;IAED;;;OAGG;IACH,wBAUC;IAGD;;OAEG;IACH,iBAUC;IAED;;OAEG;IACH,mBAMC;IAED,uCAMC;IAED;;;OAGG;IACH,2DAaC;IAED;;;OAGG;IACH,qBAFW,WAAW,QA2FrB;IAED;;;OAGG;IACH,+CAOC;IAED,mCAoDC;IAED,yBASC;IAED,0BAEC;CACJ;6BA1Z4B,2BAA2B;4BAG5B,kBAAkB;4BAxBlB,qCAAqC;4BACrC,sDAAsD"}

package/src/engine/animation/Tween.d.ts

@@ -12,7 +12,7 @@ declare class Tween {
     constructor(callback: any, valueStart: number, valueEnd: number, duration: number, formula?: (x: number) => number, oscillate?: boolean);
     timeElapsed: number;
     on: {
-        ended: Signal<any, any, any, any, any, any, any, any>;
+        ended: Signal;
     };
     oscillate: boolean;
     formula: (x: number) => number;

package/src/engine/animation/clip/AnimationClip.d.ts

@@ -1,4 +1,24 @@
-export class AnimationClip {
-    name: string
-    readonly duration: number
-}
+export class AnimationClip {
+    /**
+     * Human-readable label
+     * @type {string}
+     */
+    name: string;
+    /**
+     *
+     * @type {AnimationTrack[]}
+     */
+    tracks: AnimationTrack[];
+    /**
+     *
+     * @returns {number}
+     */
+    get start_time(): number;
+    get end_time(): number;
+    /**
+     *
+     * @return {number}
+     */
+    get duration(): number;
+}
+//# sourceMappingURL=AnimationClip.d.ts.map

package/src/engine/animation/clip/AnimationClipBinding.d.ts

@@ -1,14 +1,35 @@
-import {AnimationClip} from "./AnimationClip";
-
-export class AnimationClipBinding {
-    /**
-     * @deprecated
-     */
-    readonly name: string
-    /**
-     * @deprecated
-     */
-    readonly duration: number
-
-    clip: AnimationClip
-}
+export class AnimationClipBinding {
+    static from(clip: any, root: any, binding_registry: any): AnimationClipBinding;
+    /**
+     * @type {AnimationClip}
+     */
+    clip: AnimationClip;
+    /**
+     * Populated by {@link bind} method
+     * @type {AnimationTrackBinding[]}
+     */
+    tracks: AnimationTrackBinding[];
+    /**
+     * @deprecated use `clip.name` directly instead
+     * @return {string}
+     */
+    get name(): string;
+    /**
+     * @deprecated use `clip.duration` directly instead
+     * @return {number}
+     */
+    get duration(): number;
+    /**
+     * @template T
+     * @param {T} root
+     * @param {Object<Type<BoundValueWriter>>} binding_registry
+     */
+    bind<T>(root: T, binding_registry: any): void;
+    /**
+     *
+     * @param {number} time time in seconds
+     */
+    writeAt(time: number): void;
+}
+import { AnimationTrackBinding } from "./AnimationTrackBinding.js";
+//# sourceMappingURL=AnimationClipBinding.d.ts.map

package/src/engine/animation/clip/ecd_bind_animation_curve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ecd_bind_animation_curve.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/clip/ecd_bind_animation_curve.js"],"names":[],"mappings":"AAoGA;;;;GAIG;AACH,2DAFW,mBAAmB,wBAgC7B;8BArI6B,oBAAoB;qCACb,2BAA2B"}
+{"version":3,"file":"ecd_bind_animation_curve.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/clip/ecd_bind_animation_curve.js"],"names":[],"mappings":"AA6GA;;;;GAIG;AACH,2DAFW,mBAAmB,wBAgC7B;8BA9I6B,oBAAoB;qCACb,2BAA2B"}

package/src/engine/animation/clip/ecd_bind_animation_curve.js

@@ -7,6 +7,7 @@ import { AnimationTrack } from "./AnimationTrack.js";
 import { AnimationTrackBinding } from "./AnimationTrackBinding.js";
 import { bind_property_writer } from "./bind_property_writer.js";
 import { curve_from_track_data } from "./curve_from_track_data.js";
+import { hemisphere_align_quaternion_values } from "./hemisphere_align_quaternion_values.js";
 
 
 /**
@@ -44,7 +45,7 @@ function track_to_interpolation(track) {
  */
 function convert_three_track_to_curves(track) {
 
-    const values = track.values;
+    let values = track.values;
     const times = track.times;
 
     const key_count = times.length;
@@ -58,6 +59,14 @@ function convert_three_track_to_curves(track) {
     // figure out interpolation type
     const interpolation = track_to_interpolation(track);
 
+    // A quaternion track is interpolated below as four independent per-component curves; without hemisphere
+    // alignment a pair of adjacent keys with a negative dot product interpolates the long way around. Negate
+    // keys into a common hemisphere first so the component nlerp takes the short arc. (Discrete needs no
+    // interpolation; CubicTangents packs tangents per key and is handled separately / not yet aligned.)
+    if (interpolation === AnimationInterpolationKind.Linear && track.ValueTypeName === 'quaternion') {
+        values = hemisphere_align_quaternion_values(values, key_count);
+    }
+
     const values_per_key = values.length / key_count;
 
     const component_count = interpolation === AnimationInterpolationKind.CubicTangents ? values_per_key / 3 : values_per_key;

package/src/engine/animation/clip/hemisphere_align_quaternion_values.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Return a copy of a flat quaternion keyframe-value array (`[x0,y0,z0,w0, x1,y1,z1,w1, ...]`) in which every
+ * key has been negated as needed so that consecutive keys lie in the same hemisphere (their dot product is
+ * non-negative).
+ *
+ * A quaternion and its negation represent the same rotation, so this does not change the pose at any key. It
+ * does change what happens BETWEEN keys: the animation clip pipeline interpolates a quaternion track as four
+ * independent per-component curves (component-wise normalized-lerp), and without hemisphere alignment a pair of
+ * adjacent keys whose dot product is negative interpolates the long way around — spinning nearly 360 degrees and
+ * dipping through a near-degenerate quaternion at the midpoint. Aligning the keys first makes the component nlerp
+ * take the short arc, matching what three.js does at interpolation time via Quaternion.slerpFlat's sign flip.
+ *
+ * The input array is not mutated.
+ *
+ * @param {number[]|Float32Array|Float64Array} values flat quaternion components, 4 per key
+ * @param {number} key_count number of keyframes
+ * @returns {number[]|Float32Array|Float64Array} a copy with hemisphere-aligned keys
+ */
+export function hemisphere_align_quaternion_values(values: number[] | Float32Array | Float64Array, key_count: number): number[] | Float32Array | Float64Array;
+//# sourceMappingURL=hemisphere_align_quaternion_values.d.ts.map

package/src/engine/animation/clip/hemisphere_align_quaternion_values.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hemisphere_align_quaternion_values.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/clip/hemisphere_align_quaternion_values.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,2DAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,aAClC,MAAM,GACJ,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,CAoB9C"}

package/src/engine/animation/clip/hemisphere_align_quaternion_values.js

@@ -0,0 +1,37 @@
+/**
+ * Return a copy of a flat quaternion keyframe-value array (`[x0,y0,z0,w0, x1,y1,z1,w1, ...]`) in which every
+ * key has been negated as needed so that consecutive keys lie in the same hemisphere (their dot product is
+ * non-negative).
+ *
+ * A quaternion and its negation represent the same rotation, so this does not change the pose at any key. It
+ * does change what happens BETWEEN keys: the animation clip pipeline interpolates a quaternion track as four
+ * independent per-component curves (component-wise normalized-lerp), and without hemisphere alignment a pair of
+ * adjacent keys whose dot product is negative interpolates the long way around — spinning nearly 360 degrees and
+ * dipping through a near-degenerate quaternion at the midpoint. Aligning the keys first makes the component nlerp
+ * take the short arc, matching what three.js does at interpolation time via Quaternion.slerpFlat's sign flip.
+ *
+ * The input array is not mutated.
+ *
+ * @param {number[]|Float32Array|Float64Array} values flat quaternion components, 4 per key
+ * @param {number} key_count number of keyframes
+ * @returns {number[]|Float32Array|Float64Array} a copy with hemisphere-aligned keys
+ */
+export function hemisphere_align_quaternion_values(values, key_count) {
+    const out = values.slice();
+
+    for (let i = 1; i < key_count; i++) {
+        const p = (i - 1) * 4;
+        const c = i * 4;
+
+        const dot = out[p] * out[c] + out[p + 1] * out[c + 1] + out[p + 2] * out[c + 2] + out[p + 3] * out[c + 3];
+
+        if (dot < 0) {
+            out[c] = -out[c];
+            out[c + 1] = -out[c + 1];
+            out[c + 2] = -out[c + 2];
+            out[c + 3] = -out[c + 3];
+        }
+    }
+
+    return out;
+}

package/src/engine/animation/curve/actionProcessorOperations/curveActions.d.ts

@@ -28,7 +28,7 @@ export class RemoveKeyframeAction extends Action<any> {
      * @param {keyframesContext} context
      */
     constructor(passKeyframes: List<any>, passNullKeyframe: Keyframe, context: keyframesContext);
-    copyKfToDelete: any;
+    copyKfToDelete: List<any>;
     refNullKeyframe: Keyframe;
     actionContext: keyframesContext;
     linkedActiveKeyframe: any;
@@ -102,6 +102,6 @@ export class SelectionAction extends Action<any> {
 }
 import { AnimationCurve } from "../AnimationCurve.js";
 import { Action } from "../../../../core/process/undo/Action.js";
-import { Keyframe } from "../Keyframe.js";
 import List from "../../../../core/collection/list/List.js";
+import { Keyframe } from "../Keyframe.js";
 //# sourceMappingURL=curveActions.d.ts.map

package/src/engine/animation/curve/actionProcessorOperations/curveActions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"curveActions.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/actionProcessorOperations/curveActions.js"],"names":[],"mappings":"AAKA;IACI;;;;;;;;;;OAUG;IACH,sIATW,cAAc,EAkBxB;IARG,cAAqB;IACrB,sBAAsC;IACtC,mBAAgC;IAChC,sBAAqC;IACrC,uBAAuC;IACvC,2BAA8C;IAC9C,yBAA4C;IAC5C,mBAAgC;CAEvC;AAED;IACI;;;;;OAKG;IACH,wDAHW,QAAQ,WACR,gBAAgB,EAc1B;IAVG,oBAA2C;IAC3C,0BAAuC;IAEvC,gCAA4B;IAE5B,0BAAsE;IACtE,oCAA0C;IAM9C,mCASC;IAED,oCAMC;CACJ;AAED;IACI;;;;OAIG;IACH,0BAHW,QAAQ,WACR,gBAAgB,EAO1B;IAHG,2BAA4C;IAE5C,gCAA4B;IAGhC,mCAIC;IAED,oCAKC;CACJ;AAED;IACI;;;;;;;OAOG;IACH,iCANW,cAAc,qBACd,cAAc,qBACd,cAAc,mBACd,cAAc,WACd,gBAAgB,EAW1B;IAPG,8BAAsC;IACtC,gCAAkD;IAElD,4BAAkC;IAClC,8BAA8C;IAE9C,gCAA4B;IAGhC,mCAQC;IAED,oCAKC;CACJ;AAED;IACI;;;;;;;OAOG;IACH,0BANW,QAAQ,0BACR,QAAQ,wBACR,QAAQ,0CAER,gBAAgB,EAU1B;IANG,sBAA+B;IAC/B,6BAAwD;IACxD,2BAAoD;IAEpD,gCAA4B;IAC5B,gCAAgD;IAGpD,mCAKC;IAED,oCAKC;CACJ;AAED;IACI;;;;;;OAMG;IACH,uHAFW,gBAAgB,EAU1B;IANG,gCAAiD;IACjD,wBAA8B;IAE9B,4BAAkC;IAElC,gCAA4B;IAGhC,mCAMC;IAED,oCAMC;CACJ;+BAzM4B,sBAAsB;uBAD9B,yCAAyC;yBAEvC,gBAAgB;iBACtB,0CAA0C"}
+{"version":3,"file":"curveActions.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/actionProcessorOperations/curveActions.js"],"names":[],"mappings":"AAKA;IACI;;;;;;;;;;OAUG;IACH,sIATW,cAAc,EAkBxB;IARG,cAAqB;IACrB,sBAAsC;IACtC,mBAAgC;IAChC,sBAAqC;IACrC,uBAAuC;IACvC,2BAA8C;IAC9C,yBAA4C;IAC5C,mBAAgC;CAEvC;AAED;IACI;;;;;OAKG;IACH,wDAHW,QAAQ,WACR,gBAAgB,EAc1B;IAVG,0BAA2C;IAC3C,0BAAuC;IAEvC,gCAA4B;IAE5B,0BAAsE;IACtE,oCAA0C;IAM9C,mCASC;IAED,oCAMC;CACJ;AAED;IACI;;;;OAIG;IACH,0BAHW,QAAQ,WACR,gBAAgB,EAO1B;IAHG,2BAA4C;IAE5C,gCAA4B;IAGhC,mCAIC;IAED,oCAKC;CACJ;AAED;IACI;;;;;;;OAOG;IACH,iCANW,cAAc,qBACd,cAAc,qBACd,cAAc,mBACd,cAAc,WACd,gBAAgB,EAW1B;IAPG,8BAAsC;IACtC,gCAAkD;IAElD,4BAAkC;IAClC,8BAA8C;IAE9C,gCAA4B;IAGhC,mCAQC;IAED,oCAKC;CACJ;AAED;IACI;;;;;;;OAOG;IACH,0BANW,QAAQ,0BACR,QAAQ,wBACR,QAAQ,0CAER,gBAAgB,EAU1B;IANG,sBAA+B;IAC/B,6BAAwD;IACxD,2BAAoD;IAEpD,gCAA4B;IAC5B,gCAAgD;IAGpD,mCAKC;IAED,oCAKC;CACJ;AAED;IACI;;;;;;OAMG;IACH,uHAFW,gBAAgB,EAU1B;IANG,gCAAiD;IACjD,wBAA8B;IAE9B,4BAAkC;IAElC,gCAA4B;IAGhC,mCAMC;IAED,oCAMC;CACJ;+BAzM4B,sBAAsB;uBAD9B,yCAAyC;iBAG7C,0CAA0C;yBADpC,gBAAgB"}

package/src/engine/animation/curve/editor/createKeyframeMarker.d.ts

@@ -1,2 +1,2 @@
-export function createKeyframeMarker(): void;
+export function createKeyframeMarker(): import("../../../../view/View.js").default;
 //# sourceMappingURL=createKeyframeMarker.d.ts.map

package/src/engine/animation/curve/editor/createKeyframeMarker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createKeyframeMarker.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/editor/createKeyframeMarker.js"],"names":[],"mappings":"AAEA,6CAQC"}
+{"version":3,"file":"createKeyframeMarker.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/editor/createKeyframeMarker.js"],"names":[],"mappings":"AAEA,mFAQC"}

package/src/engine/animation/keyed2/AnimationTrackPlayback.d.ts

@@ -21,7 +21,7 @@ declare class AnimationTrackPlayback {
     __loop: boolean;
     __valueBuffer: Float64Array;
     on: {
-        ended: Signal<any, any, any, any, any, any, any, any>;
+        ended: Signal;
     };
     /**
      *

package/src/engine/animation/keyed2/AnimationTrackPlayback.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AnimationTrackPlayback.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/keyed2/AnimationTrackPlayback.js"],"names":[],"mappings":";AAGA;IACI;;;;;;;;OAQG;IACH,4EAuBC;IAtBG,sBAAkB;IAClB,cAA+B;IAE/B,oBAAoC;IACpC,kBAAgC;IAEhC,uBAAuB;IACvB,8BAA8B;IAE9B,uBAAuB;IACvB,sBAAsB;IAEtB,gBAAmB;IAEnB,4BAA0D;IAG1D;;MAEC;IAKL;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,gBAFa,QAAQ,IAAI,CAAC,CAUzB;IAED;;;OAGG;IACH,WAFW,OAAO,QAIjB;IAED,cAEC;IAED;;;OAGG;IACH,kBAFW,MAAM,QA2BhB;IAED;;;OAGG;IACH,cAFa,OAAO,CA2CnB;IAED;;;OAGG;IACH,mBAFW,MAAM,QA+BhB;IAED,eAOC;IAED;;;OAGG;IACH,0BAFW,MAAM,EAAE,QA2ClB;CACJ;mBAhPkB,uCAAuC"}
+{"version":3,"file":"AnimationTrackPlayback.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/keyed2/AnimationTrackPlayback.js"],"names":[],"mappings":";AAGA;IACI;;;;;;;;OAQG;IACH,4EAuBC;IAtBG,sBAAkB;IAClB,cAA+B;IAE/B,oBAAoC;IACpC,kBAAgC;IAEhC,uBAAuB;IACvB,8BAA8B;IAE9B,uBAAuB;IACvB,sBAAsB;IAEtB,gBAAmB;IAEnB,4BAA0D;IAG1D;;MAEC;IAKL;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,gBAFa,QAAQ,IAAI,CAAC,CAUzB;IAED;;;OAGG;IACH,WAFW,OAAO,QAIjB;IAED,cAEC;IAED;;;OAGG;IACH,kBAFW,MAAM,QA2BhB;IAED;;;OAGG;IACH,cAFa,OAAO,CA2CnB;IAED;;;OAGG;IACH,mBAFW,MAAM,QAmChB;IAED,eAOC;IAED;;;OAGG;IACH,0BAFW,MAAM,EAAE,QA2ClB;CACJ;mBApPkB,uCAAuC"}

package/src/engine/animation/keyed2/AnimationTrackPlayback.js

@@ -159,7 +159,11 @@ class AnimationTrackPlayback {
         if (timeDelta < 0) {
             //negative delta, going back in time
             this.setPosition(newPosition);
-        } else if (newPosition > this.__nextKeyTime) {
+            // the `>= timeEnd` term catches a frame that lands EXACTLY on the end: __nextKeyTime equals
+            // timeEnd on the final segment, so the strict `> __nextKeyTime` test would skip it, and the
+            // one-shot `ended` (guarded by position < timeEnd) would then never fire. Mid-track exact
+            // landings do not reach timeEnd, so they stay on the plain else branch as before.
+        } else if (newPosition > this.__nextKeyTime || newPosition >= this.track.timeEnd) {
 
             if (newPosition >= this.track.timeEnd) {
                 if (this.__loop) {

package/src/engine/animation/keyed2/behavior/AnimationBehavior.d.ts

@@ -9,7 +9,6 @@ export class AnimationBehavior extends Behavior<any> {
      * @type {AnimationTrackPlayback}
      */
     animation: AnimationTrackPlayback;
-    initialize(_ignore_: any): void;
 }
 import { Behavior } from "../../../intelligence/behavior/Behavior.js";
 //# sourceMappingURL=AnimationBehavior.d.ts.map

package/src/engine/animation/keyed2/behavior/AnimationBehavior.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AnimationBehavior.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/keyed2/behavior/AnimationBehavior.js"],"names":[],"mappings":"AAGA;IACI;;;OAGG;IACH,+CAOC;IALG;;;OAGG;IACH,kCAA0B;IAqB9B,gCAEC;CACJ;yBAtCwB,4CAA4C"}
+{"version":3,"file":"AnimationBehavior.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/keyed2/behavior/AnimationBehavior.js"],"names":[],"mappings":"AAGA;IACI;;;OAGG;IACH,+CAOC;IALG;;;OAGG;IACH,kCAA0B;CAwBjC;yBAtCwB,4CAA4C"}

package/src/engine/asset/Asset.d.ts

@@ -1,7 +1,47 @@
-export class Asset<T> {
-    constructor()
-
-    public readonly byteSize: number
-
-    public create(): T
-}
+/**
+ * @template T
+ *
+ */
+export class Asset<T> {
+    /**
+     * @template T
+     * @param {function():T} [factory]
+     * @param {number} [byteSize] byte size of the asset in RAM
+     * @constructor
+     */
+    constructor(factory?: () => T_1, byteSize?: number);
+    /**
+     *
+     * @type {function(): T}
+     */
+    factory: () => T_1;
+    /**
+     *
+     * @type {number}
+     */
+    byteSize: number;
+    /**
+     * Descriptions of assets this asset depends on.
+     * Populated by the {@link AssetManager} from nested requests made by the loader during the load.
+     * @type {Array<AssetDescription>}
+     */
+    dependencies: Array<AssetDescription>;
+    /**
+     *
+     * @type {AssetDescription}
+     */
+    description: AssetDescription;
+    /**
+     *
+     * @param {Asset} other
+     * @returns {boolean}
+     */
+    equals(other: Asset<any>): boolean;
+    hash(): any;
+    /**
+     *
+     * @returns {T}
+     */
+    create(): T;
+}
+//# sourceMappingURL=Asset.d.ts.map