@woosh/meep-engine 2.165.5 → 2.165.7

package/src/engine/ecs/parent/ChildEntities.d.ts

@@ -1,3 +1,23 @@
-export class ChildEntities {
-    readonly entities: number[]
-}
+export class ChildEntities {
+    /**
+     *
+     * @param {number[]} elements
+     * @returns {ChildEntities}
+     */
+    static from(elements: number[]): ChildEntities;
+    /**
+     * Directly attached children, must have to relevant {@link ParentEntity} components in children as well
+     * @readonly
+     * @type {number[]}
+     */
+    readonly entities: number[];
+    toJSON(): {
+        entities: number[];
+    };
+    /**
+     *
+     * @param {number[]} entities
+     */
+    fromJSON({ entities }: number[]): void;
+}
+//# sourceMappingURL=ChildEntities.d.ts.map

package/src/engine/ecs/parent/EntityNode.d.ts

@@ -1,25 +1,157 @@
-import Entity from "../Entity";
-import {EntityComponentDataset} from "../EntityComponentDataset";
-import {Transform} from "../transform/Transform";
-
-export class EntityNode {
-    constructor(entity?: Entity)
-
-    readonly root: EntityNode
-    readonly parent: EntityNode | null
-    readonly entity: Entity
-
-    readonly transform: Transform
-
-    readonly children: Readonly<EntityNode[]>
-
-    addChild(node: EntityNode): boolean
-
-    removeChild(node: EntityNode): boolean
-
-    traverse(visitor: (node: EntityNode) => any, thisArg?: any): void
-
-    build(ecd: EntityComponentDataset): void
-
-    destroy(): void
-}
+/**
+ * Scene-graph abstraction.
+ * This is syntactic sugar on top of {@link TransformAttachment} and {@link ParentEntity} components that makes working with hierarchies easier.
+ */
+export class EntityNode {
+    /**
+     *
+     * @param {*} components
+     * @return {EntityNode}
+     */
+    static fromComponents(...components: any): EntityNode;
+    /**
+     *
+     * @param {Entity} [entity] optional entity to be wrapped
+     */
+    constructor(entity?: Entity);
+    /**
+     *
+     * @type {EntityNode|null}
+     * @private
+     */
+    private __parent;
+    /**
+     *
+     * @type {EntityNode[]}
+     * @private
+     */
+    private __children;
+    /**
+     * Local transform
+     * @type {Transform}
+     * @private
+     */
+    private __transform;
+    on: {
+        built: Signal;
+        destroyed: Signal;
+    };
+    /**
+     *
+     * @type {number}
+     */
+    flags: number;
+    /**
+     *
+     * @type {Entity}
+     * @private
+     */
+    private __entity;
+    /**
+     *
+     * @param {number|EntityNodeFlags} flag
+     * @returns {void}
+     */
+    setFlag(flag: number | EntityNodeFlags): void;
+    /**
+     *
+     * @param {number|EntityNodeFlags} flag
+     * @returns {void}
+     */
+    clearFlag(flag: number | EntityNodeFlags): void;
+    /**
+     *
+     * @param {number|EntityNodeFlags} flag
+     * @param {boolean} value
+     */
+    writeFlag(flag: number | EntityNodeFlags, value: boolean): void;
+    /**
+     *
+     * @param {number|EntityNodeFlags} flag
+     * @returns {boolean}
+     */
+    getFlag(flag: number | EntityNodeFlags): boolean;
+    /**
+     *
+     * @param {function(node:EntityNode):*} visitor
+     * @param {*} [thisArg]
+     */
+    traverse(visitor: any, thisArg?: any): void;
+    /**
+     *
+     * @param {function(node:EntityNode):*} visitor
+     * @param {*} [context]
+     */
+    traverseChildren(visitor: any, context?: any): void;
+    /**
+     *
+     * @return {Readonly<Array<EntityNode>>}
+     */
+    get children(): readonly EntityNode[];
+    /**
+     *
+     * @private
+     */
+    private __transform_sync_down;
+    /**
+     *
+     * @return {Attachment}
+     * @private
+     */
+    private __safe_get_attachment;
+    /**
+     * @returns {Transform}
+     */
+    get transform(): Transform;
+    /**
+     * Root of the hierarchy, will be `this` if node is already a root
+     * @return {EntityNode}
+     */
+    get root(): EntityNode;
+    /**
+     *
+     * @param {EntityNode|null} node
+     */
+    set parent(arg: EntityNode);
+    /**
+     *
+     * @return {EntityNode|null}
+     */
+    get parent(): EntityNode;
+    /**
+     *
+     * @return {Entity}
+     */
+    get entity(): Entity;
+    /**
+     *
+     * @param {EntityNode} node
+     * @returns {boolean}
+     */
+    addChild(node: EntityNode): boolean;
+    /**
+     *
+     * @param {EntityNode} node
+     * @returns {boolean}
+     */
+    removeChild(node: EntityNode): boolean;
+    get isBuilt(): boolean;
+    attachListeners(): void;
+    detachListeners(): void;
+    /**
+     *
+     * @param {EntityComponentDataset} ecd
+     */
+    build(ecd: EntityComponentDataset): void;
+    destroy(): void;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isEntityNode: boolean;
+}
+import Signal from "../../../core/events/signal/Signal.js";
+import { EntityNodeFlags } from "./EntityNodeFlags.js";
+import { Transform } from "../transform/Transform.js";
+import Entity from "../Entity.js";
+//# sourceMappingURL=EntityNode.d.ts.map

