@woosh/meep-engine 3.15.0 → 3.17.0

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

@@ -0,0 +1,59 @@
+import { assert } from "../../../core/assert.js";
+import {
+    TRANSFORM64_ROTATION_OFFSET,
+    TRANSFORM64_SCALE_OFFSET,
+    TRANSFORM64_TRANSLATION_OFFSET
+} from "./Transform64.js";
+
+/**
+ * Whether two {@link Transform64}s hold the same translation, rotation and scale.
+ *
+ * The counterpart of {@link t64_equals_transform} for two transforms of the same type, and it exists
+ * for the same reason: a system that places on a poll rather than on a signal has to be able to tell
+ * that there is nothing to place. The cost of not asking is not the copy - it is that
+ * `Node3D.updateMatrices` bumps a version whether or not anything moved, and downstream a bumped
+ * version means a scene-database row uploaded and, for a mesh, a whole-tree rebuild of the top-level
+ * acceleration structure.
+ *
+ * **Not {@link Transform64#equals}.** That one compares all 23 elements, the matrix included, and so
+ * reports two transforms as different when only one of them has a stale matrix - which is a state
+ * this type invites, since a rotation or scale write does not refresh the matrix until
+ * {@link Transform64#updateMatrix} is called. Using it as a placement guard would answer "have the
+ * buffers diverged" when the question is "has anything moved", and would let the rebuild it is meant
+ * to prevent back in.
+ *
+ * Exact equality rather than a tolerance, for the same reason {@link t64_equals_transform} uses it:
+ * the question is whether a write would change anything, and a write of a value that differs by any
+ * amount does.
+ *
+ * @param {Transform64} a
+ * @param {Transform64} b
+ * @returns {boolean}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function t64_equals_components(a, b) {
+    assert.equal(a.isTransform64, true, 'a.isTransform64 !== true');
+    assert.equal(b.isTransform64, true, 'b.isTransform64 !== true');
+
+    for (let i = 0; i < 3; i++) {
+        if (a[TRANSFORM64_TRANSLATION_OFFSET + i] !== b[TRANSFORM64_TRANSLATION_OFFSET + i]) {
+            return false;
+        }
+    }
+
+    for (let i = 0; i < 4; i++) {
+        if (a[TRANSFORM64_ROTATION_OFFSET + i] !== b[TRANSFORM64_ROTATION_OFFSET + i]) {
+            return false;
+        }
+    }
+
+    for (let i = 0; i < 3; i++) {
+        if (a[TRANSFORM64_SCALE_OFFSET + i] !== b[TRANSFORM64_SCALE_OFFSET + i]) {
+            return false;
+        }
+    }
+
+    return true;
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Read a transform's rotation out into a quaternion.
+ *
+ * The companion of {@link t64_read_translation}, and there for the same reason: quaternion math -
+ * inverses, slerps, angles between two rotations - lives on {@link Quaternion}, and a
+ * {@link Transform64} is an array holding none of it.
+ *
+ * @param {Quaternion} out
+ * @param {Transform64} transform
+ * @returns {Quaternion} out
+ */
+export function t64_read_rotation(out: Quaternion, transform: Transform64): Quaternion;
+//# sourceMappingURL=t64_read_rotation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"t64_read_rotation.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/transform/t64_read_rotation.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,uFAIC"}

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

@@ -0,0 +1,16 @@
+/**
+ * Read a transform's rotation out into a quaternion.
+ *
+ * The companion of {@link t64_read_translation}, and there for the same reason: quaternion math -
+ * inverses, slerps, angles between two rotations - lives on {@link Quaternion}, and a
+ * {@link Transform64} is an array holding none of it.
+ *
+ * @param {Quaternion} out
+ * @param {Transform64} transform
+ * @returns {Quaternion} out
+ */
+export function t64_read_rotation(out, transform) {
+    out.set(transform.rotation_x, transform.rotation_y, transform.rotation_z, transform.rotation_w);
+
+    return out;
+}

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

