@woosh/meep-engine 3.16.0 → 3.17.0

package/src/engine/ecs/transform/TRANSFORM64_EVENT_CHANGE.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Entity event announcing that an entity's {@link Transform64} was mutated in place.
+ *
+ * A {@link Transform64} carries no signals - that is the point of it - so a write is invisible
+ * until someone says so, and saying so is the writer's job. Everything that used to wake on
+ * `position.onChanged` waits on this instead: the render placement, the parent/child sync,
+ * fog-of-war, the grid mirror, the spatial audio refit.
+ *
+ * The name is the whole message, and there is no payload. A listener is registered against one
+ * entity and one event name, so by the time it runs it already knows which entity moved, that what
+ * moved was the transform, and which instance that is - it was handed the instance when it linked.
+ * Anything sent alongside would only be handing back what the listener already holds, at the price
+ * of an `if` at the top of every listener to discard the dispatches meant for somebody else.
+ *
+ * Announce with {@link t64_announce_change}, once per group of writes:
+ *
+ * ```
+ * transform.setRotation(x, y, z, w);
+ * transform.updateMatrix();
+ *
+ * t64_announce_change(ecd, entity);
+ * ```
+ *
+ * Deliberately coarse - it says *that* the transform changed, not *what* changed inside it. A
+ * transform rewritten wholesale, as {@link Transform64#multiplyTransforms} rewrites one, has no
+ * finer answer to give, and a per-channel axis running beside this one would be a second mechanism
+ * describing one write. Waking on a superset of what you care about is expected: a consumer woken
+ * by a scale write when it only tracks translation does redundant work, not wrong work. Where that
+ * is too expensive, that one consumer keeps a copy and compares against it.
+ *
+ * @type {string}
+ *
+ * @see t64_announce_change
+ * @see TRANSFORM_ATTACHMENT_EVENT_CHANGE
+ * @see EntityComponentDataset#addEntityEventListener
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export const TRANSFORM64_EVENT_CHANGE: string;
+//# sourceMappingURL=TRANSFORM64_EVENT_CHANGE.d.ts.map

package/src/engine/ecs/transform/TRANSFORM64_EVENT_CHANGE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TRANSFORM64_EVENT_CHANGE.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/transform/TRANSFORM64_EVENT_CHANGE.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,uCATU,MAAM,CAS8C"}

package/src/engine/ecs/transform/TRANSFORM64_EVENT_CHANGE.js

@@ -0,0 +1,40 @@
+/**
+ * Entity event announcing that an entity's {@link Transform64} was mutated in place.
+ *
+ * A {@link Transform64} carries no signals - that is the point of it - so a write is invisible
+ * until someone says so, and saying so is the writer's job. Everything that used to wake on
+ * `position.onChanged` waits on this instead: the render placement, the parent/child sync,
+ * fog-of-war, the grid mirror, the spatial audio refit.
+ *
+ * The name is the whole message, and there is no payload. A listener is registered against one
+ * entity and one event name, so by the time it runs it already knows which entity moved, that what
+ * moved was the transform, and which instance that is - it was handed the instance when it linked.
+ * Anything sent alongside would only be handing back what the listener already holds, at the price
+ * of an `if` at the top of every listener to discard the dispatches meant for somebody else.
+ *
+ * Announce with {@link t64_announce_change}, once per group of writes:
+ *
+ * ```
+ * transform.setRotation(x, y, z, w);
+ * transform.updateMatrix();
+ *
+ * t64_announce_change(ecd, entity);
+ * ```
+ *
+ * Deliberately coarse - it says *that* the transform changed, not *what* changed inside it. A
+ * transform rewritten wholesale, as {@link Transform64#multiplyTransforms} rewrites one, has no
+ * finer answer to give, and a per-channel axis running beside this one would be a second mechanism
+ * describing one write. Waking on a superset of what you care about is expected: a consumer woken
+ * by a scale write when it only tracks translation does redundant work, not wrong work. Where that
+ * is too expensive, that one consumer keeps a copy and compares against it.
+ *
+ * @type {string}
+ *
+ * @see t64_announce_change
+ * @see TRANSFORM_ATTACHMENT_EVENT_CHANGE
+ * @see EntityComponentDataset#addEntityEventListener
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export const TRANSFORM64_EVENT_CHANGE = "@transform64/change";

package/src/engine/ecs/transform/TRANSFORM64_MIGRATION_PLAN_2026_09_04.md

@@ -5,6 +5,14 @@ change-detection mechanism next to one the ECS already has, it proposed deleting
 "no importers" evidence, and its facade would have left the abstraction layers Transform64 exists to
 remove. This revision replaces the architecture; the survey work underneath it stands.*
 
+*Update, 2026-09-05: the change-detection mechanism specified below - `EventType.ComponentChanged`
+carrying `{klass, instance}` - has been replaced by one event name per component that announces
+itself: `TRANSFORM64_EVENT_CHANGE` (`@transform64/change`) and `TRANSFORM_ATTACHMENT_EVENT_CHANGE`
+(`@transform_attachment/change`), each sent with no payload, so a listener is woken only by the
+thing it asked about and has nothing to filter. `EventType.ComponentChanged` is gone, and with it
+the residual unknown about broadening it. Everything else here stands; read `ComponentChanged`
+throughout as "the changed component's own event".*
+
 ---
 
 ## Where things stand

package/src/engine/ecs/transform/t64_announce_change.d.ts

@@ -3,13 +3,16 @@
  *
  * A {@link Transform64} carries no signals - that is the point of it - so a write is invisible until
  * someone says so, and saying so is the writer's job. Every consumer that used to wake on
- * `position.onChanged` wakes on {@link EventType.ComponentChanged} instead: the render placement,
+ * `position.onChanged` wakes on {@link TRANSFORM64_EVENT_CHANGE} instead: the render placement,
  * the parent/child sync, fog-of-war, the grid mirror, the spatial audio refit.
  *
- * The announcement is deliberately coarse - it names the component, not what changed inside it - so
+ * The announcement is deliberately coarse - it names the transform, not what changed inside it - so
  * a consumer that only tracks translation still wakes on a scale write. That is redundant work, not
  * wrong work, and it is what lets one call stand in for the three signals it replaces.
  *
+ * Nothing is sent with it. The event names the transform and reaches only this entity's listeners,
+ * which is everything a listener needs to know; the instance it wants is the one it linked with.
+ *
  * Call it once per group of writes, after the last of them and after any
  * {@link Transform64#updateMatrix} the group owes:
  *
@@ -17,17 +20,17 @@
  * transform.setRotation(x, y, z, w);
  * transform.updateMatrix();
  *
- * t64_announce_change(ecd, entity, transform);
+ * t64_announce_change(ecd, entity);
  * ```
  *
  * @param {EntityComponentDataset} ecd
- * @param {number} entity
- * @param {Transform64} transform the instance that was written, handed to listeners as `instance`
+ * @param {number} entity the entity whose transform was written
  * @returns {void}
  *
+ * @see TRANSFORM64_EVENT_CHANGE
+ *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
-export function t64_announce_change(ecd: EntityComponentDataset, entity: number, transform: Transform64): void;
-import { Transform64 } from "./Transform64.js";
+export function t64_announce_change(ecd: EntityComponentDataset, entity: number): void;
 //# sourceMappingURL=t64_announce_change.d.ts.map

package/src/engine/ecs/transform/t64_announce_change.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"t64_announce_change.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/transform/t64_announce_change.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,yEAPW,MAAM,aACN,WAAW,GACT,IAAI,CAUhB;4BArC2B,kBAAkB"}
+{"version":3,"file":"t64_announce_change.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/transform/t64_announce_change.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,yEARW,MAAM,GACJ,IAAI,CAShB"}

package/src/engine/ecs/transform/t64_announce_change.js

@@ -1,18 +1,20 @@
-import { EventType } from "../EventType.js";
-import { Transform64 } from "./Transform64.js";
+import { TRANSFORM64_EVENT_CHANGE } from "./TRANSFORM64_EVENT_CHANGE.js";
 
 /**
  * Tell the dataset that an entity's {@link Transform64} was mutated in place.
  *
  * A {@link Transform64} carries no signals - that is the point of it - so a write is invisible until
  * someone says so, and saying so is the writer's job. Every consumer that used to wake on
- * `position.onChanged` wakes on {@link EventType.ComponentChanged} instead: the render placement,
+ * `position.onChanged` wakes on {@link TRANSFORM64_EVENT_CHANGE} instead: the render placement,
  * the parent/child sync, fog-of-war, the grid mirror, the spatial audio refit.
  *
- * The announcement is deliberately coarse - it names the component, not what changed inside it - so
+ * The announcement is deliberately coarse - it names the transform, not what changed inside it - so
  * a consumer that only tracks translation still wakes on a scale write. That is redundant work, not
  * wrong work, and it is what lets one call stand in for the three signals it replaces.
  *
+ * Nothing is sent with it. The event names the transform and reaches only this entity's listeners,
+ * which is everything a listener needs to know; the instance it wants is the one it linked with.
+ *
  * Call it once per group of writes, after the last of them and after any
  * {@link Transform64#updateMatrix} the group owes:
  *
@@ -20,20 +22,18 @@ import { Transform64 } from "./Transform64.js";
  * transform.setRotation(x, y, z, w);
  * transform.updateMatrix();
  *
- * t64_announce_change(ecd, entity, transform);
+ * t64_announce_change(ecd, entity);
  * ```
  *
  * @param {EntityComponentDataset} ecd
- * @param {number} entity
- * @param {Transform64} transform the instance that was written, handed to listeners as `instance`
+ * @param {number} entity the entity whose transform was written
  * @returns {void}
  *
+ * @see TRANSFORM64_EVENT_CHANGE
+ *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
-export function t64_announce_change(ecd, entity, transform) {
-    ecd.sendEvent(entity, EventType.ComponentChanged, {
-        klass: Transform64,
-        instance: transform
-    });
+export function t64_announce_change(ecd, entity) {
+    ecd.sendEvent(entity, TRANSFORM64_EVENT_CHANGE);
 }

package/src/engine/ecs/transform-attachment/TRANSFORM_ATTACHMENT_EVENT_CHANGE.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Entity event announcing that an entity's {@link TransformAttachment} was mutated in place.
+ *
+ * The other half of the spatial hierarchy from {@link TRANSFORM64_EVENT_CHANGE}, and announced for
+ * the same reason: the offset a {@link TransformAttachment} holds is plain data, so writing it says
+ * nothing, and {@link TransformAttachmentSystem} is waiting to hear that it changed before it
+ * recomposes the entity's world {@link Transform64} and everything below it.
+ *
+ * A solved bone angle comes through here rather than through the transform channel, because a
+ * bone's local pose is not a component in its own right - it lives inside the attachment.
+ *
+ * No payload, for the reason {@link TRANSFORM64_EVENT_CHANGE} carries none: the listener is already
+ * holding the attachment it linked with.
+ *
+ * ```
+ * attachment.transform.copy(pose);
+ *
+ * ecd.sendEvent(entity, TRANSFORM_ATTACHMENT_EVENT_CHANGE);
+ * ```
+ *
+ * @type {string}
+ *
+ * @see TRANSFORM64_EVENT_CHANGE
+ * @see EntityComponentDataset#addEntityEventListener
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export const TRANSFORM_ATTACHMENT_EVENT_CHANGE: string;
+//# sourceMappingURL=TRANSFORM_ATTACHMENT_EVENT_CHANGE.d.ts.map

package/src/engine/ecs/transform-attachment/TRANSFORM_ATTACHMENT_EVENT_CHANGE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TRANSFORM_ATTACHMENT_EVENT_CHANGE.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/transform-attachment/TRANSFORM_ATTACHMENT_EVENT_CHANGE.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,gDARU,MAAM,CAQgE"}

package/src/engine/ecs/transform-attachment/TRANSFORM_ATTACHMENT_EVENT_CHANGE.js

@@ -0,0 +1,29 @@
+/**
+ * Entity event announcing that an entity's {@link TransformAttachment} was mutated in place.
+ *
+ * The other half of the spatial hierarchy from {@link TRANSFORM64_EVENT_CHANGE}, and announced for
+ * the same reason: the offset a {@link TransformAttachment} holds is plain data, so writing it says
+ * nothing, and {@link TransformAttachmentSystem} is waiting to hear that it changed before it
+ * recomposes the entity's world {@link Transform64} and everything below it.
+ *
+ * A solved bone angle comes through here rather than through the transform channel, because a
+ * bone's local pose is not a component in its own right - it lives inside the attachment.
+ *
+ * No payload, for the reason {@link TRANSFORM64_EVENT_CHANGE} carries none: the listener is already
+ * holding the attachment it linked with.
+ *
+ * ```
+ * attachment.transform.copy(pose);
+ *
+ * ecd.sendEvent(entity, TRANSFORM_ATTACHMENT_EVENT_CHANGE);
+ * ```
+ *
+ * @type {string}
+ *
+ * @see TRANSFORM64_EVENT_CHANGE
+ * @see EntityComponentDataset#addEntityEventListener
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export const TRANSFORM_ATTACHMENT_EVENT_CHANGE = "@transform_attachment/change";

package/src/engine/ecs/transform-attachment/TransformAttachmentSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TransformAttachmentSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/transform-attachment/TransformAttachmentSystem.js"],"names":[],"mappings":"AAiMA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;;IAEI;;;;OAIG;IACH,mBAAgB;IAEhB;;;;;OAKG;IACH,mBAAoC;IAEpC;;;;OAIG;IACH,gBAAa;IACb,qBAAiB;IACjB,uBAAmB;IAEnB,kEAAkD;IAClD,+HAGE;IAEF;;;;OAIG;IACH,wBASC;IAED;;;;OAIG;IACH,kBAEC;IAED;;;;;OAKG;IACH,yBAYC;IAED;;;;;;;;OAQG;IACH,uBALW,MAAM,EAAE,iBACR,MAAM,UACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,wBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,iBAJW,mBAAmB,aACnB,WAAW,UACX,MAAM,QAsBhB;IAED;;;;;OAKG;IACH,mBAJW,mBAAmB,aACnB,WAAW,UACX,MAAM,QAkBhB;IAED,6BAoBC;CACJ;uBAtYsB,cAAc;4BACT,6BAA6B;oCACK,0BAA0B;4CAL5C,oDAAoD"}
+{"version":3,"file":"TransformAttachmentSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/transform-attachment/TransformAttachmentSystem.js"],"names":[],"mappings":"AAyLA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;;IAEI;;;;OAIG;IACH,mBAAgB;IAEhB;;;;;OAKG;IACH,mBAAoC;IAEpC;;;;OAIG;IACH,gBAAa;IACb,qBAAiB;IACjB,uBAAmB;IAEnB,kEAAkD;IAClD,+HAGE;IAEF;;;;OAIG;IACH,wBASC;IAED;;;;OAIG;IACH,kBAEC;IAED;;;;;OAKG;IACH,yBAYC;IAED;;;;;;;;OAQG;IACH,uBALW,MAAM,EAAE,iBACR,MAAM,UACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,wBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,iBAJW,mBAAmB,aACnB,WAAW,UACX,MAAM,QAsBhB;IAED;;;;;OAKG;IACH,mBAJW,mBAAmB,aACnB,WAAW,UACX,MAAM,QAkBhB;IAED,6BAoBC;CACJ;uBA9XsB,cAAc;4BAET,6BAA6B;oCAEK,0BAA0B;4CAP5C,oDAAoD"}

package/src/engine/ecs/transform-attachment/TransformAttachmentSystem.js

@@ -4,7 +4,9 @@ import { ResourceAccessSpecification } from "../../../core/model/ResourceAccessS
 import { EventType } from "../EventType.js";
 import { EntityChildIndex } from "../hierarchy/EntityChildIndex.js";
 import { System } from "../System.js";
+import { TRANSFORM64_EVENT_CHANGE } from "../transform/TRANSFORM64_EVENT_CHANGE.js";
 import { Transform64 } from "../transform/Transform64.js";
+import { TRANSFORM_ATTACHMENT_EVENT_CHANGE } from "./TRANSFORM_ATTACHMENT_EVENT_CHANGE.js";
 import { TransformAttachment, TransformAttachmentFlags } from "./TransformAttachment.js";
 
 /**
@@ -74,10 +76,7 @@ class UpdateContext {
          Note that nothing here listens to this: reacting to your own output is a loop, which is
          why the self-listener below is about the attachment only.
         */
-        this.ecd.sendEvent(this.entity, EventType.ComponentChanged, {
-            klass: Transform64,
-            instance: this.transform
-        });
+        this.ecd.sendEvent(this.entity, TRANSFORM64_EVENT_CHANGE);
     }
 
     /**
@@ -122,30 +121,23 @@ class UpdateContext {
 
     link() {
         // Neither transform carries signals any more, so both announcements come through the
-        // dataset. The parent's pose arrives as a change to its own Transform64 - whether the
-        // parent is a root somebody moved or a link whose own composition just ran; the attachment's
-        // offset arrives as a change to the TransformAttachment component holding it.
-        this.#on_parent_changed = event => {
-            if (event.klass === Transform64) {
-                this.update();
-            }
-        };
+        // dataset, on the channel belonging to the thing that moved. The parent's pose arrives as
+        // TRANSFORM64_EVENT_CHANGE on the parent - whether it is a root somebody moved or a link
+        // whose own composition just ran; the offset arrives as TRANSFORM_ATTACHMENT_EVENT_CHANGE
+        // on this entity, from whoever wrote the attachment.
+        this.#on_parent_changed = () => this.update();
 
-        this.#on_self_changed = event => {
-            if (event.klass === TransformAttachment) {
-                this.update();
-            }
-        };
+        this.#on_self_changed = () => this.update();
 
         this.ecd.addEntityEventListener(
             this.attachment.parent,
-            EventType.ComponentChanged,
+            TRANSFORM64_EVENT_CHANGE,
             this.#on_parent_changed
         );
 
         this.ecd.addEntityEventListener(
             this.entity,
-            EventType.ComponentChanged,
+            TRANSFORM_ATTACHMENT_EVENT_CHANGE,
             this.#on_self_changed
         );
 
@@ -165,7 +157,7 @@ class UpdateContext {
         if (this.#on_parent_changed !== null) {
             this.ecd.removeEntityEventListener(
                 this.attachment.parent,
-                EventType.ComponentChanged,
+                TRANSFORM64_EVENT_CHANGE,
                 this.#on_parent_changed
             );
 
@@ -175,7 +167,7 @@ class UpdateContext {
         if (this.#on_self_changed !== null) {
             this.ecd.removeEntityEventListener(
                 this.entity,
-                EventType.ComponentChanged,
+                TRANSFORM_ATTACHMENT_EVENT_CHANGE,
                 this.#on_self_changed
             );
 

package/src/engine/graphics/ecs/sprite/SpriteSystemPE.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SpriteSystemPE.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/sprite/SpriteSystemPE.js"],"names":[],"mappings":"AA0IA;IAGI,cAEC;IAJD,qDAAqC;CAKxC;sCA7IqC,8CAA8C;4BAGxD,uCAAuC;uBAQ5C,aAAa"}
+{"version":3,"file":"SpriteSystemPE.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/sprite/SpriteSystemPE.js"],"names":[],"mappings":"AAsIA;IAGI,cAEC;IAJD,qDAAqC;CAKxC;sCAzIqC,8CAA8C;4BAGxD,uCAAuC;uBAQ5C,aAAa"}

package/src/engine/graphics/ecs/sprite/SpriteSystemPE.js

@@ -3,7 +3,7 @@ import { SerializationMetadata } from "../../../ecs/components/SerializationMeta
 import Entity from "../../../ecs/Entity.js";
 import { AbstractContextSystem } from "../../../ecs/system/AbstractContextSystem.js";
 import { SystemEntityContext } from "../../../ecs/system/SystemEntityContext.js";
-import { EventType } from "../../../ecs/EventType.js";
+import { TRANSFORM64_EVENT_CHANGE } from "../../../ecs/transform/TRANSFORM64_EVENT_CHANGE.js";
 import { Transform64 } from "../../../ecs/transform/Transform64.js";
 import {
     PARTICLE_ATTRIBUTE_COLOR,
@@ -102,14 +102,10 @@ class Context extends SystemEntityContext {
         //
         // One listener where there were two, because a Transform64 announces itself whole rather
         // than through a sub-object per component.
-        this.__on_transform_changed = event => {
-            if (event.klass === Transform64) {
-                this.__copy_transform();
-            }
-        };
+        this.__on_transform_changed = () => this.__copy_transform();
 
         this.getDataset().addEntityEventListener(
-            this.entity, EventType.ComponentChanged, this.__on_transform_changed
+            this.entity, TRANSFORM64_EVENT_CHANGE, this.__on_transform_changed
         );
 
         emitter.computeBoundingBox();
@@ -124,7 +120,7 @@ class Context extends SystemEntityContext {
 
         if (this.__on_transform_changed !== undefined) {
             this.getDataset().removeEntityEventListener(
-                this.entity, EventType.ComponentChanged, this.__on_transform_changed
+                this.entity, TRANSFORM64_EVENT_CHANGE, this.__on_transform_changed
             );
 
             this.__on_transform_changed = undefined;

package/src/engine/graphics3/LightSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LightSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/LightSystem.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;GAYG;AACH;IAgBI;;;OAGG;IACH,oDAUC;IADG,oDAAwC;IAG5C,2CAIC;IAED,4CAIC;IAED;;;;OAIG;IACH,gBAJW,KAAK,aACL,WAAW,UACX,MAAM,QA2EhB;IAED;;;;OAIG;IACH,kBAJW,KAAK,aACL,WAAW,UACX,MAAM,QAIhB;;CA4BJ;uBAlLsB,kBAAkB;4BACb,iCAAiC;sBACvC,gCAAgC"}
+{"version":3,"file":"LightSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/LightSystem.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;GAYG;AACH;IAgBI;;;OAGG;IACH,oDAUC;IADG,oDAAwC;IAG5C,2CAIC;IAED,4CAIC;IAED;;;;OAIG;IACH,gBAJW,KAAK,aACL,WAAW,UACX,MAAM,QAuEhB;IAED;;;;OAIG;IACH,kBAJW,KAAK,aACL,WAAW,UACX,MAAM,QAIhB;;CA4BJ;uBA9KsB,kBAAkB;4BACb,iCAAiC;sBACvC,gCAAgC"}

package/src/engine/graphics3/LightSystem.js

@@ -7,7 +7,7 @@ import { System } from "../ecs/System.js";
 import { Transform64 } from "../ecs/transform/Transform64.js";
 import { Light } from "../graphics/ecs/light/Light.js";
 import { LightType } from "../graphics/ecs/light/LightType.js";
-import { EventType } from "../ecs/EventType.js";
+import { TRANSFORM64_EVENT_CHANGE } from "../ecs/transform/TRANSFORM64_EVENT_CHANGE.js";
 
 /**
  * Mirrors light entities into Shade's scene.
@@ -115,14 +115,10 @@ export class LightSystem extends System {
         // One dataset listener replaces the three sub-object signals a Transform used to carry.
         // Coarser - it wakes on any change to the transform rather than on a named channel - and
         // that is the trade: the placement reads the whole transform anyway.
-        entry.on_transform_changed = event => {
-            if (event.klass === Transform64) {
-                place();
-            }
-        };
+        entry.on_transform_changed = place;
 
         this.entityManager.dataset.addEntityEventListener(
-            entity, EventType.ComponentChanged, entry.on_transform_changed
+            entity, TRANSFORM64_EVENT_CHANGE, entry.on_transform_changed
         );
 
         // A light's properties are gameplay-driven — a torch guttering, a spell charging, a
@@ -171,7 +167,7 @@ export class LightSystem extends System {
 
         if (entry.on_transform_changed !== undefined && entry.on_transform_changed !== null) {
             this.entityManager.dataset.removeEntityEventListener(
-                entity, EventType.ComponentChanged, entry.on_transform_changed
+                entity, TRANSFORM64_EVENT_CHANGE, entry.on_transform_changed
             );
 
             entry.on_transform_changed = null;

package/src/engine/graphics3/MeshSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MeshSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/MeshSystem.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAmFI;;;;OAIG;IACH,6CAHW,KAAK,eACI,MAAM,KAAG,oBAAoB,EAchD;IADG,qDAAyC;IAG7C;;OAEG;IACH,mBAEC;IAED;;;;;;;;;;;;OAYG;IACH,wBALW,MAAM,kBACG,MAAM,KAAG,IAAI,GACpB,OAAO,CAqBnB;IAoCD;;;;;;;;;;;OAWG;IACH,oBAJW,MAAM,GACJ,sBAAoB,IAAI,CAWpC;IAED;;;;;;;;;;;OAWG;IACH,qBAJW,MAAM,GACJ,gCAA8B,IAAI,CAW9C;IAED;;;;;;;;;;;OAWG;IACH,6BALW,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,UACvC,MAAM,GACJ,OAAO,CAuCnB;IAED,2CAIC;IAED,4CASC;IA6GD;;;;OAIG;IACH,YAJW,MAAM,aACN,WAAW,UACX,MAAM,QA+BhB;IAED;;;;OAIG;IACH,cAJW,MAAM,aACN,WAAW,UACX,MAAM,QAIhB;;CA0MJ;uBA5pBsB,kBAAkB;4BACb,iCAAiC;uBAGtC,6CAA6C;sBAV9C,qCAAqC"}
+{"version":3,"file":"MeshSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/MeshSystem.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAmFI;;;;OAIG;IACH,6CAHW,KAAK,eACI,MAAM,KAAG,oBAAoB,EAchD;IADG,qDAAyC;IAG7C;;OAEG;IACH,mBAEC;IAED;;;;;;;;;;;;OAYG;IACH,wBALW,MAAM,kBACG,MAAM,KAAG,IAAI,GACpB,OAAO,CAqBnB;IAoCD;;;;;;;;;;;OAWG;IACH,oBAJW,MAAM,GACJ,sBAAoB,IAAI,CAWpC;IAED;;;;;;;;;;;OAWG;IACH,qBAJW,MAAM,GACJ,gCAA8B,IAAI,CAW9C;IAED;;;;;;;;;;;OAWG;IACH,6BALW,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,UACvC,MAAM,GACJ,OAAO,CAuCnB;IAED,2CAIC;IAED,4CASC;IA6GD;;;;OAIG;IACH,YAJW,MAAM,aACN,WAAW,UACX,MAAM,QA2BhB;IAED;;;;OAIG;IACH,cAJW,MAAM,aACN,WAAW,UACX,MAAM,QAIhB;;CAoMJ;uBAlpBsB,kBAAkB;4BACb,iCAAiC;uBAGtC,6CAA6C;sBAV9C,qCAAqC"}

package/src/engine/graphics3/MeshSystem.js

@@ -13,7 +13,7 @@ import { ParentEntity } from "../ecs/parent/ParentEntity.js";
 import { ShadedGeometry } from "../graphics/ecs/mesh-v2/ShadedGeometry.js";
 import { SGMesh } from "../graphics/ecs/mesh-v2/aggregate/SGMesh.js";
 import { shade_bundle_to_entity_composition } from "./shade_node_to_entity_composition.js";
-import { EventType } from "../ecs/EventType.js";
+import { TRANSFORM64_EVENT_CHANGE } from "../ecs/transform/TRANSFORM64_EVENT_CHANGE.js";
 import { t64_announce_change } from "../ecs/transform/t64_announce_change.js";
 
 /**
@@ -443,18 +443,14 @@ export class MeshSystem extends System {
         // The entity is placed the moment its transform moves, not on a poll: a transform that has
         // not changed costs nothing, which is the same bargain the scene database makes downstream.
         // A Transform64 has no signals of its own, so the announcement comes from the dataset: the
-        // writer sends ComponentChanged and this wakes on it. Coarser than the three sub-object
-        // signals it replaces - a scale write wakes a placement that only reads the whole transform
-        // anyway - and #place already skips when nothing moved.
-        const on_changed = event => {
-            if (event.klass === Transform64) {
-                this.#place(entity, transform);
-            }
-        };
+        // writer sends TRANSFORM64_EVENT_CHANGE and this wakes on it. Coarser than the three
+        // sub-object signals it replaces - a scale write wakes a placement that only reads the whole
+        // transform anyway - and #place already skips when nothing moved.
+        const on_changed = () => this.#place(entity, transform);
 
         entry.on_changed = on_changed;
 
-        this.entityManager.dataset.addEntityEventListener(entity, EventType.ComponentChanged, on_changed);
+        this.entityManager.dataset.addEntityEventListener(entity, TRANSFORM64_EVENT_CHANGE, on_changed);
 
         if (model.url === null) {
             // nothing to show yet; {@link update} watches for the url arriving
@@ -581,18 +577,12 @@ export class MeshSystem extends System {
 
         // the composed entity follows the source transform, and a Transform64 has no signals of
         // its own, so the follow rides the dataset announcement like every other consumer
-        const on_source_changed = event => {
-            if (event.klass === Transform64) {
-                follow();
-            }
-        };
-
         const ecd = this.entityManager.dataset;
 
-        ecd.addEntityEventListener(entity, EventType.ComponentChanged, on_source_changed);
+        ecd.addEntityEventListener(entity, TRANSFORM64_EVENT_CHANGE, follow);
 
         composition.on.destroyed.addOne(
-            () => ecd.removeEntityEventListener(entity, EventType.ComponentChanged, on_source_changed)
+            () => ecd.removeEntityEventListener(entity, TRANSFORM64_EVENT_CHANGE, follow)
         );
 
         entry.composition = composition;
@@ -633,7 +623,7 @@ export class MeshSystem extends System {
         }
 
         if (entry.on_changed !== null) {
-            this.entityManager.dataset.removeEntityEventListener(entity, EventType.ComponentChanged, entry.on_changed);
+            this.entityManager.dataset.removeEntityEventListener(entity, TRANSFORM64_EVENT_CHANGE, entry.on_changed);
 
             entry.on_changed = null;
         }

package/src/engine/graphics3/ParticleEmitterSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleEmitterSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/ParticleEmitterSystem.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;GAaG;AACH;IAiDI;;;OAGG;IACH,4DAUC;IA9DD,8DAA8C;IAuC9C;;;;OAIG;IACH,kCAEC;IAkBD,2CAUC;IAED,4CAeC;IAED;;;;OAIG;IACH,cAJW,eAAe,aACf,WAAW,UACX,MAAM,QA0ChB;IAED;;;;;;;;;OASG;IACH,iBAFW,eAAe,QAqBzB;IAED;;;;OAIG;IACH,gBAJW,eAAe,aACf,WAAW,UACX,MAAM,QA0BhB;IAED,6BAaC;IAED;;OAEG;IACH,kCA+BC;;CACJ;AAED;;;GAGG;AACH;IAUI;;OAEG;IACH,oBAFW,qBAAqB,EAM/B;IAED,yBAEC;;CACJ;uBA/SsB,kBAAkB;4BACb,iCAAiC;gCAC7B,oEAAoE;gCANpE,mDAAmD"}
+{"version":3,"file":"ParticleEmitterSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/ParticleEmitterSystem.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;GAaG;AACH;IAiDI;;;OAGG;IACH,4DAUC;IA9DD,8DAA8C;IAuC9C;;;;OAIG;IACH,kCAEC;IAkBD,2CAUC;IAED,4CAeC;IAED;;;;OAIG;IACH,cAJW,eAAe,aACf,WAAW,UACX,MAAM,QAsChB;IAED;;;;;;;;;OASG;IACH,iBAFW,eAAe,QAqBzB;IAED;;;;OAIG;IACH,gBAJW,eAAe,aACf,WAAW,UACX,MAAM,QA0BhB;IAED,6BAaC;IAED;;OAEG;IACH,kCA+BC;;CACJ;AAED;;;GAGG;AACH;IAUI;;OAEG;IACH,oBAFW,qBAAqB,EAM/B;IAED,yBAEC;;CACJ;uBA3SsB,kBAAkB;4BACb,iCAAiC;gCAC7B,oEAAoE;gCANpE,mDAAmD"}

package/src/engine/graphics3/ParticleEmitterSystem.js

@@ -10,7 +10,7 @@ import { ParticleEmitter } from "../graphics/particles/particular/engine/emitter
 import { ParticleEmitterFlag } from "../graphics/particles/particular/engine/emitter/ParticleEmitterFlag.js";
 import { ParticularEngine } from "../graphics/particles/particular/engine/ParticularEngine.js";
 import { GPUParticularRenderer } from "./particles/GPUParticularRenderer.js";
-import { EventType } from "../ecs/EventType.js";
+import { TRANSFORM64_EVENT_CHANGE } from "../ecs/transform/TRANSFORM64_EVENT_CHANGE.js";
 
 /**
  * Draws the game's particle effects under Shade.
@@ -138,18 +138,14 @@ export class ParticleEmitterSystem extends System {
 
         // Vector3.process called the callback AND subscribed. The transform has no signals, so
         // the subscription half becomes one dataset listener that re-pushes the whole pose.
-        const on_transform_changed = event => {
-            if (event.klass !== Transform64) {
-                return;
-            }
-
+        const on_transform_changed = () => {
             position(transform.translation_x, transform.translation_y, transform.translation_z);
             rotation(transform.rotation_x, transform.rotation_y, transform.rotation_z, transform.rotation_w);
             scale(transform.scale_x, transform.scale_y, transform.scale_z);
         };
 
         this.entityManager.dataset.addEntityEventListener(
-            entity, EventType.ComponentChanged, on_transform_changed
+            entity, TRANSFORM64_EVENT_CHANGE, on_transform_changed
         );
 
         this.#entries.set(entity, { emitter, position, rotation, scale, on_transform_changed });
@@ -212,7 +208,7 @@ export class ParticleEmitterSystem extends System {
 
         if (entry.on_transform_changed !== undefined) {
             this.entityManager.dataset.removeEntityEventListener(
-                entity, EventType.ComponentChanged, entry.on_transform_changed
+                entity, TRANSFORM64_EVENT_CHANGE, entry.on_transform_changed
             );
         }
 

package/src/engine/graphics3/ShadedGeometrySystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShadedGeometrySystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/ShadedGeometrySystem.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAkBI;;;OAGG;IACH,oDAUC;IADG,6DAAiD;IAGrD,2CAEC;IAED,4CAIC;IAED;;;;OAIG;IACH,eAJW,cAAc,aACd,WAAW,UACX,MAAM,QAgDhB;IAED;;;;OAIG;IACH,iBAJW,cAAc,aACd,WAAW,UACX,MAAM,QAMhB;;CA4CJ;uBA/KsB,kBAAkB;4BACb,iCAAiC;+BAC9B,2CAA2C"}
+{"version":3,"file":"ShadedGeometrySystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/ShadedGeometrySystem.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAkBI;;;OAGG;IACH,oDAUC;IADG,6DAAiD;IAGrD,2CAEC;IAED,4CAIC;IAED;;;;OAIG;IACH,eAJW,cAAc,aACd,WAAW,UACX,MAAM,QA0ChB;IAED;;;;OAIG;IACH,iBAJW,cAAc,aACd,WAAW,UACX,MAAM,QAMhB;;CA4CJ;uBAzKsB,kBAAkB;4BACb,iCAAiC;+BAC9B,2CAA2C"}

package/src/engine/graphics3/ShadedGeometrySystem.js

@@ -5,7 +5,7 @@ import Name from "../ecs/name/Name.js";
 import { System } from "../ecs/System.js";
 import { Transform64 } from "../ecs/transform/Transform64.js";
 import { ShadedGeometry } from "../graphics/ecs/mesh-v2/ShadedGeometry.js";
-import { EventType } from "../ecs/EventType.js";
+import { TRANSFORM64_EVENT_CHANGE } from "../ecs/transform/TRANSFORM64_EVENT_CHANGE.js";
 
 /**
  * Puts one primitive into Shade's scene, and keeps it where the entity says.
@@ -103,17 +103,11 @@ export class ShadedGeometrySystem extends System {
         // One dataset listener replaces the three sub-object signals a Transform used to carry.
         // Coarser - it wakes on any change to the transform rather than on a named channel - and
         // that is the trade: the placement reads the whole transform anyway.
-        const on_transform_changed = event => {
-            if (event.klass === Transform64) {
-                place();
-            }
-        };
-
         this.entityManager.dataset.addEntityEventListener(
-            entity, EventType.ComponentChanged, on_transform_changed
+            entity, TRANSFORM64_EVENT_CHANGE, place
         );
 
-        this.#entries.set(entity, { node, bindings, on_transform_changed });
+        this.#entries.set(entity, { node, bindings, on_transform_changed: place });
 
         // the component carries its own row, so anything holding the component can ask where the
         // primitive ended up without going through this system
@@ -169,7 +163,7 @@ export class ShadedGeometrySystem extends System {
 
         if (entry.on_transform_changed !== undefined) {
             this.entityManager.dataset.removeEntityEventListener(
-                entity, EventType.ComponentChanged, entry.on_transform_changed
+                entity, TRANSFORM64_EVENT_CHANGE, entry.on_transform_changed
             );
         }
 

package/src/engine/grid/transform2grid/Transform2GridPositionSystem.d.ts

@@ -52,7 +52,7 @@ declare class Synchronizer {
     ecd: EntityComponentDataset;
     write(): void;
     link(): void;
-    on_transform_changed: (event: any) => void;
+    on_transform_changed: () => void;
     unlink(): void;
 }
 export {};

package/src/engine/grid/transform2grid/Transform2GridPositionSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Transform2GridPositionSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/grid/transform2grid/Transform2GridPositionSystem.js"],"names":[],"mappings":"AAmGA;;IACI,2FAAmE;IACnE,oEAEE;IAEF;;;OAGG;IACH,MAFU,YAAY,EAAE,CAEd;IAEV;;;;;;OAMG;IACH,gBALW,sBAAsB,aACtB,WAAW,MACX,YAAY,UACZ,MAAM,QAehB;IAED;;;;;;OAMG;IACH,kBALW,sBAAsB,aACtB,WAAW,MACX,YAAY,UACZ,MAAM,QAYhB;CACJ;uBAvJsB,qBAAqB;4BAGhB,oCAAoC;yBADvC,6BAA6B;uCADf,6BAA6B;4CAMxB,oDAAoD;AAMhG;IACI;;;OAGG;IACH,WAFU,WAAW,CAEJ;IAEjB;;;OAGG;IACH,UAFU,YAAY,CAEN;IAEhB;;;OAGG;IACH,WAFU,sBAAsB,CAEf;IAEjB;;;OAGG;IACH,4BAAW;IAEX,cAgCC;IAGD,aAWC;IATG,2CAIC;IAOL,eAUC;CACJ"}
+{"version":3,"file":"Transform2GridPositionSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/grid/transform2grid/Transform2GridPositionSystem.js"],"names":[],"mappings":"AA+FA;;IACI,2FAAmE;IACnE,oEAEE;IAEF;;;OAGG;IACH,MAFU,YAAY,EAAE,CAEd;IAEV;;;;;;OAMG;IACH,gBALW,sBAAsB,aACtB,WAAW,MACX,YAAY,UACZ,MAAM,QAehB;IAED;;;;;;OAMG;IACH,kBALW,sBAAsB,aACtB,WAAW,MACX,YAAY,UACZ,MAAM,QAYhB;CACJ;uBAnJsB,qBAAqB;4BAGhB,oCAAoC;yBADvC,6BAA6B;uCADf,6BAA6B;4CAMxB,oDAAoD;AAMhG;IACI;;;OAGG;IACH,WAFU,WAAW,CAEJ;IAEjB;;;OAGG;IACH,UAFU,YAAY,CAEN;IAEhB;;;OAGG;IACH,WAFU,sBAAsB,CAEf;IAEjB;;;OAGG;IACH,4BAAW;IAEX,cAgCC;IAGD,aAOC;IALG,iCAA8C;IAOlD,eAUC;CACJ"}