package/src/engine/ecs/parent/ParentEntity.d.ts

@@ -1,11 +1,31 @@
-export class ParentEntity {
-    readonly entity: number
-
-    static from(entity: number): ParentEntity
-
-    toJSON(): any
-
-    fromJSON(j: any): void
-
-    static readonly typeName: string
-}
+/**
+ * Component representing logical attachment to another entity, when the parent disappears - so does the child
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class ParentEntity {
+    /**
+     *
+     * @param {number} entity
+     * @returns {ParentEntity}
+     */
+    static from(entity: number): ParentEntity;
+    /**
+     * Entity representing logical parent.
+     * Must not be mutated (changed) while the component is attached to a dataset
+     * @type {number}
+     */
+    entity: number;
+    toJSON(): {
+        entity: number;
+    };
+    fromJSON({ entity }: {
+        entity: any;
+    }): void;
+}
+export namespace ParentEntity {
+    let typeName: string;
+    let serializable: boolean;
+}
+//# sourceMappingURL=ParentEntity.d.ts.map

package/src/engine/ecs/parent/ParentEntitySystem.d.ts

@@ -1,11 +1,44 @@
-import {System} from "../System";
-import {EntityComponentDataset} from "../EntityComponentDataset";
-import {ParentEntity} from "./ParentEntity";
-
-export class ParentEntitySystem extends System<ParentEntity> {
-    static findRoot(ecd: EntityComponentDataset, entity: number): number
-
-    static isAncestorOf(ecd: EntityComponentDataset, child_entity: number, ancestor_entity: number): boolean
-
-    static findParentEntity(ecd: EntityComponentDataset, entity: number): number
-}
+export class ParentEntitySystem extends AbstractContextSystem<any> {
+    /**
+     * Find root entity given some entity with a {@link ParentEntity} component attached
+     * @param {EntityComponentDataset} ecd
+     * @param {number} entity
+     * @returns {number}
+     */
+    static findRoot(ecd: EntityComponentDataset, entity: number): number;
+    /**
+     * @param {EntityComponentDataset} ecd
+     * @param {number} child_entity
+     * @param {number} ancestor_entity
+     * @returns {boolean}
+     */
+    static isAncestorOf(ecd: EntityComponentDataset, child_entity: number, ancestor_entity: number): boolean;
+    /**
+     * @param {EntityComponentDataset} ecd
+     * @param {number} entity
+     * @returns {number}
+     */
+    static findParentEntity(ecd: EntityComponentDataset, entity: number): number;
+    /**
+     *
+     * @param {number[]} result
+     * @param {number} result_offset
+     * @param {EntityComponentDataset} ecd
+     * @param {number} entity
+     * @returns {number}
+     */
+    static findChildrenOf(result: number[], result_offset: number, ecd: EntityComponentDataset, entity: number): number;
+    /**
+     *
+     * @param {EntityComponentDataset} ecd
+     * @param {number} root_entity
+     * @param {function(number, EntityComponentDataset)} callback
+     * @param {*} [thisArg]
+     */
+    static traverse(ecd: EntityComponentDataset, root_entity: number, callback: (arg0: number, arg1: EntityComponentDataset) => any, thisArg?: any): void;
+    constructor();
+    dependencies: (typeof ParentEntity)[];
+}
+import { AbstractContextSystem } from "../system/AbstractContextSystem.js";
+import { ParentEntity } from "./ParentEntity.js";
+//# sourceMappingURL=ParentEntitySystem.d.ts.map