@@ -0,0 +1,14 @@
+/**
+ * Read a transform's translation out into a vector.
+ *
+ * A {@link Transform64} keeps its components as numbers inside its own array, which is the whole
+ * point of it; code that needs vector math on one of them - a distance, a cross product, a
+ * direction to rotate - reads it out into a scratch here instead of taking a view, which would
+ * allocate on every call.
+ *
+ * @param {Vector3} out
+ * @param {Transform64} transform
+ * @returns {Vector3} out
+ */
+export function t64_read_translation(out: Vector3, transform: Transform64): Vector3;
+//# sourceMappingURL=t64_read_translation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"t64_read_translation.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/transform/t64_read_translation.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,oFAIC"}

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

@@ -0,0 +1,17 @@
+/**
+ * Read a transform's translation out into a vector.
+ *
+ * A {@link Transform64} keeps its components as numbers inside its own array, which is the whole
+ * point of it; code that needs vector math on one of them - a distance, a cross product, a
+ * direction to rotate - reads it out into a scratch here instead of taking a view, which would
+ * allocate on every call.
+ *
+ * @param {Vector3} out
+ * @param {Transform64} transform
+ * @returns {Vector3} out
+ */
+export function t64_read_translation(out, transform) {
+    out.set(transform.translation_x, transform.translation_y, transform.translation_z);
+
+    return out;
+}

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/TransformAttachment.d.ts

@@ -2,7 +2,7 @@ export namespace TransformAttachmentFlags {
     let Immediate: number;
 }
 /**
- * Controls {@link Transform} the entity it is attached to, enables transformation hierarchy.
+ * Controls {@link Transform64} the entity it is attached to, enables transformation hierarchy.
  *
  * This is the *spatial* relation only. It says where the entity is, never how long it lives — see
  * {@link ParentEntity} for that, and note that the two are free to name different entities, which is
@@ -27,9 +27,9 @@ export class TransformAttachment {
     /**
      * Transform relative to the attachment target.
      * Think of this as "local transform".
-     * @type {Transform}
+     * @type {Transform64}
      */
-    transform: Transform;
+    transform: Transform64;
     /**
      * Which entity to attach to, this is what our transform is relative to.
      * Must not be mutated (changed) while the component is attached to a dataset.
@@ -50,7 +50,7 @@ export class TransformAttachment {
     toString(): string;
     toJSON(): {
         transform: {
-            position: {
+            translation: {
                 x: number;
                 y: number;
                 z: number;
@@ -138,5 +138,5 @@ export class TransformAttachment {
 export namespace TransformAttachment {
     let typeName: string;
 }
-import { Transform } from "../transform/Transform.js";
+import { Transform64 } from "../transform/Transform64.js";
 //# sourceMappingURL=TransformAttachment.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"TransformAttachment.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/transform-attachment/TransformAttachment.js"],"names":[],"mappings":";;;AAaA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAEI;;;;OAIG;IACH,WAFU,SAAS,CAES;IAE5B;;;;;;;;;;OAUG;IACH,QAFU,MAAM,CAEJ;IAEZ;;;OAGG;IACH,OAFU,MAAM,CAEM;IAEtB,mBAEC;IAED;;;;;;;;;;;;;;;;;;;;;MAMC;IAED;;;;aAQC;IAMD;;;OAGG;IACH,4BAEC;IAVD,yBAEC;IAUD;;;;OAIG;IACH,cAHW,MAAM;QA/FjB;;;WAGG;;KA4FuC,GAC7B,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM;QAxGjB;;;WAGG;;KAqGuC,GAC7B,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM;QAjHjB;;;WAGG;;KA8GuC,SAC/B,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM;QA9HjB;;;WAGG;;KA2HuC,GAC7B,OAAO,CAInB;IAUL;;;OAGG;IACH,gCAFU,OAAO,CAEkC;CAZlD;;kBAIS,MAAM;;0BA5IU,2BAA2B"}
+{"version":3,"file":"TransformAttachment.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/transform-attachment/TransformAttachment.js"],"names":[],"mappings":";;;AAaA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAEI;;;;OAIG;IACH,WAFU,WAAW,CAES;IAE9B;;;;;;;;;;OAUG;IACH,QAFU,MAAM,CAEJ;IAEZ;;;OAGG;IACH,OAFU,MAAM,CAEM;IAEtB,mBAEC;IAED;;;;;;;;;;;;;;;;;;;;;MAMC;IAED;;;;aAQC;IAMD;;;OAGG;IACH,4BAEC;IAVD,yBAEC;IAUD;;;;OAIG;IACH,cAHW,MAAM;QA/FjB;;;WAGG;;KA4FuC,GAC7B,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM;QAxGjB;;;WAGG;;KAqGuC,GAC7B,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM;QAjHjB;;;WAGG;;KA8GuC,SAC/B,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM;QA9HjB;;;WAGG;;KA2HuC,GAC7B,OAAO,CAInB;IAUL;;;OAGG;IACH,gCAFU,OAAO,CAEkC;CAZlD;;kBAIS,MAAM;;4BA5IY,6BAA6B"}

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

@@ -1,5 +1,5 @@
 import { assert } from "../../../core/assert.js";
-import { Transform } from "../transform/Transform.js";
+import { Transform64 } from "../transform/Transform64.js";
 
 export const TransformAttachmentFlags = {
     /**
@@ -12,7 +12,7 @@ export const TransformAttachmentFlags = {
 const DEFAULT_FLAGS = TransformAttachmentFlags.Immediate;
 
 /**
- * Controls {@link Transform} the entity it is attached to, enables transformation hierarchy.
+ * Controls {@link Transform64} the entity it is attached to, enables transformation hierarchy.
  *
  * This is the *spatial* relation only. It says where the entity is, never how long it lives — see
  * {@link ParentEntity} for that, and note that the two are free to name different entities, which is
@@ -38,9 +38,9 @@ export class TransformAttachment {
     /**
      * Transform relative to the attachment target.
      * Think of this as "local transform".
-     * @type {Transform}
+     * @type {Transform64}
      */
