@flighthq/node 0.3.0-next.1595.4d49b41 → 0.3.0-next.1665.6235922

package/dist/contract.d.ts

@@ -9,6 +9,7 @@ export * from './hasTransform3d';
 export * from './hierarchy';
 export * from './node';
 export * from './nodeColorAdjustment';
+export * from './nodeOrderList';
 export * from './revision';
 export * from './nodeTransform2d';
 export * from './stageFit';

package/dist/contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../src/contract.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC;AACrC,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC;AAC5B,cAAc,QAAQ,CAAC;AACvB,cAAc,uBAAuB,CAAC;AACtC,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC;AAClC,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC"}
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../src/contract.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC;AACrC,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC;AAC5B,cAAc,QAAQ,CAAC;AACvB,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC;AAClC,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC"}

package/dist/contract.js

@@ -9,6 +9,7 @@ export * from './hasTransform3d';
 export * from './hierarchy';
 export * from './node';
 export * from './nodeColorAdjustment';
+export * from './nodeOrderList';
 export * from './revision';
 export * from './nodeTransform2d';
 export * from './stageFit';

package/dist/contract.js.map

@@ -1 +1 @@
-{"version":3,"file":"contract.js","sourceRoot":"","sources":["../src/contract.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC;AACrC,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC;AAC5B,cAAc,QAAQ,CAAC;AACvB,cAAc,uBAAuB,CAAC;AACtC,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC;AAClC,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC"}
+{"version":3,"file":"contract.js","sourceRoot":"","sources":["../src/contract.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC;AACrC,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC;AAC5B,cAAc,QAAQ,CAAC;AACvB,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC;AAClC,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC"}

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export { addNodeChild, addNodeChildAt, addNodeChildren, addNodeColorAdjustment, computeNodeBoundsRectangle, computeNodeRootLocalBoundsRectangle, computeScene2DFitAlignX, computeScene2DFitAlignY, computeScene2DFitFillScale, computeScene2DFitScale, computeScene2DFitTransform, containsNodeChild, convertNodeVector2GlobalToLocal, convertNodeVector2LocalToGlobal, convertNodeVector3GlobalToLocal, convertNodeVector3LocalToGlobal, createNode, createViewport, disposeNode, enableNodeSignals, findNode, findNodeByName, forEachNodeAncestor, forEachNodeChild, forEachNodeDescendant, getNodeAncestors, getNodeAppearanceRevision, getNodeChildAt, getNodeChildByName, getNodeChildCount, getNodeChildIndex, getNodeChildren, getNodeColorAdjustments, getNodeCommonAncestor, getNodeDepth, getNodeHeight, getNodeLocalBoundsRectangle, getNodeLocalBoundsRevision, getNodeLocalContentRevision, getNodeLocalMatrix, getNodeLocalMatrix4, getNodeLocalTransformRevision, getNodeNextSibling, getNodeParent, getNodeParentBoundsRectangle, getNodePreviousSibling, getNodeRoot, getNodeSignals, getNodeTransform2D, getNodeTransform3D, getNodeWidth, getNodeWorldBoundsRectangle, getNodeWorldMatrix, getNodeWorldMatrix4, getNodeWorldTransformRevision, getViewportAspect, invalidateNodeAppearance, invalidateNodeLocalTransform, invalidateNodeRender, isNodeAncestorOf, isNodeLocalMatrix4Detached, removeNodeChild, removeNodeChildAt, removeNodeChildren, reparentNode, replaceNodeChild, setNodeChildIndex, setNodeColorAdjustments, setNodeColorAdjustmentsTint, setNodeEnabled, setNodeHeight, setNodeLocalMatrix, setNodeLocalMatrix4, setNodeTransform2D, setNodeTransform3D, setNodeWidth, swapNodeChildren, swapNodeChildrenAt, walkNodeDescendants, } from './contract';
+export { addNodeChild, addNodeChildAt, addNodeChildren, addNodeColorAdjustment, addNodeOrderListEntry, applyNodeOrderList, computeNodeBoundsRectangle, computeNodeRootLocalBoundsRectangle, computeScene2DFitAlignX, computeScene2DFitAlignY, computeScene2DFitFillScale, computeScene2DFitScale, computeScene2DFitTransform, clearNodeOrderList, containsNodeChild, convertNodeVector2GlobalToLocal, convertNodeVector2LocalToGlobal, convertNodeVector3GlobalToLocal, convertNodeVector3LocalToGlobal, createNode, createNodeOrderList, createViewport, disposeNode, enableNodeSignals, findNode, findNodeByName, forEachNodeAncestor, forEachNodeChild, forEachNodeDescendant, getNodeAncestors, getNodeAppearanceRevision, getNodeChildAt, getNodeChildByName, getNodeChildCount, getNodeChildIndex, getNodeChildren, getNodeColorAdjustments, getNodeCommonAncestor, getNodeDepth, getNodeHeight, getNodeLocalBoundsRectangle, getNodeLocalBoundsRevision, getNodeLocalContentRevision, getNodeLocalMatrix, getNodeLocalMatrix4, getNodeLocalTransformRevision, getNodeNextSibling, getNodeParent, getNodeParentBoundsRectangle, getNodePreviousSibling, getNodeRoot, getNodeSignals, getNodeTransform2D, getNodeTransform3D, getNodeWidth, getNodeWorldBoundsRectangle, getNodeWorldMatrix, getNodeWorldMatrix4, getNodeWorldTransformRevision, getViewportAspect, invalidateNodeAppearance, invalidateNodeLocalTransform, invalidateNodeRender, isNodeAncestorOf, isNodeLocalMatrix4Detached, removeNodeChild, removeNodeChildAt, removeNodeChildren, reparentNode, replaceNodeChild, setNodeChildIndex, setNodeColorAdjustments, setNodeColorAdjustmentsTint, setNodeEnabled, setNodeHeight, setNodeLocalMatrix, setNodeLocalMatrix4, setNodeTransform2D, setNodeTransform3D, setNodeWidth, swapNodeChildren, swapNodeChildrenAt, walkNodeDescendants, disposeNodeOrderList, forEachNodeOrderListEntry, getNodeOrderListEntrySortKey, hasNodeOrderListEntry, removeNodeOrderListEntry, setNodeOrderListEntry, setNodeOrderListEntryAbove, setNodeOrderListEntryBelow, setNodeOrderListFromNodeChildren, swapNodeOrderListEntries, } from './contract';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,cAAc,EACd,eAAe,EACf,sBAAsB,EACtB,0BAA0B,EAC1B,mCAAmC,EACnC,uBAAuB,EACvB,uBAAuB,EACvB,0BAA0B,EAC1B,sBAAsB,EACtB,0BAA0B,EAC1B,iBAAiB,EACjB,+BAA+B,EAC/B,+BAA+B,EAC/B,+BAA+B,EAC/B,+BAA+B,EAC/B,UAAU,EACV,cAAc,EACd,WAAW,EACX,iBAAiB,EACjB,QAAQ,EACR,cAAc,EACd,mBAAmB,EACnB,gBAAgB,EAChB,qBAAqB,EACrB,gBAAgB,EAChB,yBAAyB,EACzB,cAAc,EACd,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,EACjB,eAAe,EACf,uBAAuB,EACvB,qBAAqB,EACrB,YAAY,EACZ,aAAa,EACb,2BAA2B,EAC3B,0BAA0B,EAC1B,2BAA2B,EAC3B,kBAAkB,EAClB,mBAAmB,EACnB,6BAA6B,EAC7B,kBAAkB,EAClB,aAAa,EACb,4BAA4B,EAC5B,sBAAsB,EACtB,WAAW,EACX,cAAc,EACd,kBAAkB,EAClB,kBAAkB,EAClB,YAAY,EACZ,2BAA2B,EAC3B,kBAAkB,EAClB,mBAAmB,EACnB,6BAA6B,EAC7B,iBAAiB,EACjB,wBAAwB,EACxB,4BAA4B,EAC5B,oBAAoB,EACpB,gBAAgB,EAChB,0BAA0B,EAC1B,eAAe,EACf,iBAAiB,EACjB,kBAAkB,EAClB,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,EACjB,uBAAuB,EACvB,2BAA2B,EAC3B,cAAc,EACd,aAAa,EACb,kBAAkB,EAClB,mBAAmB,EACnB,kBAAkB,EAClB,kBAAkB,EAClB,YAAY,EACZ,gBAAgB,EAChB,kBAAkB,EAClB,mBAAmB,GACpB,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,cAAc,EACd,eAAe,EACf,sBAAsB,EACtB,qBAAqB,EACrB,kBAAkB,EAClB,0BAA0B,EAC1B,mCAAmC,EACnC,uBAAuB,EACvB,uBAAuB,EACvB,0BAA0B,EAC1B,sBAAsB,EACtB,0BAA0B,EAC1B,kBAAkB,EAClB,iBAAiB,EACjB,+BAA+B,EAC/B,+BAA+B,EAC/B,+BAA+B,EAC/B,+BAA+B,EAC/B,UAAU,EACV,mBAAmB,EACnB,cAAc,EACd,WAAW,EACX,iBAAiB,EACjB,QAAQ,EACR,cAAc,EACd,mBAAmB,EACnB,gBAAgB,EAChB,qBAAqB,EACrB,gBAAgB,EAChB,yBAAyB,EACzB,cAAc,EACd,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,EACjB,eAAe,EACf,uBAAuB,EACvB,qBAAqB,EACrB,YAAY,EACZ,aAAa,EACb,2BAA2B,EAC3B,0BAA0B,EAC1B,2BAA2B,EAC3B,kBAAkB,EAClB,mBAAmB,EACnB,6BAA6B,EAC7B,kBAAkB,EAClB,aAAa,EACb,4BAA4B,EAC5B,sBAAsB,EACtB,WAAW,EACX,cAAc,EACd,kBAAkB,EAClB,kBAAkB,EAClB,YAAY,EACZ,2BAA2B,EAC3B,kBAAkB,EAClB,mBAAmB,EACnB,6BAA6B,EAC7B,iBAAiB,EACjB,wBAAwB,EACxB,4BAA4B,EAC5B,oBAAoB,EACpB,gBAAgB,EAChB,0BAA0B,EAC1B,eAAe,EACf,iBAAiB,EACjB,kBAAkB,EAClB,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,EACjB,uBAAuB,EACvB,2BAA2B,EAC3B,cAAc,EACd,aAAa,EACb,kBAAkB,EAClB,mBAAmB,EACnB,kBAAkB,EAClB,kBAAkB,EAClB,YAAY,EACZ,gBAAgB,EAChB,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,yBAAyB,EACzB,4BAA4B,EAC5B,qBAAqB,EACrB,wBAAwB,EACxB,qBAAqB,EACrB,0BAA0B,EAC1B,0BAA0B,EAC1B,gCAAgC,EAChC,wBAAwB,GACzB,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -1,2 +1,2 @@
-export { addNodeChild, addNodeChildAt, addNodeChildren, addNodeColorAdjustment, computeNodeBoundsRectangle, computeNodeRootLocalBoundsRectangle, computeScene2DFitAlignX, computeScene2DFitAlignY, computeScene2DFitFillScale, computeScene2DFitScale, computeScene2DFitTransform, containsNodeChild, convertNodeVector2GlobalToLocal, convertNodeVector2LocalToGlobal, convertNodeVector3GlobalToLocal, convertNodeVector3LocalToGlobal, createNode, createViewport, disposeNode, enableNodeSignals, findNode, findNodeByName, forEachNodeAncestor, forEachNodeChild, forEachNodeDescendant, getNodeAncestors, getNodeAppearanceRevision, getNodeChildAt, getNodeChildByName, getNodeChildCount, getNodeChildIndex, getNodeChildren, getNodeColorAdjustments, getNodeCommonAncestor, getNodeDepth, getNodeHeight, getNodeLocalBoundsRectangle, getNodeLocalBoundsRevision, getNodeLocalContentRevision, getNodeLocalMatrix, getNodeLocalMatrix4, getNodeLocalTransformRevision, getNodeNextSibling, getNodeParent, getNodeParentBoundsRectangle, getNodePreviousSibling, getNodeRoot, getNodeSignals, getNodeTransform2D, getNodeTransform3D, getNodeWidth, getNodeWorldBoundsRectangle, getNodeWorldMatrix, getNodeWorldMatrix4, getNodeWorldTransformRevision, getViewportAspect, invalidateNodeAppearance, invalidateNodeLocalTransform, invalidateNodeRender, isNodeAncestorOf, isNodeLocalMatrix4Detached, removeNodeChild, removeNodeChildAt, removeNodeChildren, reparentNode, replaceNodeChild, setNodeChildIndex, setNodeColorAdjustments, setNodeColorAdjustmentsTint, setNodeEnabled, setNodeHeight, setNodeLocalMatrix, setNodeLocalMatrix4, setNodeTransform2D, setNodeTransform3D, setNodeWidth, swapNodeChildren, swapNodeChildrenAt, walkNodeDescendants, } from './contract';
+export { addNodeChild, addNodeChildAt, addNodeChildren, addNodeColorAdjustment, addNodeOrderListEntry, applyNodeOrderList, computeNodeBoundsRectangle, computeNodeRootLocalBoundsRectangle, computeScene2DFitAlignX, computeScene2DFitAlignY, computeScene2DFitFillScale, computeScene2DFitScale, computeScene2DFitTransform, clearNodeOrderList, containsNodeChild, convertNodeVector2GlobalToLocal, convertNodeVector2LocalToGlobal, convertNodeVector3GlobalToLocal, convertNodeVector3LocalToGlobal, createNode, createNodeOrderList, createViewport, disposeNode, enableNodeSignals, findNode, findNodeByName, forEachNodeAncestor, forEachNodeChild, forEachNodeDescendant, getNodeAncestors, getNodeAppearanceRevision, getNodeChildAt, getNodeChildByName, getNodeChildCount, getNodeChildIndex, getNodeChildren, getNodeColorAdjustments, getNodeCommonAncestor, getNodeDepth, getNodeHeight, getNodeLocalBoundsRectangle, getNodeLocalBoundsRevision, getNodeLocalContentRevision, getNodeLocalMatrix, getNodeLocalMatrix4, getNodeLocalTransformRevision, getNodeNextSibling, getNodeParent, getNodeParentBoundsRectangle, getNodePreviousSibling, getNodeRoot, getNodeSignals, getNodeTransform2D, getNodeTransform3D, getNodeWidth, getNodeWorldBoundsRectangle, getNodeWorldMatrix, getNodeWorldMatrix4, getNodeWorldTransformRevision, getViewportAspect, invalidateNodeAppearance, invalidateNodeLocalTransform, invalidateNodeRender, isNodeAncestorOf, isNodeLocalMatrix4Detached, removeNodeChild, removeNodeChildAt, removeNodeChildren, reparentNode, replaceNodeChild, setNodeChildIndex, setNodeColorAdjustments, setNodeColorAdjustmentsTint, setNodeEnabled, setNodeHeight, setNodeLocalMatrix, setNodeLocalMatrix4, setNodeTransform2D, setNodeTransform3D, setNodeWidth, swapNodeChildren, swapNodeChildrenAt, walkNodeDescendants, disposeNodeOrderList, forEachNodeOrderListEntry, getNodeOrderListEntrySortKey, hasNodeOrderListEntry, removeNodeOrderListEntry, setNodeOrderListEntry, setNodeOrderListEntryAbove, setNodeOrderListEntryBelow, setNodeOrderListFromNodeChildren, swapNodeOrderListEntries, } from './contract';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,cAAc,EACd,eAAe,EACf,sBAAsB,EACtB,0BAA0B,EAC1B,mCAAmC,EACnC,uBAAuB,EACvB,uBAAuB,EACvB,0BAA0B,EAC1B,sBAAsB,EACtB,0BAA0B,EAC1B,iBAAiB,EACjB,+BAA+B,EAC/B,+BAA+B,EAC/B,+BAA+B,EAC/B,+BAA+B,EAC/B,UAAU,EACV,cAAc,EACd,WAAW,EACX,iBAAiB,EACjB,QAAQ,EACR,cAAc,EACd,mBAAmB,EACnB,gBAAgB,EAChB,qBAAqB,EACrB,gBAAgB,EAChB,yBAAyB,EACzB,cAAc,EACd,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,EACjB,eAAe,EACf,uBAAuB,EACvB,qBAAqB,EACrB,YAAY,EACZ,aAAa,EACb,2BAA2B,EAC3B,0BAA0B,EAC1B,2BAA2B,EAC3B,kBAAkB,EAClB,mBAAmB,EACnB,6BAA6B,EAC7B,kBAAkB,EAClB,aAAa,EACb,4BAA4B,EAC5B,sBAAsB,EACtB,WAAW,EACX,cAAc,EACd,kBAAkB,EAClB,kBAAkB,EAClB,YAAY,EACZ,2BAA2B,EAC3B,kBAAkB,EAClB,mBAAmB,EACnB,6BAA6B,EAC7B,iBAAiB,EACjB,wBAAwB,EACxB,4BAA4B,EAC5B,oBAAoB,EACpB,gBAAgB,EAChB,0BAA0B,EAC1B,eAAe,EACf,iBAAiB,EACjB,kBAAkB,EAClB,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,EACjB,uBAAuB,EACvB,2BAA2B,EAC3B,cAAc,EACd,aAAa,EACb,kBAAkB,EAClB,mBAAmB,EACnB,kBAAkB,EAClB,kBAAkB,EAClB,YAAY,EACZ,gBAAgB,EAChB,kBAAkB,EAClB,mBAAmB,GACpB,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,cAAc,EACd,eAAe,EACf,sBAAsB,EACtB,qBAAqB,EACrB,kBAAkB,EAClB,0BAA0B,EAC1B,mCAAmC,EACnC,uBAAuB,EACvB,uBAAuB,EACvB,0BAA0B,EAC1B,sBAAsB,EACtB,0BAA0B,EAC1B,kBAAkB,EAClB,iBAAiB,EACjB,+BAA+B,EAC/B,+BAA+B,EAC/B,+BAA+B,EAC/B,+BAA+B,EAC/B,UAAU,EACV,mBAAmB,EACnB,cAAc,EACd,WAAW,EACX,iBAAiB,EACjB,QAAQ,EACR,cAAc,EACd,mBAAmB,EACnB,gBAAgB,EAChB,qBAAqB,EACrB,gBAAgB,EAChB,yBAAyB,EACzB,cAAc,EACd,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,EACjB,eAAe,EACf,uBAAuB,EACvB,qBAAqB,EACrB,YAAY,EACZ,aAAa,EACb,2BAA2B,EAC3B,0BAA0B,EAC1B,2BAA2B,EAC3B,kBAAkB,EAClB,mBAAmB,EACnB,6BAA6B,EAC7B,kBAAkB,EAClB,aAAa,EACb,4BAA4B,EAC5B,sBAAsB,EACtB,WAAW,EACX,cAAc,EACd,kBAAkB,EAClB,kBAAkB,EAClB,YAAY,EACZ,2BAA2B,EAC3B,kBAAkB,EAClB,mBAAmB,EACnB,6BAA6B,EAC7B,iBAAiB,EACjB,wBAAwB,EACxB,4BAA4B,EAC5B,oBAAoB,EACpB,gBAAgB,EAChB,0BAA0B,EAC1B,eAAe,EACf,iBAAiB,EACjB,kBAAkB,EAClB,YAAY,EACZ,gBAAgB,EAChB,iBAAiB,EACjB,uBAAuB,EACvB,2BAA2B,EAC3B,cAAc,EACd,aAAa,EACb,kBAAkB,EAClB,mBAAmB,EACnB,kBAAkB,EAClB,kBAAkB,EAClB,YAAY,EACZ,gBAAgB,EAChB,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,yBAAyB,EACzB,4BAA4B,EAC5B,qBAAqB,EACrB,wBAAwB,EACxB,qBAAqB,EACrB,0BAA0B,EAC1B,0BAA0B,EAC1B,gCAAgC,EAChC,wBAAwB,GACzB,MAAM,YAAY,CAAC"}

package/dist/nodeOrderList.d.ts

@@ -0,0 +1,88 @@
+import type { Node, NodeOrderList, NodeOrderListEntryVisitor, NodeTraits } from '@flighthq/types/contract';
+/**
+ * Appends one entry to the list's valid window. Capacity past `entryCount` is reused, so a list
+ * refilled every frame allocates only while it is growing. This does not check whether `node` is
+ * already entered — it is the O(1) bulk-fill verb. Use setNodeOrderListEntry to re-key a node that may
+ * already be present; a node entered twice resolves to its last entry.
+ */
+export declare function addNodeOrderListEntry<Traits extends object = NodeTraits>(list: NodeOrderList<Traits>, node: Node<Traits>, sortKey: number): void;
+/**
+ * Reorders `target`'s children so the list's members sit in ascending sort-key order, and does nothing
+ * else. This owns order, never membership: members are permuted among the slots they already occupy, so
+ * a child the list does not name never moves, not by one index. Entries that are not currently children
+ * of `target` — including ones attached to a different parent — are ignored rather than attached, which
+ * makes the call a no-op once the caller has detached every member.
+ *
+ * Because slots are preserved rather than compacted, a foreign child sitting between two members stays
+ * between them; no sort key moves a member past it. Contiguity comes from parenting, relative order
+ * from the list.
+ *
+ * Children are written in place rather than routed through setNodeChildIndex: every member is already a
+ * child of `target`, so no parent pointer or parentReferenceId changes, and the whole permutation stamps
+ * `childrenId` once instead of once per moved node.
+ */
+export declare function applyNodeOrderList<Traits extends object = NodeTraits>(target: Node<Traits>, list: Readonly<NodeOrderList<Traits>>): void;
+/**
+ * Empties the valid window without releasing capacity, so the next fill reuses the arrays. Entries past
+ * `entryCount` keep their node references; use disposeNodeOrderList to drop them.
+ */
+export declare function clearNodeOrderList<Traits extends object = NodeTraits>(list: NodeOrderList<Traits>): void;
+export declare function createNodeOrderList<Traits extends object = NodeTraits>(): NodeOrderList<Traits>;
+/**
+ * Empties the list and releases its node references, so a long-lived list stops holding nodes reachable.
+ * The list stays usable; this is the teardown counterpart to clearNodeOrderList, which deliberately
+ * retains both capacity and the references past the window for reuse.
+ */
+export declare function disposeNodeOrderList<Traits extends object = NodeTraits>(list: NodeOrderList<Traits>): void;
+/**
+ * Calls `callback` for each entry in the order the entries were added, which is not the order they
+ * resolve to. Stops early if `callback` returns `false`.
+ */
+export declare function forEachNodeOrderListEntry<Traits extends object = NodeTraits>(list: Readonly<NodeOrderList<Traits>>, callback: NodeOrderListEntryVisitor<Traits>): void;
+/**
+ * Returns the sort key `node` is entered with, or `null` when it has no entry. Null rather than -1
+ * because every finite number, negative included, is a legal sort key.
+ */
+export declare function getNodeOrderListEntrySortKey<Traits extends object = NodeTraits>(list: Readonly<NodeOrderList<Traits>>, node: Readonly<Node<Traits>>): number | null;
+export declare function hasNodeOrderListEntry<Traits extends object = NodeTraits>(list: Readonly<NodeOrderList<Traits>>, node: Readonly<Node<Traits>>): boolean;
+/**
+ * Removes `node`'s entry, returning whether one was found. Entries after it shift down rather than
+ * being back-filled from the end: entry position breaks ties between equal sort keys, so preserving it
+ * is part of the contract, not an implementation detail.
+ */
+export declare function removeNodeOrderListEntry<Traits extends object = NodeTraits>(list: NodeOrderList<Traits>, node: Readonly<Node<Traits>>): boolean;
+/**
+ * Enters `node` at `sortKey`, replacing its existing entry in place if it has one. This is the verb for
+ * incremental re-keying: unlike addNodeOrderListEntry it never grows the list with a second entry for
+ * the same node, at the cost of a scan.
+ */
+export declare function setNodeOrderListEntry<Traits extends object = NodeTraits>(list: NodeOrderList<Traits>, node: Node<Traits>, sortKey: number): void;
+/**
+ * Enters `node` so it resolves immediately above `target` — drawn after it, in front of it. Does
+ * nothing when `target` has no entry, since there is nothing to be above.
+ *
+ * Placement is exact rather than a midpoint between neighbouring keys: `node` takes `target`'s own sort
+ * key and its entry is positioned just after `target`'s, so the equal-key tie-break separates the two.
+ * That holds however tightly packed the surrounding keys are, and repeated placement never exhausts
+ * float precision the way bisection does.
+ */
+export declare function setNodeOrderListEntryAbove<Traits extends object = NodeTraits>(list: NodeOrderList<Traits>, node: Node<Traits>, target: Readonly<Node<Traits>>): void;
+/**
+ * Enters `node` so it resolves immediately below `target` — drawn before it, behind it. Does nothing
+ * when `target` has no entry. The mirror of setNodeOrderListEntryAbove, placing `node`'s entry just
+ * before `target`'s at the same sort key.
+ */
+export declare function setNodeOrderListEntryBelow<Traits extends object = NodeTraits>(list: NodeOrderList<Traits>, node: Node<Traits>, target: Readonly<Node<Traits>>): void;
+/**
+ * Refills the list from `source`'s current children, each entered at its own child index. This is the
+ * inverse of applyNodeOrderList: capture what is there, edit it with the *Above/*Below/swap verbs, then
+ * apply it back. Any previous contents are discarded.
+ */
+export declare function setNodeOrderListFromNodeChildren<Traits extends object = NodeTraits>(list: NodeOrderList<Traits>, source: Readonly<Node<Traits>>): void;
+/**
+ * Exchanges the sort keys of two entered nodes, the way a display list swaps two depths. Does nothing
+ * unless both nodes have entries. Entry positions are left alone, so a tie between the two resolves the
+ * same way afterwards as before.
+ */
+export declare function swapNodeOrderListEntries<Traits extends object = NodeTraits>(list: NodeOrderList<Traits>, nodeA: Readonly<Node<Traits>>, nodeB: Readonly<Node<Traits>>): void;
+//# sourceMappingURL=nodeOrderList.d.ts.map

package/dist/nodeOrderList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeOrderList.d.ts","sourceRoot":"","sources":["../src/nodeOrderList.ts"],"names":[],"mappings":"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"}

package/dist/nodeOrderList.js

@@ -0,0 +1,250 @@
+import { emitSignal } from '@flighthq/signals/contract';
+import { getNodeRuntime } from './node';
+/**
+ * Appends one entry to the list's valid window. Capacity past `entryCount` is reused, so a list
+ * refilled every frame allocates only while it is growing. This does not check whether `node` is
+ * already entered — it is the O(1) bulk-fill verb. Use setNodeOrderListEntry to re-key a node that may
+ * already be present; a node entered twice resolves to its last entry.
+ */
+export function addNodeOrderListEntry(list, node, sortKey) {
+    const entryCount = list.entryCount;
+    if (entryCount < list.nodes.length) {
+        list.nodes[entryCount] = node;
+        list.sortKeys[entryCount] = sortKey;
+    }
+    else {
+        list.nodes.push(node);
+        list.sortKeys.push(sortKey);
+    }
+    list.entryCount = entryCount + 1;
+}
+/**
+ * Reorders `target`'s children so the list's members sit in ascending sort-key order, and does nothing
+ * else. This owns order, never membership: members are permuted among the slots they already occupy, so
+ * a child the list does not name never moves, not by one index. Entries that are not currently children
+ * of `target` — including ones attached to a different parent — are ignored rather than attached, which
+ * makes the call a no-op once the caller has detached every member.
+ *
+ * Because slots are preserved rather than compacted, a foreign child sitting between two members stays
+ * between them; no sort key moves a member past it. Contiguity comes from parenting, relative order
+ * from the list.
+ *
+ * Children are written in place rather than routed through setNodeChildIndex: every member is already a
+ * child of `target`, so no parent pointer or parentReferenceId changes, and the whole permutation stamps
+ * `childrenId` once instead of once per moved node.
+ */
+export function applyNodeOrderList(target, list) {
+    const targetRuntime = getNodeRuntime(target);
+    const children = targetRuntime.children;
+    if (children === null || list.entryCount === 0)
+        return;
+    const listIndex = _listIndex;
+    const members = _members;
+    const slots = _slots;
+    listIndex.clear();
+    members.length = 0;
+    slots.length = 0;
+    // A node entered more than once resolves to its last entry, since the later set overwrites.
+    for (let i = 0; i < list.entryCount; i++)
+        listIndex.set(list.nodes[i], i);
+    for (let i = 0; i < children.length; i++) {
+        if (!listIndex.has(children[i]))
+            continue;
+        members.push(children[i]);
+        slots.push(i);
+    }
+    // Fewer than two members present cannot be a reordering, whatever their sort keys say.
+    if (members.length < 2) {
+        listIndex.clear();
+        members.length = 0;
+        return;
+    }
+    const sortKeys = list.sortKeys;
+    members.sort((a, b) => {
+        const ai = listIndex.get(a);
+        const bi = listIndex.get(b);
+        // Equal sort keys keep the order the entries were added in, so a tie is resolved by the list rather
+        // than by whatever order the children happened to already be in. Breaking the tie explicitly also
+        // frees the C port from needing its sort to be stable, and it is the mechanism the *Above/*Below
+        // verbs place with — they assign an equal key and rely on entry position to separate the two.
+        return sortKeys[ai] !== sortKeys[bi] ? sortKeys[ai] - sortKeys[bi] : ai - bi;
+    });
+    let moved = false;
+    for (let i = 0; i < slots.length; i++) {
+        const slot = slots[i];
+        if (children[slot] === members[i])
+            continue;
+        children[slot] = members[i];
+        moved = true;
+    }
+    // Released before the signal, so a handler that applies another list is not reading this call's
+    // scratch out from under it.
+    listIndex.clear();
+    members.length = 0;
+    if (!moved)
+        return;
+    targetRuntime.childrenId = (targetRuntime.childrenId + 1) >>> 0;
+    const targetSignals = targetRuntime.nodeSignals;
+    if (targetSignals !== null)
+        emitSignal(targetSignals.onChildrenOrderChanged);
+}
+/**
+ * Empties the valid window without releasing capacity, so the next fill reuses the arrays. Entries past
+ * `entryCount` keep their node references; use disposeNodeOrderList to drop them.
+ */
+export function clearNodeOrderList(list) {
+    list.entryCount = 0;
+}
+export function createNodeOrderList() {
+    return { entryCount: 0, nodes: [], sortKeys: [] };
+}
+/**
+ * Empties the list and releases its node references, so a long-lived list stops holding nodes reachable.
+ * The list stays usable; this is the teardown counterpart to clearNodeOrderList, which deliberately
+ * retains both capacity and the references past the window for reuse.
+ */
+export function disposeNodeOrderList(list) {
+    list.entryCount = 0;
+    list.nodes.length = 0;
+    list.sortKeys.length = 0;
+}
+/**
+ * Calls `callback` for each entry in the order the entries were added, which is not the order they
+ * resolve to. Stops early if `callback` returns `false`.
+ */
+export function forEachNodeOrderListEntry(list, callback) {
+    for (let i = 0; i < list.entryCount; i++) {
+        if (callback(list.nodes[i], list.sortKeys[i], i) === false)
+            return;
+    }
+}
+/**
+ * Returns the sort key `node` is entered with, or `null` when it has no entry. Null rather than -1
+ * because every finite number, negative included, is a legal sort key.
+ */
+export function getNodeOrderListEntrySortKey(list, node) {
+    const index = findNodeOrderListEntryIndex(list, node);
+    return index === -1 ? null : list.sortKeys[index];
+}
+export function hasNodeOrderListEntry(list, node) {
+    return findNodeOrderListEntryIndex(list, node) !== -1;
+}
+/**
+ * Removes `node`'s entry, returning whether one was found. Entries after it shift down rather than
+ * being back-filled from the end: entry position breaks ties between equal sort keys, so preserving it
+ * is part of the contract, not an implementation detail.
+ */
+export function removeNodeOrderListEntry(list, node) {
+    const index = findNodeOrderListEntryIndex(list, node);
+    if (index === -1)
+        return false;
+    removeNodeOrderListEntryAtIndex(list, index);
+    return true;
+}
+/**
+ * Enters `node` at `sortKey`, replacing its existing entry in place if it has one. This is the verb for
+ * incremental re-keying: unlike addNodeOrderListEntry it never grows the list with a second entry for
+ * the same node, at the cost of a scan.
+ */
+export function setNodeOrderListEntry(list, node, sortKey) {
+    const index = findNodeOrderListEntryIndex(list, node);
+    if (index === -1) {
+        addNodeOrderListEntry(list, node, sortKey);
+        return;
+    }
+    list.sortKeys[index] = sortKey;
+}
+/**
+ * Enters `node` so it resolves immediately above `target` — drawn after it, in front of it. Does
+ * nothing when `target` has no entry, since there is nothing to be above.
+ *
+ * Placement is exact rather than a midpoint between neighbouring keys: `node` takes `target`'s own sort
+ * key and its entry is positioned just after `target`'s, so the equal-key tie-break separates the two.
+ * That holds however tightly packed the surrounding keys are, and repeated placement never exhausts
+ * float precision the way bisection does.
+ */
+export function setNodeOrderListEntryAbove(list, node, target) {
+    insertNodeOrderListEntryBeside(list, node, target, 1);
+}
+/**
+ * Enters `node` so it resolves immediately below `target` — drawn before it, behind it. Does nothing
+ * when `target` has no entry. The mirror of setNodeOrderListEntryAbove, placing `node`'s entry just
+ * before `target`'s at the same sort key.
+ */
+export function setNodeOrderListEntryBelow(list, node, target) {
+    insertNodeOrderListEntryBeside(list, node, target, 0);
+}
+/**
+ * Refills the list from `source`'s current children, each entered at its own child index. This is the
+ * inverse of applyNodeOrderList: capture what is there, edit it with the *Above/*Below/swap verbs, then
+ * apply it back. Any previous contents are discarded.
+ */
+export function setNodeOrderListFromNodeChildren(list, source) {
+    list.entryCount = 0;
+    const children = getNodeRuntime(source).children;
+    if (children === null)
+        return;
+    for (let i = 0; i < children.length; i++) {
+        addNodeOrderListEntry(list, children[i], i);
+    }
+}
+/**
+ * Exchanges the sort keys of two entered nodes, the way a display list swaps two depths. Does nothing
+ * unless both nodes have entries. Entry positions are left alone, so a tie between the two resolves the
+ * same way afterwards as before.
+ */
+export function swapNodeOrderListEntries(list, nodeA, nodeB) {
+    const indexA = findNodeOrderListEntryIndex(list, nodeA);
+    if (indexA === -1)
+        return;
+    const indexB = findNodeOrderListEntryIndex(list, nodeB);
+    if (indexB === -1)
+        return;
+    const sortKeyA = list.sortKeys[indexA];
+    list.sortKeys[indexA] = list.sortKeys[indexB];
+    list.sortKeys[indexB] = sortKeyA;
+}
+function findNodeOrderListEntryIndex(list, node) {
+    // Scans backwards so a node entered more than once reports the entry that wins at apply time.
+    for (let i = list.entryCount - 1; i >= 0; i--) {
+        if (list.nodes[i] === node)
+            return i;
+    }
+    return -1;
+}
+// Shared by the Above (offset 1) and Below (offset 0) verbs: `node` takes `target`'s sort key and its
+// entry lands on the named side of `target`'s. An existing entry for `node` is removed first, so
+// re-placing a node already in the list moves it rather than duplicating it.
+function insertNodeOrderListEntryBeside(list, node, target, offset) {
+    if (node === target)
+        return;
+    const existing = findNodeOrderListEntryIndex(list, node);
+    if (existing !== -1)
+        removeNodeOrderListEntryAtIndex(list, existing);
+    const targetIndex = findNodeOrderListEntryIndex(list, target);
+    if (targetIndex === -1)
+        return;
+    const sortKey = list.sortKeys[targetIndex];
+    const at = targetIndex + offset;
+    addNodeOrderListEntry(list, node, sortKey);
+    for (let i = list.entryCount - 1; i > at; i--) {
+        list.nodes[i] = list.nodes[i - 1];
+        list.sortKeys[i] = list.sortKeys[i - 1];
+    }
+    list.nodes[at] = node;
+    list.sortKeys[at] = sortKey;
+}
+function removeNodeOrderListEntryAtIndex(list, index) {
+    const last = list.entryCount - 1;
+    for (let i = index; i < last; i++) {
+        list.nodes[i] = list.nodes[i + 1];
+        list.sortKeys[i] = list.sortKeys[i + 1];
+    }
+    list.entryCount = last;
+}
+// Scratch reused across applyNodeOrderList calls so a per-frame apply allocates nothing. Cleared on
+// every exit path, including before the order-changed signal fires, so a reentrant apply starts clean.
+const _listIndex = new Map();
+const _members = [];
+const _slots = [];
+//# sourceMappingURL=nodeOrderList.js.map

package/dist/nodeOrderList.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeOrderList.js","sourceRoot":"","sources":["../src/nodeOrderList.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flighthq/node",
-  "version": "0.3.0-next.1595.4d49b41",
+  "version": "0.3.0-next.1665.6235922",
   "repository": {
     "type": "git",
     "url": "https://github.com/flighthq/flight.git",
@@ -36,12 +36,12 @@
     "clean:dist": "tsx ../../scripts/clean-package-dist.ts"
   },
   "dependencies": {
-    "@flighthq/adjustments": "0.3.0-next.1595.4d49b41",
-    "@flighthq/entity": "0.3.0-next.1595.4d49b41",
-    "@flighthq/geometry": "0.3.0-next.1595.4d49b41",
-    "@flighthq/materials": "0.3.0-next.1595.4d49b41",
-    "@flighthq/signals": "0.3.0-next.1595.4d49b41",
-    "@flighthq/types": "0.3.0-next.1595.4d49b41"
+    "@flighthq/adjustments": "0.3.0-next.1665.6235922",
+    "@flighthq/entity": "0.3.0-next.1665.6235922",
+    "@flighthq/geometry": "0.3.0-next.1665.6235922",
+    "@flighthq/materials": "0.3.0-next.1665.6235922",
+    "@flighthq/signals": "0.3.0-next.1665.6235922",
+    "@flighthq/types": "0.3.0-next.1665.6235922"
   },
   "devDependencies": {
     "typescript": "^5.3.0"

package/src/nodeOrderList.test.ts

@@ -0,0 +1,617 @@
+import { connectSignal } from '@flighthq/signals/contract';
+import type { Node, NodeTraits } from '@flighthq/types/contract';
+import { NodeKind } from '@flighthq/types/contract';
+
+import { addNodeChild, removeNodeChild } from './hierarchy';
+import { createNode, enableNodeSignals, getNodeRuntime } from './node';
+import {
+  addNodeOrderListEntry,
+  applyNodeOrderList,
+  clearNodeOrderList,
+  createNodeOrderList,
+  disposeNodeOrderList,
+  forEachNodeOrderListEntry,
+  getNodeOrderListEntrySortKey,
+  hasNodeOrderListEntry,
+  removeNodeOrderListEntry,
+  setNodeOrderListEntry,
+  setNodeOrderListEntryAbove,
+  setNodeOrderListEntryBelow,
+  setNodeOrderListFromNodeChildren,
+  swapNodeOrderListEntries,
+} from './nodeOrderList';
+import { getNodeChildrenRevision } from './revision';
+
+let container: Node<NodeTraits>;
+let childA: Node<NodeTraits>;
+let childB: Node<NodeTraits>;
+let childC: Node<NodeTraits>;
+
+beforeEach(() => {
+  container = createNode(NodeKind);
+  childA = createNode(NodeKind);
+  childB = createNode(NodeKind);
+  childC = createNode(NodeKind);
+});
+
+function getChildren(source: Node) {
+  return getNodeRuntime(source).children as Node[];
+}
+
+function attachAll() {
+  addNodeChild(container, childA);
+  addNodeChild(container, childB);
+  addNodeChild(container, childC);
+}
+
+describe('addNodeOrderListEntry', () => {
+  it('appends entries into the valid window', () => {
+    const list = createNodeOrderList();
+
+    addNodeOrderListEntry(list, childA, 5);
+    addNodeOrderListEntry(list, childB, 2);
+
+    expect(list.entryCount).toBe(2);
+    expect(list.nodes[0]).toBe(childA);
+    expect(list.sortKeys[0]).toBe(5);
+    expect(list.nodes[1]).toBe(childB);
+    expect(list.sortKeys[1]).toBe(2);
+  });
+
+  it('reuses capacity after a clear rather than growing the arrays', () => {
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childA, 1);
+    addNodeOrderListEntry(list, childB, 2);
+    clearNodeOrderList(list);
+
+    addNodeOrderListEntry(list, childC, 3);
+
+    expect(list.entryCount).toBe(1);
+    expect(list.nodes.length).toBe(2);
+    expect(list.nodes[0]).toBe(childC);
+  });
+
+  it('allows a node to be entered twice', () => {
+    const list = createNodeOrderList();
+
+    addNodeOrderListEntry(list, childA, 1);
+    addNodeOrderListEntry(list, childA, 2);
+
+    expect(list.entryCount).toBe(2);
+  });
+});
+
+describe('applyNodeOrderList', () => {
+  it('permutes members into ascending sort-key order', () => {
+    attachAll();
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childA, 30);
+    addNodeOrderListEntry(list, childB, 20);
+    addNodeOrderListEntry(list, childC, 10);
+
+    applyNodeOrderList(container, list);
+
+    expect(getChildren(container)).toEqual([childC, childB, childA]);
+  });
+
+  it('never moves a child the list does not name', () => {
+    const foreign = createNode(NodeKind);
+    addNodeChild(container, childA);
+    addNodeChild(container, foreign);
+    addNodeChild(container, childB);
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childA, 20);
+    addNodeOrderListEntry(list, childB, 10);
+
+    applyNodeOrderList(container, list);
+
+    // 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]);
+  });
+
+  it('ignores entries that are not children of the target', () => {
+    const stranger = createNode(NodeKind);
+    addNodeChild(container, childA);
+    addNodeChild(container, childB);
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childA, 30);
+    addNodeOrderListEntry(list, stranger, 20);
+    addNodeOrderListEntry(list, childB, 10);
+
+    applyNodeOrderList(container, list);
+
+    expect(getChildren(container)).toEqual([childB, childA]);
+  });
+
+  it('ignores entries attached to a different parent', () => {
+    const other = createNode(NodeKind);
+    addNodeChild(container, childA);
+    addNodeChild(container, childB);
+    addNodeChild(other, childC);
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childA, 30);
+    addNodeOrderListEntry(list, childC, 20);
+    addNodeOrderListEntry(list, childB, 10);
+
+    applyNodeOrderList(container, list);
+
+    expect(getChildren(container)).toEqual([childB, childA]);
+    expect(getChildren(other)).toEqual([childC]);
+  });
+
+  it('is a no-op once every member has been removed', () => {
+    const foreign = createNode(NodeKind);
+    addNodeChild(container, childA);
+    addNodeChild(container, foreign);
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childA, 20);
+    addNodeOrderListEntry(list, childB, 10);
+    removeNodeChild(container, childA);
+    const revision = getNodeChildrenRevision(container);
+
+    applyNodeOrderList(container, list);
+
+    expect(getChildren(container)).toEqual([foreign]);
+    expect(getNodeChildrenRevision(container)).toBe(revision);
+  });
+
+  it('sorts the survivors when only some members were removed', () => {
+    attachAll();
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childA, 30);
+    addNodeOrderListEntry(list, childB, 20);
+    addNodeOrderListEntry(list, childC, 10);
+    removeNodeChild(container, childB);
+
+    applyNodeOrderList(container, list);
+
+    expect(getChildren(container)).toEqual([childC, childA]);
+  });
+
+  it('breaks equal sort keys by the order the entries were added', () => {
+    addNodeChild(container, childC);
+    addNodeChild(container, childB);
+    addNodeChild(container, childA);
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childA, 7);
+    addNodeOrderListEntry(list, childB, 7);
+    addNodeOrderListEntry(list, childC, 7);
+
+    applyNodeOrderList(container, list);
+
+    expect(getChildren(container)).toEqual([childA, childB, childC]);
+  });
+
+  it('resolves a node entered twice to its last entry', () => {
+    addNodeChild(container, childA);
+    addNodeChild(container, childB);
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childA, 10);
+    addNodeOrderListEntry(list, childB, 20);
+    addNodeOrderListEntry(list, childA, 30);
+
+    applyNodeOrderList(container, list);
+
+    expect(getChildren(container)).toEqual([childB, childA]);
+  });
+
+  it('is idempotent', () => {
+    addNodeChild(container, childA);
+    addNodeChild(container, childB);
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childA, 20);
+    addNodeOrderListEntry(list, childB, 10);
+    applyNodeOrderList(container, list);
+    const revision = getNodeChildrenRevision(container);
+
+    applyNodeOrderList(container, list);
+
+    expect(getChildren(container)).toEqual([childB, childA]);
+    expect(getNodeChildrenRevision(container)).toBe(revision);
+  });
+
+  it('advances the children revision once for the whole permutation', () => {
+    attachAll();
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childA, 30);
+    addNodeOrderListEntry(list, childB, 20);
+    addNodeOrderListEntry(list, childC, 10);
+    const revision = getNodeChildrenRevision(container);
+
+    applyNodeOrderList(container, list);
+
+    expect(getNodeChildrenRevision(container)).toBe((revision + 1) >>> 0);
+  });
+
+  it('calls onChildrenOrderChanged on the parent once', () => {
+    attachAll();
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childA, 30);
+    addNodeOrderListEntry(list, childB, 20);
+    addNodeOrderListEntry(list, childC, 10);
+    let calls = 0;
+    connectSignal(enableNodeSignals(container).onChildrenOrderChanged, () => {
+      calls++;
+    });
+
+    applyNodeOrderList(container, list);
+
+    expect(calls).toBe(1);
+  });
+
+  it('does not signal when nothing moved', () => {
+    addNodeChild(container, childA);
+    addNodeChild(container, childB);
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childA, 10);
+    addNodeOrderListEntry(list, childB, 20);
+    let calls = 0;
+    connectSignal(enableNodeSignals(container).onChildrenOrderChanged, () => {
+      calls++;
+    });
+
+    applyNodeOrderList(container, list);
+
+    expect(calls).toBe(0);
+  });
+
+  it('leaves an empty list alone', () => {
+    addNodeChild(container, childA);
+    addNodeChild(container, childB);
+    const revision = getNodeChildrenRevision(container);
+
+    applyNodeOrderList(container, createNodeOrderList());
+
+    expect(getChildren(container)).toEqual([childA, childB]);
+    expect(getNodeChildrenRevision(container)).toBe(revision);
+  });
+});
+
+describe('clearNodeOrderList', () => {
+  it('empties the valid window but keeps capacity', () => {
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childA, 1);
+
+    clearNodeOrderList(list);
+
+    expect(list.entryCount).toBe(0);
+    expect(list.nodes.length).toBe(1);
+  });
+});
+
+describe('createNodeOrderList', () => {
+  it('creates an empty list', () => {
+    const list = createNodeOrderList();
+
+    expect(list.entryCount).toBe(0);
+    expect(list.nodes).toEqual([]);
+    expect(list.sortKeys).toEqual([]);
+  });
+});
+
+describe('disposeNodeOrderList', () => {
+  it('releases the node references clear deliberately retains', () => {
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childA, 1);
+    addNodeOrderListEntry(list, childB, 2);
+
+    disposeNodeOrderList(list);
+
+    expect(list.entryCount).toBe(0);
+    expect(list.nodes.length).toBe(0);
+    expect(list.sortKeys.length).toBe(0);
+  });
+
+  it('leaves the list usable', () => {
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childA, 1);
+    disposeNodeOrderList(list);
+
+    addNodeOrderListEntry(list, childB, 4);
+
+    expect(list.entryCount).toBe(1);
+    expect(getNodeOrderListEntrySortKey(list, childB)).toBe(4);
+  });
+});
+
+describe('forEachNodeOrderListEntry', () => {
+  it('visits every entry in entry order', () => {
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childA, 30);
+    addNodeOrderListEntry(list, childB, 10);
+    const seen: [Node, number, number][] = [];
+
+    forEachNodeOrderListEntry(list, (node, sortKey, index) => {
+      seen.push([node, sortKey, index]);
+    });
+
+    expect(seen).toEqual([
+      [childA, 30, 0],
+      [childB, 10, 1],
+    ]);
+  });
+
+  it('stops early when the callback returns false', () => {
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childA, 1);
+    addNodeOrderListEntry(list, childB, 2);
+    let visits = 0;
+
+    forEachNodeOrderListEntry(list, () => {
+      visits++;
+      return false;
+    });
+
+    expect(visits).toBe(1);
+  });
+
+  it('does not visit entries past the valid window', () => {
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childA, 1);
+    addNodeOrderListEntry(list, childB, 2);
+    clearNodeOrderList(list);
+    addNodeOrderListEntry(list, childC, 3);
+    let visits = 0;
+
+    forEachNodeOrderListEntry(list, () => {
+      visits++;
+    });
+
+    expect(visits).toBe(1);
+  });
+});
+
+describe('getNodeOrderListEntrySortKey', () => {
+  it('returns the sort key a node is entered with', () => {
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childA, -4);
+
+    expect(getNodeOrderListEntrySortKey(list, childA)).toBe(-4);
+  });
+
+  it('returns null rather than -1 for a node with no entry', () => {
+    const list = createNodeOrderList();
+
+    expect(getNodeOrderListEntrySortKey(list, childA)).toBeNull();
+  });
+
+  it('reports the winning entry when a node is entered twice', () => {
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childA, 1);
+    addNodeOrderListEntry(list, childA, 9);
+
+    expect(getNodeOrderListEntrySortKey(list, childA)).toBe(9);
+  });
+});
+
+describe('hasNodeOrderListEntry', () => {
+  it('reports whether a node is entered', () => {
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childA, 1);
+
+    expect(hasNodeOrderListEntry(list, childA)).toBe(true);
+    expect(hasNodeOrderListEntry(list, childB)).toBe(false);
+  });
+
+  it('does not see entries past the valid window', () => {
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childA, 1);
+    clearNodeOrderList(list);
+
+    expect(hasNodeOrderListEntry(list, childA)).toBe(false);
+  });
+});
+
+describe('removeNodeOrderListEntry', () => {
+  it('removes the entry and reports that it did', () => {
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childA, 1);
+    addNodeOrderListEntry(list, childB, 2);
+
+    expect(removeNodeOrderListEntry(list, childA)).toBe(true);
+    expect(list.entryCount).toBe(1);
+    expect(hasNodeOrderListEntry(list, childA)).toBe(false);
+    expect(getNodeOrderListEntrySortKey(list, childB)).toBe(2);
+  });
+
+  it('reports false for a node with no entry', () => {
+    const list = createNodeOrderList();
+
+    expect(removeNodeOrderListEntry(list, childA)).toBe(false);
+  });
+
+  it('shifts the remaining entries down so tie order survives', () => {
+    attachAll();
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childA, 7);
+    addNodeOrderListEntry(list, childC, 7);
+    addNodeOrderListEntry(list, childB, 7);
+    removeNodeOrderListEntry(list, childA);
+
+    applyNodeOrderList(container, list);
+
+    // 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]);
+  });
+});
+
+describe('setNodeOrderListEntry', () => {
+  it('enters a node that has no entry', () => {
+    const list = createNodeOrderList();
+
+    setNodeOrderListEntry(list, childA, 3);
+
+    expect(list.entryCount).toBe(1);
+    expect(getNodeOrderListEntrySortKey(list, childA)).toBe(3);
+  });
+
+  it('re-keys in place rather than adding a second entry', () => {
+    const list = createNodeOrderList();
+    setNodeOrderListEntry(list, childA, 3);
+
+    setNodeOrderListEntry(list, childA, 8);
+
+    expect(list.entryCount).toBe(1);
+    expect(getNodeOrderListEntrySortKey(list, childA)).toBe(8);
+  });
+});
+
+describe('setNodeOrderListEntryAbove', () => {
+  it('places a node immediately above the target', () => {
+    attachAll();
+    const list = createNodeOrderList();
+    setNodeOrderListFromNodeChildren(list, container);
+
+    setNodeOrderListEntryAbove(list, childA, childC);
+    applyNodeOrderList(container, list);
+
+    expect(getChildren(container)).toEqual([childB, childC, childA]);
+  });
+
+  it('places between neighbours whose keys leave no gap', () => {
+    attachAll();
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childB, 5);
+    addNodeOrderListEntry(list, childC, 6);
+
+    setNodeOrderListEntryAbove(list, childA, childB);
+    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]);
+  });
+
+  it('moves a node that is already entered rather than duplicating it', () => {
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childA, 1);
+    addNodeOrderListEntry(list, childC, 9);
+
+    setNodeOrderListEntryAbove(list, childA, childC);
+
+    expect(list.entryCount).toBe(2);
+    expect(getNodeOrderListEntrySortKey(list, childA)).toBe(9);
+  });
+
+  it('does nothing when the target has no entry', () => {
+    const list = createNodeOrderList();
+
+    setNodeOrderListEntryAbove(list, childA, childC);
+
+    expect(list.entryCount).toBe(0);
+  });
+
+  it('does nothing when the node is its own target', () => {
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childA, 4);
+
+    setNodeOrderListEntryAbove(list, childA, childA);
+
+    expect(list.entryCount).toBe(1);
+    expect(getNodeOrderListEntrySortKey(list, childA)).toBe(4);
+  });
+});
+
+describe('setNodeOrderListEntryBelow', () => {
+  it('places a node immediately below the target', () => {
+    attachAll();
+    const list = createNodeOrderList();
+    setNodeOrderListFromNodeChildren(list, container);
+
+    setNodeOrderListEntryBelow(list, childA, childC);
+    applyNodeOrderList(container, list);
+
+    expect(getChildren(container)).toEqual([childB, childA, childC]);
+  });
+
+  it('places between neighbours whose keys leave no gap', () => {
+    attachAll();
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childB, 5);
+    addNodeOrderListEntry(list, childC, 6);
+
+    setNodeOrderListEntryBelow(list, childA, childC);
+    applyNodeOrderList(container, list);
+
+    expect(getChildren(container)).toEqual([childB, childA, childC]);
+  });
+
+  it('does nothing when the target has no entry', () => {
+    const list = createNodeOrderList();
+
+    setNodeOrderListEntryBelow(list, childA, childC);
+
+    expect(list.entryCount).toBe(0);
+  });
+});
+
+describe('setNodeOrderListFromNodeChildren', () => {
+  it('enters every child at its own index', () => {
+    attachAll();
+    const list = createNodeOrderList();
+
+    setNodeOrderListFromNodeChildren(list, container);
+
+    expect(list.entryCount).toBe(3);
+    expect(getNodeOrderListEntrySortKey(list, childA)).toBe(0);
+    expect(getNodeOrderListEntrySortKey(list, childB)).toBe(1);
+    expect(getNodeOrderListEntrySortKey(list, childC)).toBe(2);
+  });
+
+  it('round-trips through apply without moving anything', () => {
+    attachAll();
+    const list = createNodeOrderList();
+    setNodeOrderListFromNodeChildren(list, container);
+    const revision = getNodeChildrenRevision(container);
+
+    applyNodeOrderList(container, list);
+
+    expect(getChildren(container)).toEqual([childA, childB, childC]);
+    expect(getNodeChildrenRevision(container)).toBe(revision);
+  });
+
+  it('discards any previous contents', () => {
+    const stranger = createNode(NodeKind);
+    addNodeChild(container, childA);
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, stranger, 99);
+
+    setNodeOrderListFromNodeChildren(list, container);
+
+    expect(list.entryCount).toBe(1);
+    expect(hasNodeOrderListEntry(list, stranger)).toBe(false);
+  });
+
+  it('empties the list for a node with no children', () => {
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childA, 1);
+
+    setNodeOrderListFromNodeChildren(list, childB);
+
+    expect(list.entryCount).toBe(0);
+  });
+});
+
+describe('swapNodeOrderListEntries', () => {
+  it('exchanges the sort keys of two entered nodes', () => {
+    attachAll();
+    const list = createNodeOrderList();
+    setNodeOrderListFromNodeChildren(list, container);
+
+    swapNodeOrderListEntries(list, childA, childC);
+    applyNodeOrderList(container, list);
+
+    expect(getChildren(container)).toEqual([childC, childB, childA]);
+  });
+
+  it('does nothing unless both nodes are entered', () => {
+    const list = createNodeOrderList();
+    addNodeOrderListEntry(list, childA, 1);
+
+    swapNodeOrderListEntries(list, childA, childB);
+
+    expect(getNodeOrderListEntrySortKey(list, childA)).toBe(1);
+  });
+});