package/src/engine/ecs/renderable/RenderSystem.d.ts

@@ -1,7 +1,65 @@
-import {System} from "../System";
-import {GraphicsEngine} from "../../graphics/GraphicsEngine";
-import Renderable from "./Renderable";
-
-export default class RenderSystem extends System<Renderable> {
-    constructor(graphics: GraphicsEngine)
-}
+export default RenderSystem;
+/**
+ * @deprecated use {@link ShadedGeometry} instead
+ */
+declare class RenderSystem extends System<any> {
+    /**
+     *
+     * @param {GraphicsEngine} graphicsEngine
+     * @constructor
+     */
+    constructor(graphicsEngine: GraphicsEngine);
+    dependencies: (typeof Transform | typeof Renderable)[];
+    components_used: ResourceAccessSpecification<typeof Renderable>[];
+    entityData: any[];
+    /**
+     *
+     * @type {RenderLayer|null}
+     */
+    renderLayer: RenderLayer | null;
+    /**
+     *
+     * @type {BVH}
+     */
+    bvh: BVH;
+    /**
+     * @type {GraphicsEngine}
+     */
+    graphics: GraphicsEngine;
+    startup(entityManager: any): Promise<void>;
+    shutdown(entityManager: any): Promise<void>;
+    /**
+     *
+     * @param {Renderable} renderable
+     * @param {Transform} transform
+     * @param {int} entity
+     */
+    link(renderable: Renderable, transform: Transform, entity: int): void;
+    /**
+     *
+     * @param {Renderable} renderable
+     * @param {Transform} transform
+     * @param {int} entity
+     */
+    unlink(renderable: Renderable, transform: Transform, entity: int): void;
+    /**
+     *
+     * @param {SurfacePoint3} result
+     * @param {number} origin_x
+     * @param {number} origin_y
+     * @param {number} origin_z
+     * @param {number} direction_x
+     * @param {number} direction_y
+     * @param {number} direction_z
+     * @param {function(number, Renderable, EntityComponentDataset):boolean} [filter]
+     * @param {*} [filterContext]
+     * @returns {number} Entity ID, or -1 if no hit found
+     */
+    query_geometry_raycast_nearest(result: SurfacePoint3, origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number, filter?: (arg0: number, arg1: Renderable, arg2: EntityComponentDataset) => boolean, filterContext?: any): number;
+}
+import { System } from '../System.js';
+import { Transform } from '../transform/Transform.js';
+import Renderable from './Renderable.js';
+import { ResourceAccessSpecification } from "../../../core/model/ResourceAccessSpecification.js";
+import { BVH } from "../../../core/bvh2/bvh3/BVH.js";
+//# sourceMappingURL=RenderSystem.d.ts.map

package/src/engine/ecs/renderable/Renderable.d.ts