-    transform = new Transform();
+    transform = new Transform64();
 
     /**
      * Which entity to attach to, this is what our transform is relative to.

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

@@ -1,6 +1,6 @@
 /**
  * Owns the *spatial* hierarchy: an entity carrying {@link TransformAttachment} has its world
- * {@link Transform} composed as parent world × local.
+ * {@link Transform64} composed as parent world × local.
  *
  * The component stores only the child-to-parent direction, so the system keeps the other one, in the
  * same shape {@link ParentEntitySystem} keeps for the lifetime hierarchy.
@@ -12,7 +12,7 @@
  * - **Children come back ascending by entity id**, not in link order. See {@link EntityChildIndex}.
  * - **Callers get a snapshot**, because detaching or destroying what a child list names moves the
  *   index under a caller that is iterating it.
- * - **A queued child is in the index.** A child whose parent has no {@link Transform} yet is parked
+ * - **A queued child is in the index.** A child whose parent has no {@link Transform64} yet is parked
  *   and retried, and it is indexed from the moment it links rather than from the moment it binds:
  *   the question the index answers is "which children point at me", and that is true of a child that
  *   is still waiting. The consequence is that a non-zero child count does not imply those children
@@ -49,8 +49,8 @@ export class TransformAttachmentSystem extends System<any> {
     private __queue;
     __queue_size: number;
     __queue_cursor: number;
-    dependencies: (typeof Transform | typeof TransformAttachment)[];
-    components_used: (ResourceAccessSpecification<typeof Transform> | ResourceAccessSpecification<typeof TransformAttachment>)[];
+    dependencies: (typeof Transform64 | typeof TransformAttachment)[];
+    components_used: (ResourceAccessSpecification<typeof Transform64> | ResourceAccessSpecification<typeof TransformAttachment>)[];
     /**
      *
      * @param {UpdateContext} ctx
@@ -72,7 +72,7 @@ export class TransformAttachmentSystem extends System<any> {
     private __dequeue_entity;
     /**
      * Direct children of `entity`, ascending by entity id. Includes children that are still queued
-     * waiting for this entity to gain a {@link Transform}.
+     * waiting for this entity to gain a {@link Transform64}.
      *
      * @param {number[]} result written from `result_offset` onwards
      * @param {number} result_offset
@@ -91,21 +91,21 @@ export class TransformAttachmentSystem extends System<any> {
     /**
      *
      * @param {TransformAttachment} attachment
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {number} entity
      */
