@flighthq/node 0.3.1-next.847.2e6f8bf → 0.3.1-next.887.9f59a84

package/src/boundsRectangle.test.ts

@@ -13,6 +13,8 @@ import {
   initTransform2DRuntimeTrait,
   initTransform2DTrait,
   invalidateNodeLocalTransform,
+  removeNodeChild,
+  setNodeEnabled,
 } from '@flighthq/node/contract';
 import type {
   HasBoundsRectangle,
@@ -120,9 +122,10 @@ describe('computeNodeBoundsRectangle', () => {
   it('should compute bounds relative to nested child', () => {
     const out = createRectangle();
     computeNodeBoundsRectangle(out, root, grandChild);
-    expect(out.width).toBeGreaterThan(0);
-    expect(out.height).toBeGreaterThan(0);
-    // exact numbers depend on transforms
+    expect(out.x).toBeCloseTo(-100);
+    expect(out.y).toBeCloseTo(-100);
+    expect(out.width).toBeCloseTo(205);
+    expect(out.height).toBeCloseTo(205);
   });
 
   it('should account for scaling in parent transforms', () => {
@@ -187,6 +190,20 @@ describe('computeNodeBoundsRectangle', () => {
     computeNodeBoundsRectangle(out, child, root);
     expect(equalsRectangle(out, getNodeWorldBoundsRectangle(child))).toBe(true);
   });
+
+  it('removes a detached target transform from target-relative bounds', () => {
+    root.x = 40;
+    root.y = -25;
+    invalidateNodeLocalTransform(root);
+    const out = createRectangle();
+
+    computeNodeBoundsRectangle(out, child, root);
+
+    expect(out.x).toBeCloseTo(105);
+    expect(out.y).toBeCloseTo(105);
+    expect(out.width).toBeCloseTo(100);
+    expect(out.height).toBeCloseTo(100);
+  });
 });
 
 describe('computeNodeRootLocalBoundsRectangle', () => {
@@ -573,8 +590,71 @@ describe('getNodeWorldBoundsRectangle', () => {
     invalidateNodeLocalTransform(child);
 
     const bounds = getNodeWorldBoundsRectangle(parent);
-    expect(bounds.width).toBeGreaterThan(10);
-    expect(bounds.height).toBeGreaterThan(10);
+    expect(bounds).toMatchObject({ x: 0, y: 0, width: 300, height: 200 });
+  });
+
+  it('refreshes cached aggregate bounds when a child moves', () => {
+    const parent = createTestNode();
+    const child = createTestNode();
+    addNodeChild(parent, child);
+    setRectangle(getNodeLocalBoundsRectangle(parent) as Rectangle, 0, 0, 10, 10);
+    setRectangle(getNodeLocalBoundsRectangle(child) as Rectangle, 0, 0, 20, 20);
+    child.x = 30;
+    invalidateNodeLocalTransform(child);
+    expect(getNodeWorldBoundsRectangle(parent)).toMatchObject({ x: 0, y: 0, width: 50, height: 20 });
+
+    child.x = 80;
+    invalidateNodeLocalTransform(child);
+
+    expect(getNodeWorldBoundsRectangle(parent)).toMatchObject({ x: 0, y: 0, width: 100, height: 20 });
+  });
+
+  it('consults a descendant kind-owned bounds validity hook after the aggregate is cached', () => {
+    const parent = createTestNode();
+    const child = createTestNode();
+    const runtime = getEntityRuntime(child);
+    let input = { width: 20 };
+    let stampedInput = input;
+    runtime.computeLocalBoundsRectangle = (out: Rectangle) => {
+      setRectangle(out, 100, 0, input.width, 10);
+      stampedInput = input;
+    };
+    runtime.isLocalBoundsRectangleValid = () => stampedInput === input;
+    addNodeChild(parent, child);
+    setRectangle(getNodeLocalBoundsRectangle(parent) as Rectangle, 0, 0, 10, 10);
+    expect(getNodeWorldBoundsRectangle(parent).width).toBe(120);
+
+    input = { width: 50 };
+
+    expect(getNodeWorldBoundsRectangle(parent).width).toBe(150);
+  });
+
+  it('refreshes cached aggregate bounds when a child is removed', () => {
+    const parent = createTestNode();
+    const child = createTestNode();
+    addNodeChild(parent, child);
+    setRectangle(getNodeLocalBoundsRectangle(parent) as Rectangle, 0, 0, 10, 10);
+    setRectangle(getNodeLocalBoundsRectangle(child) as Rectangle, 100, 0, 200, 200);
+    expect(getNodeWorldBoundsRectangle(parent).width).toBe(300);
+
+    removeNodeChild(parent, child);
+
+    expect(getNodeWorldBoundsRectangle(parent)).toMatchObject({ x: 0, y: 0, width: 10, height: 10 });
+  });
+
+  it('refreshes cached aggregate bounds when a child is disabled or re-enabled', () => {
+    const parent = createTestNode();
+    const child = createTestNode();
+    addNodeChild(parent, child);
+    setRectangle(getNodeLocalBoundsRectangle(parent) as Rectangle, 0, 0, 10, 10);
+    setRectangle(getNodeLocalBoundsRectangle(child) as Rectangle, 100, 0, 200, 200);
+    expect(getNodeWorldBoundsRectangle(parent).width).toBe(300);
+
+    setNodeEnabled(child, false);
+    expect(getNodeWorldBoundsRectangle(parent).width).toBe(10);
+
+    setNodeEnabled(child, true);
+    expect(getNodeWorldBoundsRectangle(parent).width).toBe(300);
   });
 
   it('ignores an enabled child with zero-area world bounds', () => {
@@ -609,6 +689,74 @@ describe('setNodeHeight', () => {
     setNodeHeight(node, 100);
     expect(node.scaleY).toBe(0);
   });
+
+  it('keeps a finite scale when the current height is zero', () => {
+    const node = createTestNode();
+    setRectangle(getNodeLocalBoundsRectangle(node) as Rectangle, 0, 0, 10, 0);
+
+    setNodeHeight(node, 100);
+
+    expect(node.scaleY).toBe(1);
+    expect(Number.isFinite(node.scaleY)).toBe(true);
+  });
+
+  for (const [name, transform] of sizeRoundTripTransforms) {
+    it(`round-trips parent-space height through ${name}`, () => {
+      const parent = createTestNode();
+      const node = createTestNode();
+      addNodeChild(parent, node);
+      setRectangle(getNodeLocalBoundsRectangle(node) as Rectangle, 0, 0, 10, 20);
+      Object.assign(node, transform);
+      invalidateNodeLocalTransform(node);
+      const sign = Math.sign(node.scaleY);
+
+      setNodeHeight(node, 100);
+
+      expect(getNodeHeight(node)).toBeCloseTo(100, 10);
+      expect(Math.sign(node.scaleY)).toBe(sign);
+    });
+  }
+
+  it('declines an unsatisfiable height below the fixed x-axis contribution', () => {
+    const parent = createTestNode();
+    const node = createTestNode();
+    addNodeChild(parent, node);
+    setRectangle(getNodeLocalBoundsRectangle(node) as Rectangle, 0, 0, 10, 20);
+    node.rotation = 30;
+    invalidateNodeLocalTransform(node);
+    const scaleY = node.scaleY;
+
+    setNodeHeight(node, 4);
+
+    expect(node.scaleY).toBe(scaleY);
+  });
+
+  it('does not mutate at a singular rotation and still solves near it', () => {
+    const singularParent = createTestNode();
+    const singular = createTestNode();
+    addNodeChild(singularParent, singular);
+    setRectangle(getNodeLocalBoundsRectangle(singular) as Rectangle, 0, 0, 10, 20);
+    singular.rotation = 90;
+    singular.scaleY = 2;
+    invalidateNodeLocalTransform(singular);
+
+    setNodeHeight(singular, 50);
+
+    expect(singular.scaleY).toBe(2);
+    expect(Number.isFinite(singular.scaleY)).toBe(true);
+
+    const nearParent = createTestNode();
+    const near = createTestNode();
+    addNodeChild(nearParent, near);
+    setRectangle(getNodeLocalBoundsRectangle(near) as Rectangle, 0, 0, 10, 20);
+    near.rotation = 89.999;
+    invalidateNodeLocalTransform(near);
+
+    setNodeHeight(near, 50);
+
+    expect(Number.isFinite(near.scaleY)).toBe(true);
+    expect(getNodeHeight(near)).toBeCloseTo(50, 8);
+  });
 });
 
 describe('setNodeWidth', () => {
@@ -628,6 +776,74 @@ describe('setNodeWidth', () => {
     setNodeWidth(node, 100);
     expect(node.scaleX).toBe(0);
   });
+
+  it('keeps a finite scale when the current width is zero', () => {
+    const node = createTestNode();
+    setRectangle(getNodeLocalBoundsRectangle(node) as Rectangle, 0, 0, 0, 10);
+
+    setNodeWidth(node, 100);
+
+    expect(node.scaleX).toBe(1);
+    expect(Number.isFinite(node.scaleX)).toBe(true);
+  });
+
+  for (const [name, transform] of sizeRoundTripTransforms) {
+    it(`round-trips parent-space width through ${name}`, () => {
+      const parent = createTestNode();
+      const node = createTestNode();
+      addNodeChild(parent, node);
+      setRectangle(getNodeLocalBoundsRectangle(node) as Rectangle, 0, 0, 10, 20);
+      Object.assign(node, transform);
+      invalidateNodeLocalTransform(node);
+      const sign = Math.sign(node.scaleX);
+
+      setNodeWidth(node, 100);
+
+      expect(getNodeWidth(node)).toBeCloseTo(100, 10);
+      expect(Math.sign(node.scaleX)).toBe(sign);
+    });
+  }
+
+  it('declines an unsatisfiable width below the fixed y-axis contribution', () => {
+    const parent = createTestNode();
+    const node = createTestNode();
+    addNodeChild(parent, node);
+    setRectangle(getNodeLocalBoundsRectangle(node) as Rectangle, 0, 0, 10, 20);
+    node.rotation = 30;
+    invalidateNodeLocalTransform(node);
+    const scaleX = node.scaleX;
+
+    setNodeWidth(node, 5);
+
+    expect(node.scaleX).toBe(scaleX);
+  });
+
+  it('does not mutate at a singular rotation and still solves near it', () => {
+    const singularParent = createTestNode();
+    const singular = createTestNode();
+    addNodeChild(singularParent, singular);
+    setRectangle(getNodeLocalBoundsRectangle(singular) as Rectangle, 0, 0, 10, 20);
+    singular.rotation = 90;
+    singular.scaleX = 2;
+    invalidateNodeLocalTransform(singular);
+
+    setNodeWidth(singular, 50);
+
+    expect(singular.scaleX).toBe(2);
+    expect(Number.isFinite(singular.scaleX)).toBe(true);
+
+    const nearParent = createTestNode();
+    const near = createTestNode();
+    addNodeChild(nearParent, near);
+    setRectangle(getNodeLocalBoundsRectangle(near) as Rectangle, 0, 0, 10, 20);
+    near.rotation = 89.999;
+    invalidateNodeLocalTransform(near);
+
+    setNodeWidth(near, 50);
+
+    expect(Number.isFinite(near.scaleX)).toBe(true);
+    expect(getNodeWidth(near)).toBeCloseTo(50, 8);
+  });
 });
 
 function cloneAndInvalidateRect(rect: Rectangle): Rectangle {
@@ -642,4 +858,11 @@ function invalidateRect(rect: Rectangle | null): void {
 
 type TestNode = Node<HasTransform2D & HasBoundsRectangle> & HasTransform2D & HasBoundsRectangle;
 
+const sizeRoundTripTransforms = [
+  ['rotation', { rotation: 30, scaleX: 1, scaleY: 1, skewX: 0, skewY: 0 }],
+  ['skew and non-uniform scale', { rotation: 10, scaleX: 0.7, scaleY: 2.3, skewX: 25, skewY: -15 }],
+  ['mirrored x scale', { rotation: -25, scaleX: -1.4, scaleY: 0.6, skewX: -10, skewY: 20 }],
+  ['mirrored y scale', { rotation: 40, scaleX: 1.8, scaleY: -1.2, skewX: 12, skewY: -18 }],
+] as const;
+
 const TestKind = 'Test';

package/src/hierarchy.test.ts

@@ -67,6 +67,15 @@ 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;
 
@@ -771,27 +780,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', () => {
@@ -873,6 +936,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);

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', () => {

package/src/nodeTransform2d.test.ts

@@ -304,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;