@@ -1,25 +1,95 @@
-import {Object3D} from "three";
-import {BvhClient} from "../../../core/bvh2/bvh3/BvhClient";
-import {AABB3} from "../../../core/geom/3d/aabb/AABB3";
-
-export default class Renderable {
-    readonly object: Object3D
-    readonly boundingBox: AABB3
-
-    matrixAutoUpdate: boolean
-    boundingBoxNeedsUpdate: boolean
-
-    readonly bvh: BvhClient
-
-    constructor(object: Object3D)
-
-    setFlag(flag: number): void
-
-    clearFlag(flag: number): void
-
-    writeFlag(flag: number, value: boolean): void
-
-    getFlag(flag: number): boolean
-
-    computeBoundsFromObject(): void
-}
+export default Renderable;
+/**
+ @deprecated use {@link ShadedGeometry} instead
+ */
+declare class Renderable {
+    constructor(object: any);
+    boundingBox: AABB3;
+    bvh: BvhClient;
+    /**
+     *
+     * @type {number}
+     */
+    flags: number;
+    object: any;
+    dispose(): void;
+    configureFromObject(): void;
+    /**
+     *
+     * @param {Object3D} object
+     * @private
+     */
+    private __auto_detect_flag_cast_shadow_from_object;
+    /**
+     *
+     * @param {boolean} v
+     */
+    set matrixAutoUpdate(arg: boolean);
+    /**
+     *
+     * @returns {boolean}
+     */
+    get matrixAutoUpdate(): boolean;
+    /**
+     *
+     * @param {boolean} v
+     */
+    set boundingBoxNeedsUpdate(arg: boolean);
+    /**
+     *
+     * @returns {boolean}
+     */
+    get boundingBoxNeedsUpdate(): boolean;
+    /**
+     *
+     * @param {number|RenderableFlags} flag
+     * @returns {void}
+     */
+    setFlag(flag: number | {
+        BoundingBoxNeedsUpdate: number;
+        UpdateMatrix: number;
+        InView: number;
+        CastShadow: number;
+    }): void;
+    /**
+     *
+     * @param {number|RenderableFlags} flag
+     * @returns {void}
+     */
+    clearFlag(flag: number | {
+        BoundingBoxNeedsUpdate: number;
+        UpdateMatrix: number;
+        InView: number;
+        CastShadow: number;
+    }): void;
+    /**
+     *
+     * @param {number|RenderableFlags} flag
+     * @param {boolean} value
+     */
+    writeFlag(flag: number | {
+        BoundingBoxNeedsUpdate: number;
+        UpdateMatrix: number;
+        InView: number;
+        CastShadow: number;
+    }, value: boolean): void;
+    /**
+     *
+     * @param {number|RenderableFlags} flag
+     * @returns {boolean}
+     */
+    getFlag(flag: number | {
+        BoundingBoxNeedsUpdate: number;
+        UpdateMatrix: number;
+        InView: number;
+        CastShadow: number;
+    }): boolean;
+    computeBoundsFromObject(): void;
+}
+declare namespace Renderable {
+    let typeName: string;
+    let serializable: boolean;
+}
+import { AABB3 } from "../../../core/geom/3d/aabb/AABB3.js";
+import { BvhClient } from "../../../core/bvh2/bvh3/BvhClient.js";
+//# sourceMappingURL=Renderable.d.ts.map

package/src/engine/ecs/speaker/VoiceSystem.d.ts

@@ -9,7 +9,7 @@ export class VoiceSystem extends AbstractContextSystem<any> {
         font_size: number;
     });
     dependencies: (typeof Voice)[];