-    link(attachment: TransformAttachment, transform: Transform, entity: number): void;
+    link(attachment: TransformAttachment, transform: Transform64, entity: number): void;
     /**
      *
      * @param {TransformAttachment} attachment
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {number} entity
      */
-    unlink(attachment: TransformAttachment, transform: Transform, entity: number): void;
+    unlink(attachment: TransformAttachment, transform: Transform64, entity: number): void;
     update(timeDelta: any): void;
 }
 import { System } from "../System.js";
-import { Transform } from "../transform/Transform.js";
+import { Transform64 } from "../transform/Transform64.js";
 import { TransformAttachment } from "./TransformAttachment.js";
 import { ResourceAccessSpecification } from "../../../core/model/ResourceAccessSpecification.js";
 //# sourceMappingURL=TransformAttachmentSystem.d.ts.map

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":"AA8IA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;;IAEI;;;;OAIG;IACH,mBAAgB;IAEhB;;;;;OAKG;IACH,mBAAoC;IAEpC;;;;OAIG;IACH,gBAAa;IACb,qBAAiB;IACjB,uBAAmB;IAEnB,gEAAgD;IAChD,6HAGE;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,SAAS,UACT,MAAM,QAsBhB;IAED;;;;;OAKG;IACH,mBAJW,mBAAmB,aACnB,SAAS,UACT,MAAM,QAkBhB;IAED,6BAoBC;CACJ;uBAnVsB,cAAc;0BACX,2BAA2B;oCACS,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 { Transform } from "../transform/Transform.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";
 
 /**
@@ -22,7 +24,7 @@ class UpdateContext {
 
     /**
      *
-     * @type {Transform|null}
+     * @type {Transform64|null}
      */
     transform = null;
 
