@flighthq/node 0.3.0 → 0.3.1-next.1041.35b950c

package/src/hierarchy.test.ts

@@ -24,6 +24,7 @@ import {
   removeNodeChildAt,
   removeNodeChildren,
   reparentNode,
+  setReparentNodeGuard,
   replaceNodeChild,
   setNodeChildIndex,
   swapNodeChildren,
@@ -67,6 +68,22 @@ describe('addNodeChild', () => {
     expect(() => addNodeChild(container, container)).toThrow(TypeError);
   });
 
+  it('throws rather than creating a cycle', () => {
+    addNodeChild(container, childA);
+    addNodeChild(childA, childB);
+
+    expect(() => addNodeChild(childB, container)).toThrow(TypeError);
+    expect(getNodeParent(container)).toBeNull();
+    expect(getNodeRoot(childB)).toBe(container);
+  });
+
+  it('rejects a child disallowed by the parent runtime', () => {
+    getEntityRuntime(container).canAddChild = () => false;
+
+    expect(() => addNodeChild(container, childA)).toThrow('The specified parent object cannot add this child');
+    expect(getNodeParent(childA)).toBeNull();
+  });
+
   it('removes child from previous parent before adding', () => {
     const other = createNode(NodeKind);
 
@@ -222,6 +239,15 @@ describe('addNodeChildAt', () => {
     expect(getNodeParentReferenceRevision(childA)).toBe(parentReferenceId);
   });
 
+  it('repairs a stale parent reference whose child-list entry is absent', () => {
+    getEntityRuntime(childA).parent = container;
+
+    addNodeChildAt(container, childA, 0);
+
+    expect(getNodeChildAt(container, 0)).toBe(childA);
+    expect(getNodeParent(childA)).toBe(container);
+  });
+
   it('calls onParentChanged on the child', () => {
     let called = false;
     connectSignal(enableNodeSignals(childA).onParentChanged, () => {
@@ -531,6 +557,16 @@ describe('removeNodeChild', () => {
     expect(getNodeParent(childA)).toBeNull();
   });
 
+  it('clears a stale parent reference when the child-list entry is absent', () => {
+    getEntityRuntime(container).children = [];
+    getEntityRuntime(childA).parent = container;
+
+    removeNodeChild(container, childA);
+
+    expect(getNodeParent(childA)).toBeNull();
+    expect(getNodeChildCount(container)).toBe(0);
+  });
+
   it('calls onParentChanged on the child', () => {
     addNodeChild(container, childA);
     let called = false;
@@ -605,6 +641,11 @@ describe('removeNodeChildAt', () => {
 });
 
 describe('removeNodeChildren', () => {
+  it('does nothing when the node has never had children', () => {
+    expect(() => removeNodeChildren(container)).not.toThrow();
+    expect(getNodeChildCount(container)).toBe(0);
+  });
+
   it('removeChildren removes all children by default', () => {
     addNodeChild(container, childA);
     addNodeChild(container, childB);
@@ -681,6 +722,50 @@ describe('reparentNode', () => {
     return node;
   }
 
+  // The ruled contract: under a singular new parent, NO local transform exists that would preserve the
+  // child's world transform, so the function declines whole rather than inventing one. These assert
+  // BOTH halves stay unchanged — a partial success is the state the ruling exists to prevent.
+  it('declines whole when the new parent has no invertible world matrix', () => {
+    const parentA = createTransformNode();
+    const child = createTransformNode();
+    child.x = 20;
+    child.y = 10;
+    invalidateNodeLocalTransform(child);
+    addNodeChild(parentA, child);
+
+    const collapsed = createTransformNode();
+    collapsed.scaleX = 0;
+    invalidateNodeLocalTransform(collapsed);
+
+    expect(reparentNode(child, collapsed)).toBe(false);
+    // Neither half happened: the attachment is untouched...
+    expect(getNodeParent(child)).toBe(parentA);
+    expect(getNodeChildCount(collapsed)).toBe(0);
+    // ...and so is the transform, with no NaN written into it.
+    expect(child.x).toBe(20);
+    expect(child.y).toBe(10);
+  });
+
+  it('reports true and still preserves world position for an invertible parent', () => {
+    const parentA = createTransformNode();
+    const child = createTransformNode();
+    child.x = 20;
+    child.y = 10;
+    invalidateNodeLocalTransform(child);
+    addNodeChild(parentA, child);
+    const before = cloneMatrix(getNodeWorldMatrix(child));
+
+    const parentB = createTransformNode();
+    parentB.x = 200;
+    invalidateNodeLocalTransform(parentB);
+
+    expect(reparentNode(child, parentB)).toBe(true);
+    expect(getNodeParent(child)).toBe(parentB);
+    const after = getNodeWorldMatrix(child);
+    expect(after.tx).toBeCloseTo(before.tx, 6);
+    expect(after.ty).toBeCloseTo(before.ty, 6);
+  });
+
   it('preserves world position after reparenting', () => {
     const parentA = createTransformNode();
     parentA.x = 100;
@@ -740,27 +825,81 @@ describe('reparentNode', () => {
     expect(after.ty).toBeCloseTo(before.ty, 10);
   });
 
-  it('preserves skewX and skewY values', () => {
+  it('preserves shear induced by rotation across non-uniformly scaled parents', () => {
+    const parentA = createTransformNode();
+    parentA.rotation = -15;
+    parentA.scaleX = 0.75;
+    parentA.scaleY = 2.5;
+    invalidateNodeLocalTransform(parentA);
+
+    const child = createTransformNode();
+    child.x = 10;
+    child.y = 5;
+    child.rotation = 37;
+    child.scaleX = 1.2;
+    child.scaleY = 0.9;
+    invalidateNodeLocalTransform(child);
+    addNodeChild(parentA, child);
+
+    expect(child.skewX).toBe(0);
+    expect(child.skewY).toBe(0);
+    const before = cloneMatrix(getNodeWorldMatrix(child));
+
+    const parentB = createTransformNode();
+    parentB.rotation = 22;
+    parentB.scaleX = 2.4;
+    parentB.scaleY = 0.6;
+    invalidateNodeLocalTransform(parentB);
+
+    reparentNode(child, parentB);
+    const after = getNodeWorldMatrix(child);
+
+    expect(after.a).toBeCloseTo(before.a, 10);
+    expect(after.b).toBeCloseTo(before.b, 10);
+    expect(after.c).toBeCloseTo(before.c, 10);
+    expect(after.d).toBeCloseTo(before.d, 10);
+    expect(after.tx).toBeCloseTo(before.tx, 10);
+    expect(after.ty).toBeCloseTo(before.ty, 10);
+  });
+
+  it('preserves a skewed world transform across asymmetric parents', () => {
     const parentA = createTransformNode();
     parentA.x = 50;
     parentA.rotation = 45;
+    parentA.scaleX = 2;
+    parentA.scaleY = 3;
     invalidateNodeLocalTransform(parentA);
 
     const child = createTransformNode();
     child.x = 10;
+    child.y = 5;
+    child.rotation = 12;
+    child.scaleX = 1.4;
+    child.scaleY = 0.8;
     child.skewX = 15;
     child.skewY = 20;
     invalidateNodeLocalTransform(child);
     addNodeChild(parentA, child);
 
+    const before = cloneMatrix(getNodeWorldMatrix(child));
+
     const parentB = createTransformNode();
     parentB.x = 100;
+    parentB.y = -20;
+    parentB.rotation = -10;
+    parentB.scaleX = 0.7;
+    parentB.scaleY = 1.6;
     invalidateNodeLocalTransform(parentB);
 
     reparentNode(child, parentB);
+    const after = getNodeWorldMatrix(child);
 
-    expect(child.skewX).toBe(15);
-    expect(child.skewY).toBe(20);
+    expect(after.a).toBeCloseTo(before.a, 10);
+    expect(after.b).toBeCloseTo(before.b, 10);
+    expect(after.c).toBeCloseTo(before.c, 10);
+    expect(after.d).toBeCloseTo(before.d, 10);
+    expect(after.tx).toBeCloseTo(before.tx, 10);
+    expect(after.ty).toBeCloseTo(before.ty, 10);
   });
 
   it('preserves world position with pivot', () => {
@@ -842,6 +981,7 @@ describe('reparentNode', () => {
     reparentNode(child, parentB);
     const after = getNodeWorldMatrix(child);
 
+    expect(child.scaleY).toBeLessThan(0);
     expect(after.a).toBeCloseTo(before.a, 10);
     expect(after.b).toBeCloseTo(before.b, 10);
     expect(after.c).toBeCloseTo(before.c, 10);
@@ -908,6 +1048,11 @@ describe('replaceNodeChild', () => {
 });
 
 describe('setNodeChildIndex', () => {
+  it('does nothing when the node has never had children', () => {
+    expect(() => setNodeChildIndex(container, childA, 0)).not.toThrow();
+    expect(getNodeChildCount(container)).toBe(0);
+  });
+
   it('advances the child-list revision when order changes', () => {
     addNodeChild(container, childA);
     addNodeChild(container, childB);
@@ -948,6 +1093,25 @@ describe('setNodeChildIndex', () => {
     expect(getChildren(container)[0]).toBe(childA);
   });
 
+  it('does not advance the revision when the child is already at the destination', () => {
+    addNodeChild(container, childA);
+    const childrenId = getNodeChildrenRevision(container);
+
+    setNodeChildIndex(container, childA, 0);
+
+    expect(getNodeChildrenRevision(container)).toBe(childrenId);
+    expect(getNodeChildAt(container, 0)).toBe(childA);
+  });
+
+  it('ignores a stale parent reference whose child-list entry is absent', () => {
+    addNodeChild(container, childB);
+    getEntityRuntime(childA).parent = container;
+
+    setNodeChildIndex(container, childA, 0);
+
+    expect(getChildren(container)).toEqual([childB]);
+  });
+
   it('calls onChildrenOrderChanged on the parent', () => {
     addNodeChild(container, childA);
     addNodeChild(container, childB);
@@ -961,7 +1125,48 @@ describe('setNodeChildIndex', () => {
   });
 });
 
+describe('setReparentNodeGuard', () => {
+  type TransformNode = Node<HasTransform2D> & HasTransform2D;
+  function createTransformNode(): TransformNode {
+    const node = createNode('TransformTest') as TransformNode;
+    initTransform2DTrait(node);
+    initTransform2DRuntimeTrait(getRawEntityRuntime(node) as HasTransform2DRuntime);
+    return node;
+  }
+
+  it('is notified on the decline and never on success', () => {
+    const seen: string[] = [];
+    setReparentNodeGuard((_child, newParent) => seen.push(newParent.name ?? '<unnamed>'));
+    try {
+      const child = createTransformNode();
+      const collapsed = createTransformNode();
+      collapsed.name = 'collapsed';
+      collapsed.scaleX = 0;
+      invalidateNodeLocalTransform(collapsed);
+      const healthy = createTransformNode();
+      healthy.name = 'healthy';
+      invalidateNodeLocalTransform(healthy);
+
+      reparentNode(child, collapsed);
+      reparentNode(child, healthy);
+      expect(seen).toEqual(['collapsed']);
+    } finally {
+      setReparentNodeGuard(null);
+    }
+  });
+});
+
 describe('swapNodeChildren', () => {
+  it('does not advance the revision when both arguments are the same child', () => {
+    addNodeChild(container, childA);
+    const childrenId = getNodeChildrenRevision(container);
+
+    swapNodeChildren(container, childA, childA);
+
+    expect(getNodeChildrenRevision(container)).toBe(childrenId);
+    expect(getNodeChildAt(container, 0)).toBe(childA);
+  });
+
   it('advances the child-list revision when order changes', () => {
     addNodeChild(container, childA);
     addNodeChild(container, childB);
@@ -1007,6 +1212,21 @@ describe('swapNodeChildren', () => {
 });
 
 describe('swapNodeChildrenAt', () => {
+  it('does nothing when the node has never had children', () => {
+    expect(() => swapNodeChildrenAt(container, 0, 1)).not.toThrow();
+    expect(getNodeChildCount(container)).toBe(0);
+  });
+
+  it('does not advance the revision when both indices are equal', () => {
+    addNodeChild(container, childA);
+    const childrenId = getNodeChildrenRevision(container);
+
+    swapNodeChildrenAt(container, 0, 0);
+
+    expect(getNodeChildrenRevision(container)).toBe(childrenId);
+    expect(getNodeChildAt(container, 0)).toBe(childA);
+  });
+
   it('advances the child-list revision when order changes', () => {
     addNodeChild(container, childA);
     addNodeChild(container, childB);

package/src/node.test.ts

@@ -1,5 +1,5 @@
 import { connectSignal } from '@flighthq/signals/contract';
-import type { Node, NodeData, NodeRuntime, PartialNode } from '@flighthq/types/contract';
+import type { InteractionSignals, Node, NodeData, NodeRuntime, PartialNode } from '@flighthq/types/contract';
 import { NodeKind } from '@flighthq/types/contract';
 
 import { addNodeChild, getNodeChildCount, getNodeParent } from './hierarchy';
@@ -165,6 +165,16 @@ describe('disposeNode', () => {
     expect(getNodeSignals(node)).toBeNull();
   });
 
+  it('releases the interaction signal registry after disposal', () => {
+    const node = createNode(NodeKind);
+    const runtime = getNodeRuntime(node) as NodeRuntime;
+    runtime.interactionSignals = {} as InteractionSignals;
+
+    disposeNode(node);
+
+    expect(runtime.interactionSignals).toBeNull();
+  });
+
   it('is safe to call on a root node with no parent', () => {
     const node = createNode(NodeKind);
     expect(() => disposeNode(node)).not.toThrow();

package/src/nodeColorAdjustment.test.ts

@@ -19,6 +19,17 @@ describe('addNodeColorAdjustment', () => {
     expect(getNodeColorAdjustments(node)).toEqual([adjustment]);
     expect(getNodeRuntime(node).resolvedColorScaleBias?.redScale).toBeCloseTo(0x7f / 255);
   });
+
+  it('appends to an existing stack without replacing earlier adjustments', () => {
+    const node = createNode(NodeKind);
+    const first = createTintAdjustment(0xff0000ff);
+    const second = createTintAdjustment(0x00ff00ff);
+
+    addNodeColorAdjustment(node, first);
+    addNodeColorAdjustment(node, second);
+
+    expect(getNodeColorAdjustments(node)).toEqual([first, second]);
+  });
 });
 
 describe('getNodeColorAdjustments', () => {

package/src/nodeOrderList.test.ts

@@ -38,6 +38,12 @@ function getChildren(source: Node) {
   return getNodeRuntime(source).children as Node[];
 }
 
+function expectChildren(source: Node, expected: readonly Node[]): void {
+  const actual = getChildren(source);
+  expect(actual).toHaveLength(expected.length);
+  for (let i = 0; i < expected.length; i++) expect(actual[i]).toBe(expected[i]);
+}
+
 function attachAll() {
   addNodeChild(container, childA);
   addNodeChild(container, childB);
@@ -91,7 +97,7 @@ describe('applyNodeOrderList', () => {
 
     applyNodeOrderList(container, list);
 
-    expect(getChildren(container)).toEqual([childC, childB, childA]);
+    expectChildren(container, [childC, childB, childA]);
   });
 
   it('never moves a child the list does not name', () => {
@@ -107,7 +113,7 @@ describe('applyNodeOrderList', () => {
 
     // The members swap across the slots they held (0 and 2); the foreign child keeps slot 1, so it
     // still sits between them rather than being compacted to one side.
-    expect(getChildren(container)).toEqual([childB, foreign, childA]);
+    expectChildren(container, [childB, foreign, childA]);
   });
 
   it('ignores entries that are not children of the target', () => {
@@ -121,7 +127,7 @@ describe('applyNodeOrderList', () => {
 
     applyNodeOrderList(container, list);
 
-    expect(getChildren(container)).toEqual([childB, childA]);
+    expectChildren(container, [childB, childA]);
   });
 
   it('ignores entries attached to a different parent', () => {
@@ -136,8 +142,8 @@ describe('applyNodeOrderList', () => {
 
     applyNodeOrderList(container, list);
 
-    expect(getChildren(container)).toEqual([childB, childA]);
-    expect(getChildren(other)).toEqual([childC]);
+    expectChildren(container, [childB, childA]);
+    expectChildren(other, [childC]);
   });
 
   it('is a no-op once every member has been removed', () => {
@@ -152,7 +158,7 @@ describe('applyNodeOrderList', () => {
 
     applyNodeOrderList(container, list);
 
-    expect(getChildren(container)).toEqual([foreign]);
+    expectChildren(container, [foreign]);
     expect(getNodeChildrenRevision(container)).toBe(revision);
   });
 
@@ -166,7 +172,7 @@ describe('applyNodeOrderList', () => {
 
     applyNodeOrderList(container, list);
 
-    expect(getChildren(container)).toEqual([childC, childA]);
+    expectChildren(container, [childC, childA]);
   });
 
   it('breaks equal sort keys by the order the entries were added', () => {
@@ -180,7 +186,7 @@ describe('applyNodeOrderList', () => {
 
     applyNodeOrderList(container, list);
 
-    expect(getChildren(container)).toEqual([childA, childB, childC]);
+    expectChildren(container, [childA, childB, childC]);
   });
 
   it('resolves a node entered twice to its last entry', () => {
@@ -193,7 +199,7 @@ describe('applyNodeOrderList', () => {
 
     applyNodeOrderList(container, list);
 
-    expect(getChildren(container)).toEqual([childB, childA]);
+    expectChildren(container, [childB, childA]);
   });
 
   it('is idempotent', () => {
@@ -207,7 +213,7 @@ describe('applyNodeOrderList', () => {
 
     applyNodeOrderList(container, list);
 
-    expect(getChildren(container)).toEqual([childB, childA]);
+    expectChildren(container, [childB, childA]);
     expect(getNodeChildrenRevision(container)).toBe(revision);
   });
 
@@ -263,9 +269,31 @@ describe('applyNodeOrderList', () => {
 
     applyNodeOrderList(container, createNodeOrderList());
 
-    expect(getChildren(container)).toEqual([childA, childB]);
+    expectChildren(container, [childA, childB]);
     expect(getNodeChildrenRevision(container)).toBe(revision);
   });
+
+  it('leaves a childless target alone when the list is nonempty', () => {
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childA, 1);
+
+    expect(() => applyNodeOrderList(container, list)).not.toThrow();
+    expect(getNodeRuntime(container).children).toBeNull();
+  });
+
+  it('does not apply retained entries outside the valid window', () => {
+    addNodeChild(container, childC);
+    addNodeChild(container, childB);
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childC, 10);
+    addNodeOrderListEntry(list, childB, 0);
+    clearNodeOrderList(list);
+    addNodeOrderListEntry(list, childC, 10);
+
+    applyNodeOrderList(container, list);
+
+    expectChildren(container, [childC, childB]);
+  });
 });
 
 describe('clearNodeOrderList', () => {
@@ -433,7 +461,7 @@ describe('removeNodeOrderListEntry', () => {
 
     // A keeps slot 0 — only its entry was removed, not the child. C was entered before B and stays
     // before it; a swap-with-last removal would have put B first and left the children untouched.
-    expect(getChildren(container)).toEqual([childA, childC, childB]);
+    expectChildren(container, [childA, childC, childB]);
   });
 });
 
@@ -467,7 +495,7 @@ describe('setNodeOrderListEntryAbove', () => {
     setNodeOrderListEntryAbove(list, childA, childC);
     applyNodeOrderList(container, list);
 
-    expect(getChildren(container)).toEqual([childB, childC, childA]);
+    expectChildren(container, [childB, childC, childA]);
   });
 
   it('places between neighbours whose keys leave no gap', () => {
@@ -477,11 +505,20 @@ describe('setNodeOrderListEntryAbove', () => {
     addNodeOrderListEntry(list, childC, 6);
 
     setNodeOrderListEntryAbove(list, childA, childB);
+
+    expect(list.entryCount).toBe(3);
+    expect(list.nodes).toHaveLength(3);
+    expect(list.sortKeys).toHaveLength(3);
+    expect(list.nodes[0]).toBe(childB);
+    expect(list.nodes[1]).toBe(childA);
+    expect(list.nodes[2]).toBe(childC);
+    expect(list.sortKeys.slice(0, 3)).toEqual([5, 5, 6]);
+
     applyNodeOrderList(container, list);
 
     // No midpoint exists between 5 and 6, so bisection could not express this; the equal-key plus
     // entry-position rule can.
-    expect(getChildren(container)).toEqual([childB, childA, childC]);
+    expectChildren(container, [childB, childA, childC]);
   });
 
   it('moves a node that is already entered rather than duplicating it', () => {
@@ -503,6 +540,16 @@ describe('setNodeOrderListEntryAbove', () => {
     expect(list.entryCount).toBe(0);
   });
 
+  it('keeps an existing node entry when the target has no entry', () => {
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childA, 4);
+
+    setNodeOrderListEntryAbove(list, childA, childC);
+
+    expect(list.entryCount).toBe(1);
+    expect(getNodeOrderListEntrySortKey(list, childA)).toBe(4);
+  });
+
   it('does nothing when the node is its own target', () => {
     const list = createNodeOrderList();
     addNodeOrderListEntry(list, childA, 4);
@@ -523,7 +570,7 @@ describe('setNodeOrderListEntryBelow', () => {
     setNodeOrderListEntryBelow(list, childA, childC);
     applyNodeOrderList(container, list);
 
-    expect(getChildren(container)).toEqual([childB, childA, childC]);
+    expectChildren(container, [childB, childA, childC]);
   });
 
   it('places between neighbours whose keys leave no gap', () => {
@@ -535,7 +582,7 @@ describe('setNodeOrderListEntryBelow', () => {
     setNodeOrderListEntryBelow(list, childA, childC);
     applyNodeOrderList(container, list);
 
-    expect(getChildren(container)).toEqual([childB, childA, childC]);
+    expectChildren(container, [childB, childA, childC]);
   });
 
   it('does nothing when the target has no entry', () => {
@@ -545,6 +592,16 @@ describe('setNodeOrderListEntryBelow', () => {
 
     expect(list.entryCount).toBe(0);
   });
+
+  it('keeps an existing node entry when the target has no entry', () => {
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childA, 4);
+
+    setNodeOrderListEntryBelow(list, childA, childC);
+
+    expect(list.entryCount).toBe(1);
+    expect(getNodeOrderListEntrySortKey(list, childA)).toBe(4);
+  });
 });
 
 describe('setNodeOrderListFromNodeChildren', () => {
@@ -568,7 +625,7 @@ describe('setNodeOrderListFromNodeChildren', () => {
 
     applyNodeOrderList(container, list);
 
-    expect(getChildren(container)).toEqual([childA, childB, childC]);
+    expectChildren(container, [childA, childB, childC]);
     expect(getNodeChildrenRevision(container)).toBe(revision);
   });
 
@@ -603,7 +660,7 @@ describe('swapNodeOrderListEntries', () => {
     swapNodeOrderListEntries(list, childA, childC);
     applyNodeOrderList(container, list);
 
-    expect(getChildren(container)).toEqual([childC, childB, childA]);
+    expectChildren(container, [childC, childB, childA]);
   });
 
   it('does nothing unless both nodes are entered', () => {
@@ -614,4 +671,13 @@ describe('swapNodeOrderListEntries', () => {
 
     expect(getNodeOrderListEntrySortKey(list, childA)).toBe(1);
   });
+
+  it('does nothing when the first node has no entry', () => {
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childB, 2);
+
+    swapNodeOrderListEntries(list, childA, childB);
+
+    expect(getNodeOrderListEntrySortKey(list, childB)).toBe(2);
+  });
 });

package/src/nodeTransform2d.test.ts

@@ -166,6 +166,28 @@ describe('ensureNodeLocalMatrix', () => {
     ensureNodeLocalMatrix(node);
     expect(equalsMatrix(runtime.localMatrix, cache)).toBe(true);
   });
+
+  it('normalizes rotations above 180 degrees', () => {
+    const runtime = getEntityRuntime(node) as HasTransform2DRuntime;
+    node.rotation = 270;
+    invalidateNodeLocalTransform(node);
+
+    ensureNodeLocalMatrix(node);
+
+    expect(runtime.rotationAngle).toBe(-90);
+    expect(runtime.localMatrix?.b).toBeCloseTo(-1);
+  });
+
+  it('normalizes rotations below -180 degrees', () => {
+    const runtime = getEntityRuntime(node) as HasTransform2DRuntime;
+    node.rotation = -270;
+    invalidateNodeLocalTransform(node);
+
+    ensureNodeLocalMatrix(node);
+
+    expect(runtime.rotationAngle).toBe(90);
+    expect(runtime.localMatrix?.b).toBeCloseTo(1);
+  });
 });
 
 describe('ensureNodeWorldMatrix', () => {
@@ -282,6 +304,29 @@ describe('setNodeLocalMatrix', () => {
     expect(m.ty).toBeCloseTo(20);
   });
 
+  // Pins the losslessness this function's contract promises for a reflected (negative determinant)
+  // matrix. Positive-determinant cases round-tripped even while reflected ones silently lost the
+  // reflection, so a fixture that is not reflected cannot speak to this.
+  it('round-trips a reflected matrix, keeping the mirror', () => {
+    setNodeLocalMatrix(node, createMatrix(1, 0, 0, -1, 0, 0));
+    const m = getNodeLocalMatrix(node);
+    expect(m.a).toBeCloseTo(1);
+    expect(m.b).toBeCloseTo(0);
+    expect(m.c).toBeCloseTo(0);
+    expect(m.d).toBeCloseTo(-1);
+  });
+
+  it('round-trips a rotated reflection through all four matrix cells', () => {
+    setNodeLocalMatrix(node, createMatrix(0.5, 0.8, 0.8, -0.5, 3, 4));
+    const m = getNodeLocalMatrix(node);
+    expect(m.a).toBeCloseTo(0.5);
+    expect(m.b).toBeCloseTo(0.8);
+    expect(m.c).toBeCloseTo(0.8);
+    expect(m.d).toBeCloseTo(-0.5);
+    expect(m.tx).toBeCloseTo(3);
+    expect(m.ty).toBeCloseTo(4);
+  });
+
   it('resets pivot and absorbs its offset into translation', () => {
     node.pivotX = 5;
     node.pivotY = 5;