-    components_used: (ResourceAccessSpecification<typeof GUIElement> | ResourceAccessSpecification<typeof Transform> | ResourceAccessSpecification<typeof ViewportPosition> | ResourceAccessSpecification<typeof HeadsUpDisplay> | ResourceAccessSpecification<typeof Attachment> | ResourceAccessSpecification<typeof SerializationMetadata> | ResourceAccessSpecification<typeof BehaviorComponent>)[];
+    components_used: (ResourceAccessSpecification<typeof Transform> | ResourceAccessSpecification<typeof GUIElement> | ResourceAccessSpecification<typeof ViewportPosition> | ResourceAccessSpecification<typeof HeadsUpDisplay> | ResourceAccessSpecification<typeof Attachment> | ResourceAccessSpecification<typeof SerializationMetadata> | ResourceAccessSpecification<typeof BehaviorComponent>)[];
     /**
      *
      * @type {Localization}
@@ -101,9 +101,9 @@ export class VoiceSystem extends AbstractContextSystem<any> {
 }
 import { AbstractContextSystem } from "../system/AbstractContextSystem.js";
 import { Voice } from "./Voice.js";
-import GUIElement from "../gui/GUIElement.js";
-import { ResourceAccessSpecification } from "../../../core/model/ResourceAccessSpecification.js";
 import { Transform } from "../transform/Transform.js";
+import { ResourceAccessSpecification } from "../../../core/model/ResourceAccessSpecification.js";
+import GUIElement from "../gui/GUIElement.js";
 import ViewportPosition from "../gui/position/ViewportPosition.js";
 import HeadsUpDisplay from "../gui/hud/HeadsUpDisplay.js";
 import { Attachment } from "../attachment/Attachment.js";

package/src/engine/ecs/speaker/VoiceSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VoiceSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/speaker/VoiceSystem.js"],"names":[],"mappings":"AA+JA;IACI;;;;OAIG;IACH;;;OA2FC;IArFG,+BAA2B;IAE3B,qYAQC;IAGD;;;OAGG;IACH,0BAAuB;IAEvB;;;OAGG;IACH,eAAe;IAEf;;;OAGG;IACH,4BAAiB;IAEjB;;;OAGG;IACH,8BAAgB;IAEhB;;;OAGG;IACH,eAAoB;IAEpB;;;;OAIG;IACH,iCAAyC;IAEzC;;;;OAIG;IACH,kBAAkC;IAIlC;;;;OAIG;IACH,eAAkB;IAElB;;;;OAIG;IACH,oBAAgC;IAEhC;;;OAGG;IACH,oBAAqC;IAErC;;;;OAIG;IACH,gBAAoB;IAGxB;;;OAGG;IACH,kBAFY,MAAM,CAIjB;IAEF,2CAqBE;IAED;;;;;OAKG;IACH,uBAJW,MAAM,UACN,MAAM,SACN,KAAK,QAsBf;IAED;;;;;;OAMG;IACH,wBAoBC;IAED;;;;;OAKG;IACH,gBAJW,MAAM,WACN,MAAM,SACN,KAAK,QAuHf;CACJ;sCA3bqC,oCAAoC;sBAIpD,YAAY;uBAPX,sBAAsB;4CAnBD,oDAAoD;0BAwBtE,2BAA2B;6BAHxB,qCAAqC;2BADvC,8BAA8B;2BAL9B,6BAA6B;sCAClB,wCAAwC;kCAR5C,sDAAsD"}
+{"version":3,"file":"VoiceSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/speaker/VoiceSystem.js"],"names":[],"mappings":"AA+JA;IACI;;;;OAIG;IACH;;;OA2FC;IArFG,+BAA2B;IAE3B,qYAQC;IAGD;;;OAGG;IACH,0BAAuB;IAEvB;;;OAGG;IACH,eAAe;IAEf;;;OAGG;IACH,4BAAiB;IAEjB;;;OAGG;IACH,8BAAgB;IAEhB;;;OAGG;IACH,eAAoB;IAEpB;;;;OAIG;IACH,iCAAyC;IAEzC;;;;OAIG;IACH,kBAAkC;IAIlC;;;;OAIG;IACH,eAAkB;IAElB;;;;OAIG;IACH,oBAAgC;IAEhC;;;OAGG;IACH,oBAAqC;IAErC;;;;OAIG;IACH,gBAAoB;IAGxB;;;OAGG;IACH,kBAFY,MAAM,CAIjB;IAEF,2CAqBE;IAED;;;;;OAKG;IACH,uBAJW,MAAM,UACN,MAAM,SACN,KAAK,QAsBf;IAED;;;;;;OAMG;IACH,wBAoBC;IAED;;;;;OAKG;IACH,gBAJW,MAAM,WACN,MAAM,SACN,KAAK,QAuHf;CACJ;sCA3bqC,oCAAoC;sBAIpD,YAAY;0BAFR,2BAA2B;4CAxBT,oDAAoD;uBAmBzE,sBAAsB;6BAEhB,qCAAqC;2BADvC,8BAA8B;2BAL9B,6BAA6B;sCAClB,wCAAwC;kCAR5C,sDAAsD"}

package/src/engine/ecs/storage/binary/BinaryClassSerializationAdapter.d.ts

@@ -1,21 +1,86 @@
-import BinaryBuffer from '../../../../core/binary/BinaryBuffer'
-
-interface Type<T> extends Function {
-    new(...args: any[]): T;
-}
-
-export class BinaryClassSerializationAdapter<T> {
-    readonly klass: Type<T>;
-
-    readonly version: number;
-
-    initialize(...args: any[]): void;
-
-    finalize(): void;
-
-    serialize(buffer: BinaryBuffer, value: T): void
-
-    deserialize(buffer: BinaryBuffer, value: T): void
-
-    readonly isBinaryClassSerializationAdapter = true;
-}
+/**
+ * Defines how to serialize and deserialize an instance of a given class.
+ * This class is intended to be overridden.
+ *
+ * @template T
+ *
+ * @example
+ *      class BookSerializer extends BinaryClassSerializationAdapter{
+ *          klass = Book
+ *          version = 0
+ *
+ *          serialize(buffer: BinaryBuffer, book: Book){
+ *
+ *              buffer.writeUTF8String(book.title);
+ *              buffer.writeUint32(book.page_count);
+ *              buffer.writeUTF8String(book.text);
+ *
+ *          }
+ *
+ *          deserialize(buffer: BinaryBuffer, book: Book){
+ *
+ *              book.title = buffer.readUTF8String();
+ *              book.page_count = buffer.readUint32();
+ *              book.text = buffer.readUTF8String();
+ *
+ *          }
+ *      }
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class BinaryClassSerializationAdapter<T> {
+    /**
+     * Class that this adapter handles.
+     * NOTE: misspelling of the word "class" is intentional, in JavaScript "class" is a reserved word.
+     * @example
+     *    klass = Vector3
+     * @protected
+     * @type {Class<T>}
+     */
+    protected klass: Class<T>;
+    /**
+     * Format version number, used to check for format changes and data compatibility
+     * Increment the number if you change the adapter to indicate the change in format
+     * See {@link BinaryClassUpgrader} for details on how to handle support for outdated format versions
+     * @protected
+     * @type {number}
+     */
+    protected version: number;
+    /**
+     * Invoked externally as part of the serialization lifecycle.
+     * Guaranteed to be invoked before the first usage of the adapter.
+     *
+     * @param args
+     */
+    initialize(...args: any[]): void;
+    /**
+     * Handle any necessary resource cleanup.
+     * Invoked externally as part of the serialization lifecycle
+     * Guaranteed to be invoked after the last usage of the adapter.
+     *
+     */
+    finalize(): void;
+    /**
+     * Serialize an instance into the passed buffer.
+     * Will write at the current {@link BinaryBuffer.position}.
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {T} value
+     */
+    serialize(buffer: BinaryBuffer, value: T): void;
+    /**
+     * Read value from the buffer, passed in value will change as a result.
+     * Will read from the current {@link BinaryBuffer.position}.
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {T} value
+     */
+    deserialize(buffer: BinaryBuffer, value: T): void;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isBinaryClassSerializationAdapter: boolean;
+}
+//# sourceMappingURL=BinaryClassSerializationAdapter.d.ts.map