@@ -34,7 +36,7 @@ class UpdateContext {
 
     /**
      *
-     * @type {Transform|null}
+     * @type {Transform64|null}
      */
     parent_transform = null;
 
@@ -65,6 +67,16 @@ class UpdateContext {
             this.parent_transform,
             this.attachment.transform
         );
+
+        /*
+         This is what carries a move down a chain. The world transform just written is what this
+         entity's OWN children compose against, and they are listening for exactly this event; a
+         Transform64 says nothing when it is written, so the composition says it instead.
+
+         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, TRANSFORM64_EVENT_CHANGE);
     }
 
     /**
@@ -73,7 +85,7 @@ class UpdateContext {
      */
     bind_parent() {
 
-        const parent_transform = this.ecd.getComponent(this.attachment.parent, Transform);
+        const parent_transform = this.ecd.getComponent(this.attachment.parent, Transform64);
 
         if (parent_transform === undefined) {
             return false;
@@ -87,7 +99,7 @@ class UpdateContext {
     /**
      * The spatial parent is gone, so there is nothing left to compose against. Dropping the component
      * is what turns that into an observable state change: the entity keeps the world transform it had
-     * and becomes a root, instead of silently freezing while holding a dead parent's {@link Transform}
+     * and becomes a root, instead of silently freezing while holding a dead parent's {@link Transform64}
      * alive through this context.
      *
      * @returns {void}
@@ -101,14 +113,33 @@ class UpdateContext {
         this.ecd.removeComponentFromEntity(this.entity, TransformAttachment);
     }
 
+    /** @type {function(*)|null} */
+    #on_parent_changed = null;
+
+    /** @type {function(*)|null} */
+    #on_self_changed = null;
+
     link() {
-        const t_parent = this.parent_transform;
+        // Neither transform carries signals any more, so both announcements come through the
+        // 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();
 
-        t_parent.subscribe(this.update, this);
+        this.#on_self_changed = () => this.update();
 
-        const t_attachment = this.attachment.transform;
+        this.ecd.addEntityEventListener(
+            this.attachment.parent,
+            TRANSFORM64_EVENT_CHANGE,
+            this.#on_parent_changed
+        );
 
-        t_attachment.subscribe(this.update, this);
+        this.ecd.addEntityEventListener(
+            this.entity,
+            TRANSFORM_ATTACHMENT_EVENT_CHANGE,
+            this.#on_self_changed
+        );
 
         this.ecd.addEntityEventListener(
             this.attachment.parent,
@@ -123,13 +154,25 @@ class UpdateContext {
     unlink() {
         this.#linked = false;
 
-        const transform = this.parent_transform;
+        if (this.#on_parent_changed !== null) {
+            this.ecd.removeEntityEventListener(
+                this.attachment.parent,
+                TRANSFORM64_EVENT_CHANGE,
+                this.#on_parent_changed
+            );
 
-        transform.unsubscribe(this.update, this);
+            this.#on_parent_changed = null;
+        }
 
-        const t_attachment = this.attachment.transform;
+        if (this.#on_self_changed !== null) {
+            this.ecd.removeEntityEventListener(
+                this.entity,
+                TRANSFORM_ATTACHMENT_EVENT_CHANGE,
+                this.#on_self_changed
+            );
 
-        t_attachment.unsubscribe(this.update, this);
+            this.#on_self_changed = null;
+        }
 
         this.ecd.removeEntityEventListener(
             this.attachment.parent,
@@ -142,7 +185,7 @@ class UpdateContext {
 
 /**
  * Owns the *spatial* hierarchy: an entity carrying {@link TransformAttachment} has its world
- * {@link Transform} composed as parent world × local.
+ * {@link Transform64} composed as parent world × local.
  *
  * The component stores only the child-to-parent direction, so the system keeps the other one, in the
  * same shape {@link ParentEntitySystem} keeps for the lifetime hierarchy.
@@ -154,7 +197,7 @@ class UpdateContext {
  * - **Children come back ascending by entity id**, not in link order. See {@link EntityChildIndex}.
  * - **Callers get a snapshot**, because detaching or destroying what a child list names moves the
  *   index under a caller that is iterating it.
- * - **A queued child is in the index.** A child whose parent has no {@link Transform} yet is parked
+ * - **A queued child is in the index.** A child whose parent has no {@link Transform64} yet is parked
  *   and retried, and it is indexed from the moment it links rather than from the moment it binds:
  *   the question the index answers is "which children point at me", and that is true of a child that
  *   is still waiting. The consequence is that a non-zero child count does not imply those children
@@ -194,10 +237,10 @@ export class TransformAttachmentSystem extends System {
     __queue_size = 0;
     __queue_cursor = 0;
 
-    dependencies = [TransformAttachment, Transform];
+    dependencies = [TransformAttachment, Transform64];
     components_used = [
         ResourceAccessSpecification.from(TransformAttachment, ResourceAccessKind.Read),
-        ResourceAccessSpecification.from(Transform, ResourceAccessKind.Read | ResourceAccessKind.Write),
+        ResourceAccessSpecification.from(Transform64, ResourceAccessKind.Read | ResourceAccessKind.Write),
     ];
 
     /**
@@ -247,7 +290,7 @@ export class TransformAttachmentSystem extends System {
 
     /**
      * Direct children of `entity`, ascending by entity id. Includes children that are still queued
-     * waiting for this entity to gain a {@link Transform}.
+     * waiting for this entity to gain a {@link Transform64}.
      *
      * @param {number[]} result written from `result_offset` onwards
      * @param {number} result_offset
@@ -272,7 +315,7 @@ export class TransformAttachmentSystem extends System {
     /**
      *
      * @param {TransformAttachment} attachment
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {number} entity
      */
     link(attachment, transform, entity) {
@@ -300,7 +343,7 @@ export class TransformAttachmentSystem extends System {
     /**
      *
      * @param {TransformAttachment} attachment
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {number} entity
      */
     unlink(attachment, transform, entity) {

package/src/engine/graphics/debug/createDebugLabel.js

@@ -1,5 +1,5 @@
 import Vector3 from "../../../core/geom/Vector3.js";
-import { Transform } from "../../ecs/transform/Transform.js";
+import { Transform64 } from "../../ecs/transform/Transform64.js";
 import Entity from "../../ecs/Entity.js";
 import HeadsUpDisplay from "../../ecs/gui/hud/HeadsUpDisplay.js";
 import ViewportPosition from "../../ecs/gui/position/ViewportPosition.js";
@@ -22,9 +22,9 @@ export function createDebugLabel(text, position = Vector3.zero) {
         top: 0
     })
 
-    const t = new Transform();
+    const t = new Transform64();
 
-    t.position.copy(position);
+    t.setTranslation(position.x, position.y, position.z);
 
     const eb = new Entity()
         .add(new HeadsUpDisplay())

package/src/engine/graphics/ecs/camera/pp/PerfectPanner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PerfectPanner.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/ecs/camera/pp/PerfectPanner.js"],"names":[],"mappings":"AAWA;IA4CI;;;OAGG;IACH,wBAEC;IAVD,qBAEC;IAUD;;OAEG;IACH,2BAEC;IAwBD;;;OAGG;IACH,wBAFW,OAAO,QA4BjB;IAED,kCAuCC;IAED,YAEC;;CAEJ;oBAzKmB,qCAAqC;oBAKrC,qCAAqC"}
+{"version":3,"file":"PerfectPanner.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/ecs/camera/pp/PerfectPanner.js"],"names":[],"mappings":"AAYA;IA4CI;;;OAGG;IACH,wBAEC;IAVD,qBAEC;IAUD;;OAEG;IACH,2BAEC;IAwBD;;;OAGG;IACH,wBAFW,OAAO,QA4BjB;IAED,kCAuCC;IAED,YAEC;;CAEJ;oBA1KmB,qCAAqC;oBAKrC,qCAAqC"}

package/src/engine/graphics/ecs/camera/pp/PerfectPanner.js

@@ -4,7 +4,8 @@ import { SurfacePoint3 } from "../../../../../core/geom/3d/SurfacePoint3.js";
 import { make_ray_from_viewport_position } from "../../../make_ray_from_viewport_position.js";
 import { camera_find_active } from "../camera_find_active.js";
 import Vector2 from "../../../../../core/geom/Vector2.js";
-import { Transform } from "../../../../ecs/transform/Transform.js";
+import { Transform64 } from "../../../../ecs/transform/Transform64.js";
+import { t64_read_translation } from "../../../../ecs/transform/t64_read_translation.js";
 
 const NEAR_PLANE_INDEX = 5;
 const FAR_PLANE_INDEX = 4;
@@ -38,7 +39,7 @@ export class PerfectPanner {
     #camera = null;
     /**
      *
-     * @type {Transform|null}
+     * @type {Transform64|null}
      */
     #camera_transform = null;
 
@@ -138,7 +139,7 @@ export class PerfectPanner {
         // bind camera
         const camera = camera_find_active(ecd);
         this.#camera = camera.component;
-        this.#camera_transform = ecd.getComponent(camera.entity, Transform);
+        this.#camera_transform = ecd.getComponent(camera.entity, Transform64);
 
 
         this.#projection_viewport_onto_plane(this.#grab_near_projection, screen_position.x, screen_position.y, NEAR_PLANE_INDEX);
@@ -158,7 +159,7 @@ export class PerfectPanner {
             this.#grab_world_reference.copy(hit.position);
         }
 
-        this.#grab_eye_position.copy(this.#camera_transform.position);
+        t64_read_translation(this.#grab_eye_position, this.#camera_transform);
 
         this.#translation.set(0, 0, 0);
     }

package/src/engine/graphics/ecs/camera/topdown/TopDownCameraController.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TopDownCameraController.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/ecs/camera/topdown/TopDownCameraController.js"],"names":[],"mappings":"AAwBA;;;;;;GAMG;AACH,iDALW,MAAM,kBACN,MAAM,SACN,uBAAuB,UACvB,uBAAuB,QAiBjC;AAED;;;;;;;GAOG;AACH,+CAHW,UAAU,cACV,uBAAuB,QAIjC;;AAkED;IA2JI,iDAMC;IAxJD,0BAKC;IAbD,gBAAuB;IACvB,cAAU;IACV,YAAQ;IACR,aAAS;IACT,iBAAa;IACb,oBAAgB;IAChB,oBAAkB;IASlB;;;;;;;;;OASG;IACH,yBAJW,OAAO,UACP,OAAO,OACP,OAAO,QA4BjB;IAED;;;;OAIG;IACH,cAHW,uBAAuB,GACrB,OAAO,CAWnB;IAED;;;OAGG;IACH,YAFW,uBAAuB,QAYjC;IAED;;;OAGG;IACH,SAFa,uBAAuB,CAQnC;IAED;;;;;OAKG;IACH,QAJW,uBAAuB,KACvB,uBAAuB,KACvB,MAAM,QAahB;IAED;;;;;;;;;;;;MAYC;IAED;;;;;;;;aAsBC;CASJ;;;;;;uBAxRsB,wCAAwC;oBAC3C,qCAAqC;AAqEzD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,iDAPW,uBAAuB,sBACvB,MAAM,OAEN,MAAM,eACN,OAAO,QA2BjB"}
+{"version":3,"file":"TopDownCameraController.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/ecs/camera/topdown/TopDownCameraController.js"],"names":[],"mappings":"AAyBA;;;;;;GAMG;AACH,iDALW,MAAM,kBACN,MAAM,SACN,uBAAuB,UACvB,uBAAuB,QAiBjC;AAED;;;;;;;GAOG;AACH,+CAHW,UAAU,cACV,uBAAuB,QAIjC;;AAkED;IA+JI,iDAMC;IA5JD,0BAKC;IAbD,gBAAuB;IACvB,cAAU;IACV,YAAQ;IACR,aAAS;IACT,iBAAa;IACb,oBAAgB;IAChB,oBAAkB;IASlB;;;;;;;;;OASG;IACH,yBAJW,OAAO,UACP,OAAO,OACP,OAAO,QAgCjB;IAED;;;;OAIG;IACH,cAHW,uBAAuB,GACrB,OAAO,CAWnB;IAED;;;OAGG;IACH,YAFW,uBAAuB,QAYjC;IAED;;;OAGG;IACH,SAFa,uBAAuB,CAQnC;IAED;;;;;OAKG;IACH,QAJW,uBAAuB,KACvB,uBAAuB,KACvB,MAAM,QAahB;IAED;;;;;;;;;;;;MAYC;IAED;;;;;;;;aAsBC;CASJ;;;;;;uBA7RsB,wCAAwC;oBAC3C,qCAAqC;AAsEzD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,iDAPW,uBAAuB,sBACvB,MAAM,OAEN,MAAM,eACN,OAAO,QA2BjB"}

package/src/engine/graphics/ecs/camera/topdown/TopDownCameraController.js

@@ -9,6 +9,7 @@ import Vector3 from '../../../../../core/geom/Vector3.js';
 import { lerp } from "../../../../../core/math/lerp.js";
 import { max2 } from "../../../../../core/math/max2.js";
 import { sign_not_zero } from "../../../../../core/math/sign_not_zero.js";
+import { v3_distance } from "../../../../../core/geom/vec3/v3_distance.js";
 
 const m4 = [];
 const angles = [];
@@ -150,8 +151,12 @@ class TopDownCameraController {
      */
     setFromEyeAndTarget(eye, target, up = Vector3.up) {
 
-        v3_forward.copy(target);
-        v3_forward.sub(eye);
+        // index reads accept a Vector3 or a transform's translation view alike
+        v3_forward.set(
+            target[0] - eye[0],
+            target[1] - eye[1],
+            target[2] - eye[2]
+        );
 
         q_look.lookRotation(v3_forward, up);
 
@@ -168,7 +173,7 @@ class TopDownCameraController {
         this.yaw = angles[1];
         this.roll = angles[0];
 
-        this.distance = eye.distanceTo(target);
+        this.distance = v3_distance(eye[0], eye[1], eye[2], target[0], target[1], target[2]);
 
         // ensure we can maintain this distance
         this.distanceMax = max2(this.distance, this.distanceMax);