package/src/engine/ecs/storage/binary/object-v2/serializerTestHarness.d.ts

@@ -9,7 +9,7 @@
  */
 export function roundTrip<T>(value: T, { registry, modules }?: {
     registry?: BinarySerializationRegistry;
-    modules?: ModuleRegistry;
+    modules?: ModuleRegistry<any>;
 }): T;
 /**
  * @param {*} value

package/src/engine/ecs/storage/binary/object-v2/serializerTestHarness.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serializerTestHarness.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/ecs/storage/binary/object-v2/serializerTestHarness.js"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AACH,+DAHW;IAAC,QAAQ,CAAC,EAAE,2BAA2B,CAAC;IAAC,OAAO,CAAC,EAAE,cAAc,CAAA;CAAC,KAS5E;AAED;;;;GAIG;AACH,iDAHW,2BAA2B,GACzB,YAAY,CAQxB;AAED;;;;GAIG;AACH,sDAHW,2BAA2B,GACzB,MAAM,CAIlB;4CAzC2C,mCAAmC;+BADhD,6CAA6C;6BAD/C,4CAA4C"}
+{"version":3,"file":"serializerTestHarness.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/ecs/storage/binary/object-v2/serializerTestHarness.js"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AACH,+DAHW;IAAC,QAAQ,CAAC,EAAE,2BAA2B,CAAC;IAAC,OAAO,CAAC,sBAAgB;CAAC,KAS5E;AAED;;;;GAIG;AACH,iDAHW,2BAA2B,GACzB,YAAY,CAQxB;AAED;;;;GAIG;AACH,sDAHW,2BAA2B,GACzB,MAAM,CAIlB;4CAzC2C,mCAAmC;+BADhD,6CAA6C;6BAD/C,4CAA4C"}

package/src/engine/ecs/system/AbstractContextSystem.d.ts

@@ -2,7 +2,7 @@
  * @template T
  * Creates and tracks a separate context for each linked entity, mostly targeted at event-driven system implementations
  */
-export class AbstractContextSystem<T> extends System<any, any, any, any, any> {
+export class AbstractContextSystem<T> extends System<any> {
     /**
      * @template T
      * @param {Class<SystemEntityContext>} ContextClass

package/src/engine/ecs/system_validate_class.d.ts

@@ -3,6 +3,6 @@
  * @param {System} system
  * @throws {Error} if the system fails validation
  */
-export function system_validate_class(system: System<any, any, any, any, any>): void;
+export function system_validate_class(system: System<any>): void;
 import { System } from "./System.js";
 //# sourceMappingURL=system_validate_class.d.ts.map