@flighthq/skeleton2d 0.5.1-next.973.788d3d7 → 0.6.0

package/src/enableSkeleton2DGuards.test.ts

@@ -1,28 +1,29 @@
-import { clearLogOnceKeys, setLogSink } from '@flighthq/log/contract';
-import type { LogEntry } from '@flighthq/types/contract';
+import type { LogState } from '@flighthq/log/contract';
+import { createLogState, setLogSink } from '@flighthq/log/contract';
+import type { LogEntry } from '@flighthq/log/contract';
 
-import { disableSkeleton2DGuards, enableSkeleton2DGuards } from './enableSkeleton2DGuards';
-import { reportSkeleton2DCoercedInterpolation, reportSkeleton2DDeformLengthMismatch } from './skeleton2dGuards';
+import { disableSkeleton2DGuards, enableSkeleton2DGuards } from './enableSkeleton2DGuards.ts';
+import { reportSkeleton2DCoercedInterpolation, reportSkeleton2DDeformLengthMismatch } from './skeleton2dGuards.ts';
 
-// Each case uses its own subject string. `logOnce` keys are process-wide with no reset, which is the
-// behaviour a shipped app wants — one warning per subject, not one per frame — but it means two cases
-// sharing a subject would have the second silently suppressed by the first.
+// Each case uses its own subject string. `logOnce` keys last for the LogState's lifetime, which is the
+// behaviour a shipped app wants — one warning per subject, not one per frame. Every case gets a fresh
+// state here, so no case can be silently suppressed by another.
 const entries: LogEntry[] = [];
+let logState: LogState;
 
 beforeEach(() => {
-  clearLogOnceKeys();
+  logState = createLogState();
   entries.length = 0;
-  setLogSink((entry) => void entries.push(entry));
+  setLogSink(logState, (entry) => void entries.push(entry));
 });
 
 afterEach(() => {
   disableSkeleton2DGuards();
-  setLogSink(null);
 });
 
 describe('disableSkeleton2DGuards', () => {
   it('silences both cases again', () => {
-    enableSkeleton2DGuards();
+    enableSkeleton2DGuards(logState, 0);
     disableSkeleton2DGuards();
 
     reportSkeleton2DCoercedInterpolation('DisabledChannel', 'Linear', 'Step');
@@ -40,7 +41,7 @@ describe('enableSkeleton2DGuards', () => {
   });
 
   it('names what was stated and what actually happens to a coerced channel', () => {
-    enableSkeleton2DGuards();
+    enableSkeleton2DGuards(logState, 0);
 
     reportSkeleton2DCoercedInterpolation('StatedAndApplied', 'Linear', 'Step');
 
@@ -52,7 +53,7 @@ describe('enableSkeleton2DGuards', () => {
   });
 
   it('reports both lengths on a deform mismatch, and why nothing was applied', () => {
-    enableSkeleton2DGuards();
+    enableSkeleton2DGuards(logState, 0);
 
     reportSkeleton2DDeformLengthMismatch('BothLengths', 6, 8);
 
@@ -63,7 +64,7 @@ describe('enableSkeleton2DGuards', () => {
   });
 
   it('keys the coercion message per subject, so two families both get heard', () => {
-    enableSkeleton2DGuards();
+    enableSkeleton2DGuards(logState, 0);
 
     reportSkeleton2DCoercedInterpolation('PerSubjectOne', 'Linear', 'Step');
     reportSkeleton2DCoercedInterpolation('PerSubjectTwo', 'Linear', 'Step');
@@ -74,8 +75,8 @@ describe('enableSkeleton2DGuards', () => {
   });
 
   it('installs one guard however many times it is enabled', () => {
-    enableSkeleton2DGuards();
-    enableSkeleton2DGuards();
+    enableSkeleton2DGuards(logState, 0);
+    enableSkeleton2DGuards(logState, 0);
 
     reportSkeleton2DDeformLengthMismatch('EnabledTwice', 6, 8);
 

package/src/explainSkeleton2DChannel.test.ts

@@ -1,7 +1,10 @@
 import { createAnimationChannel, createAnimationTrack } from '@flighthq/animation/contract';
-import type { AnimationChannel, AnimationInterpolation } from '@flighthq/types/contract';
+import type { AnimationChannel, AnimationInterpolation } from '@flighthq/animation/contract';
 
-import { explainSkeleton2DChannelInterpolation, isSkeleton2DSteppedChannelSubject } from './explainSkeleton2DChannel';
+import {
+  explainSkeleton2DChannelInterpolation,
+  isSkeleton2DSteppedChannelSubject,
+} from './explainSkeleton2DChannel.ts';
 
 describe('explainSkeleton2DChannelInterpolation', () => {
   it('reports the override a non-step attachment channel will receive', () => {

package/src/explainSkeleton2DDeformLength.test.ts

@@ -1,8 +1,8 @@
-import type { Skin2D } from '@flighthq/types/contract';
 import { describe, expect, it } from 'vitest';
 
-import { explainSkeleton2DDeformLength } from './explainSkeleton2DDeformLength';
-import { createSkin2D } from './skin2D';
+import type { Skin2D } from './contract.skeleton2d-types.ts';
+import { explainSkeleton2DDeformLength } from './explainSkeleton2DDeformLength.ts';
+import { createSkin2D } from './skin2D.ts';
 
 // One vertex bound to two bones: eight floats of influence data, so the deform stream it parallels is
 // FOUR floats — twice what a per-vertex reading predicts.

package/src/ikConstraint2D.test.ts

@@ -1,16 +1,16 @@
-import { allocateEntity, finishEntity } from '@flighthq/entity/contract';
-import type { Bone2D, Skeleton2D, Skeleton2DIkConstraint } from '@flighthq/types/contract';
-import { Skeleton2DConstraintKind, TransformMode2D } from '@flighthq/types/contract';
+import { allocateEntity } from '@flighthq/entity/contract';
 import { afterEach, describe, expect, it } from 'vitest';
 
-import { registerSkeleton2DIkConstraintSolver, solveSkeleton2DIkConstraint } from './ikConstraint2D';
-import { computeSkeleton2DWorldTransforms, createSkeleton2D } from './skeleton2d';
+import type { Bone2D, Skeleton2D, Skeleton2DIkConstraint } from './contract.skeleton2d-types.ts';
+import { Skeleton2DConstraintKind, TransformMode2D } from './contract.skeleton2d-types.ts';
+import { registerSkeleton2DIkConstraintSolver, solveSkeleton2DIkConstraint } from './ikConstraint2D.ts';
+import { computeSkeleton2DWorldTransforms, createSkeleton2D } from './skeleton2d.ts';
 import {
   getSkeleton2DConstraintSolver,
   registerSkeleton2DConstraintSolver,
   solveSkeleton2DConstraints,
   unregisterSkeleton2DConstraintSolver,
-} from './skeleton2dConstraint';
+} from './skeleton2dConstraint.ts';
 
 function makeBone(overrides: Partial<Bone2D> = {}): Bone2D {
   return {
@@ -39,7 +39,7 @@ function ik(overrides: Partial<Skeleton2DIkConstraint> = {}): Skeleton2DIkConstr
   out.stretch = false;
   out.targetBoneIndex = 1;
   Object.assign(out, overrides);
-  return finishEntity(out) as Skeleton2DIkConstraint;
+  return out as Skeleton2DIkConstraint;
 }
 
 // The world position of a bone's TIP — its origin plus its length along its own x axis. That is the point

package/src/pathConstraint2D.test.ts

@@ -1,23 +1,29 @@
-import { allocateEntity, finishEntity } from '@flighthq/entity/contract';
-import type { Bone2D, PathAttachment2D, Skeleton2D, Skeleton2DPathConstraint, Slot2D } from '@flighthq/types/contract';
+import { allocateEntity } from '@flighthq/entity/contract';
+import { PathCommand } from '@flighthq/path/contract';
+import { afterEach, describe, expect, it } from 'vitest';
+
+import type {
+  Bone2D,
+  PathAttachment2D,
+  Skeleton2D,
+  Skeleton2DPathConstraint,
+  Slot2D,
+} from './contract.skeleton2d-types.ts';
 import {
   PathAttachment2DKind,
-  PathCommand,
   Skeleton2DConstraintKind,
   Skeleton2DPathPositionMode,
   Skeleton2DPathRotateMode,
   Skeleton2DPathSpacingMode,
   TransformMode2D,
-} from '@flighthq/types/contract';
-import { afterEach, describe, expect, it } from 'vitest';
-
-import { registerSkeleton2DPathConstraintSolver, solveSkeleton2DPathConstraint } from './pathConstraint2D';
-import { computeSkeleton2DWorldTransforms, createSkeleton2D } from './skeleton2d';
+} from './contract.skeleton2d-types.ts';
+import { registerSkeleton2DPathConstraintSolver, solveSkeleton2DPathConstraint } from './pathConstraint2D.ts';
+import { computeSkeleton2DWorldTransforms, createSkeleton2D } from './skeleton2d.ts';
 import {
   getSkeleton2DConstraintSolver,
   registerSkeleton2DConstraintSolver,
   unregisterSkeleton2DConstraintSolver,
-} from './skeleton2dConstraint';
+} from './skeleton2dConstraint.ts';
 
 function makeBone(overrides: Partial<Bone2D> = {}): Bone2D {
   return {
@@ -46,7 +52,7 @@ function straightPath(): PathAttachment2D {
   out.skin = null;
   out.vertices = new Float32Array([0, 0, 100, 0]);
   out.winding = 'nonZero' as const;
-  return finishEntity(out) as PathAttachment2D;
+  return out as PathAttachment2D;
 }
 
 function pathSlot(attachment: PathAttachment2D | null): Slot2D {
@@ -68,7 +74,7 @@ function constraint(overrides: Partial<Skeleton2DPathConstraint> = {}): Skeleton
   out.spacingMode = Skeleton2DPathSpacingMode.Fixed;
   out.targetSlotIndex = 0;
   Object.assign(out, overrides);
-  return finishEntity(out) as Skeleton2DPathConstraint;
+  return out as Skeleton2DPathConstraint;
 }
 
 // Bone 0 carries the path slot; bones 1..n are the chain laid along it.
@@ -211,7 +217,7 @@ describe('solveSkeleton2DPathConstraint', () => {
         out.skin = null;
         out.vertices = new Float32Array([0, 0, 0, 100]);
         out.winding = 'nonZero' as const;
-        return finishEntity(out) as PathAttachment2D;
+        return out as PathAttachment2D;
       })(),
     );
     skeleton.bones[1].x = 40;
@@ -236,7 +242,7 @@ describe('solveSkeleton2DPathConstraint', () => {
         out.skin = null;
         out.vertices = new Float32Array([0, 0, 0, 100]);
         out.winding = 'nonZero' as const;
-        return finishEntity(out) as PathAttachment2D;
+        return out as PathAttachment2D;
       })(),
     );
 
@@ -257,7 +263,7 @@ describe('solveSkeleton2DPathConstraint', () => {
         out.skin = null;
         out.vertices = new Float32Array([0, 0, 50, 0, 50, 50]);
         out.winding = 'nonZero' as const;
-        return finishEntity(out) as PathAttachment2D;
+        return out as PathAttachment2D;
       })(),
     );
 

package/src/pointAttachment2D.test.ts

@@ -1,13 +1,13 @@
-import { allocateEntity, finishEntity } from '@flighthq/entity/contract';
-import type { Bone2D, PointAttachment2D } from '@flighthq/types/contract';
-import { PointAttachment2DKind, TransformMode2D } from '@flighthq/types/contract';
+import { allocateEntity } from '@flighthq/entity/contract';
 import { describe, expect, it } from 'vitest';
 
+import type { Bone2D, PointAttachment2D } from './contract.skeleton2d-types.ts';
+import { PointAttachment2DKind, TransformMode2D } from './contract.skeleton2d-types.ts';
 import {
   computeSkeleton2DPointAttachmentPosition,
   computeSkeleton2DPointAttachmentRotation,
-} from './pointAttachment2D';
-import { computeSkeleton2DWorldTransforms, createSkeleton2D } from './skeleton2d';
+} from './pointAttachment2D.ts';
+import { computeSkeleton2DWorldTransforms, createSkeleton2D } from './skeleton2d.ts';
 
 function makeBone(overrides: Partial<Bone2D> = {}): Bone2D {
   return {
@@ -32,7 +32,7 @@ function point(x: number, y: number, rotation: number): PointAttachment2D {
   out.rotation = rotation;
   out.x = x;
   out.y = y;
-  return finishEntity(out) as PointAttachment2D;
+  return out as PointAttachment2D;
 }
 
 describe('computeSkeleton2DPointAttachmentPosition', () => {

package/src/regionAttachment2D.test.ts

@@ -1,10 +1,10 @@
-import { allocateEntity, finishEntity } from '@flighthq/entity/contract';
-import type { Bone2D, RegionAttachment2D } from '@flighthq/types/contract';
-import { RegionAttachment2DKind, TransformMode2D } from '@flighthq/types/contract';
+import { allocateEntity } from '@flighthq/entity/contract';
 import { describe, expect, it } from 'vitest';
 
-import { computeSkeleton2DRegionAttachmentVertices } from './regionAttachment2D';
-import { computeSkeleton2DWorldTransforms, createSkeleton2D } from './skeleton2d';
+import type { Bone2D, RegionAttachment2D } from './contract.skeleton2d-types.ts';
+import { RegionAttachment2DKind, TransformMode2D } from './contract.skeleton2d-types.ts';
+import { computeSkeleton2DRegionAttachmentVertices } from './regionAttachment2D.ts';
+import { computeSkeleton2DWorldTransforms, createSkeleton2D } from './skeleton2d.ts';
 
 function makeBone(overrides: Partial<Bone2D> = {}): Bone2D {
   return {
@@ -34,7 +34,7 @@ function region(overrides: Partial<RegionAttachment2D> = {}): RegionAttachment2D
   out.x = 0;
   out.y = 0;
   Object.assign(out, overrides);
-  return finishEntity(out) as RegionAttachment2D;
+  return out as RegionAttachment2D;
 }
 
 describe('computeSkeleton2DRegionAttachmentVertices', () => {

package/src/skeleton2d.test.ts

@@ -1,9 +1,9 @@
-import { allocateEntity, finishEntity } from '@flighthq/entity/contract';
+import { allocateEntity } from '@flighthq/entity/contract';
 import { createMatrix } from '@flighthq/geometry/contract';
-import type { Bone2D, RegionAttachment2D, Slot2D } from '@flighthq/types/contract';
-import { RegionAttachment2DKind, TransformMode2D } from '@flighthq/types/contract';
 import { describe, expect, it } from 'vitest';
 
+import type { Bone2D, RegionAttachment2D, Slot2D } from './contract.skeleton2d-types.ts';
+import { RegionAttachment2DKind, TransformMode2D } from './contract.skeleton2d-types.ts';
 import {
   cloneSkeleton2D,
   computeSkeleton2DBoneMatrices,
@@ -20,7 +20,7 @@ import {
   setSkeleton2DBindPose,
   setSkeleton2DSkin,
   validateSkeleton2D,
-} from './skeleton2d';
+} from './skeleton2d.ts';
 
 function makeBone(overrides: Partial<Bone2D> = {}): Bone2D {
   return {
@@ -514,7 +514,7 @@ function testRegion(name: string): RegionAttachment2D {
   out.width = 0;
   out.x = 0;
   out.y = 0;
-  return finishEntity(out) as RegionAttachment2D;
+  return out as RegionAttachment2D;
 }
 describe('validateSkeleton2D', () => {
   it('returns null for a valid parent-before-child skeleton', () => {

package/src/skeleton2dAnimationTarget.test.ts

@@ -1,15 +1,15 @@
 import { createAnimationChannel, createAnimationClip, createAnimationTrack } from '@flighthq/animation/contract';
-import type { Bone2D, Skeleton2D } from '@flighthq/types/contract';
+import { describe, expect, it } from 'vitest';
+
+import { applyAnimationClipToSkeleton2D } from './applyAnimationClipToSkeleton2D.ts';
+import type { Bone2D, Skeleton2D } from './contract.skeleton2d-types.ts';
 import {
   Skeleton2DAnimationPath,
   Skeleton2DAnimationTargetKind,
   Skeleton2DSlotAnimationPath,
   TransformMode2D,
-} from '@flighthq/types/contract';
-import { describe, expect, it } from 'vitest';
-
-import { applyAnimationClipToSkeleton2D } from './applyAnimationClipToSkeleton2D';
-import { cloneSkeleton2D, createSkeleton2D } from './skeleton2d';
+} from './contract.skeleton2d-types.ts';
+import { cloneSkeleton2D, createSkeleton2D } from './skeleton2d.ts';
 import {
   createSkeleton2DBoneAnimationTarget,
   createSkeleton2DSlotAnimationTarget,
@@ -20,7 +20,7 @@ import {
   initializeSkeleton2DSlotAnimationTarget,
   registerSkeleton2DAnimationTargetBinder,
   unregisterSkeleton2DAnimationTargetBinder,
-} from './skeleton2dAnimationTarget';
+} from './skeleton2dAnimationTarget.ts';
 
 describe('createSkeleton2DBoneAnimationTarget', () => {
   it('stamps the bone kind, which is what the binder dispatches on', () => {

package/src/skeleton2dConstraint.test.ts

@@ -1,15 +1,15 @@
-import { allocateEntity, finishEntity } from '@flighthq/entity/contract';
-import type { Bone2D, Skeleton2DConstraint } from '@flighthq/types/contract';
-import { Skeleton2DConstraintKind, TransformMode2D } from '@flighthq/types/contract';
+import { allocateEntity } from '@flighthq/entity/contract';
 import { afterEach, describe, expect, it } from 'vitest';
 
-import { computeSkeleton2DWorldTransforms, createSkeleton2D } from './skeleton2d';
+import type { Bone2D, Skeleton2DConstraint } from './contract.skeleton2d-types.ts';
+import { Skeleton2DConstraintKind, TransformMode2D } from './contract.skeleton2d-types.ts';
+import { computeSkeleton2DWorldTransforms, createSkeleton2D } from './skeleton2d.ts';
 import {
   getSkeleton2DConstraintSolver,
   registerSkeleton2DConstraintSolver,
   solveSkeleton2DConstraints,
   unregisterSkeleton2DConstraintSolver,
-} from './skeleton2dConstraint';
+} from './skeleton2dConstraint.ts';
 
 function makeBone(overrides: Partial<Bone2D> = {}): Bone2D {
   return {
@@ -32,7 +32,7 @@ function constraint(kind: string): Skeleton2DConstraint {
   const out = allocateEntity<Skeleton2DConstraint>();
   out.kind = kind;
   out.mix = 1;
-  return finishEntity(out) as Skeleton2DConstraint;
+  return out as Skeleton2DConstraint;
 }
 
 // The registry is a module GLOBAL, deliberately: last-write-wins is what lets a caller replace a built-in
@@ -109,7 +109,7 @@ describe('solveSkeleton2DConstraints', () => {
       out.kind = 'acme.Rope';
       out.mix = 0.25;
       out.slack = 3;
-      return finishEntity(out) as Skeleton2DConstraint;
+      return out as Skeleton2DConstraint;
     })();
 
     solveSkeleton2DConstraints(skeleton, [rope]);

package/src/skeleton2dDrawOrderTarget.test.ts

@@ -1,4 +1,5 @@
 import { createAnimationChannel, createAnimationTrack } from '@flighthq/animation/contract';
+import type { AnimationChannel, AnimationInterpolation } from '@flighthq/animation/contract';
 import {
   addNodeChild,
   applyNodeOrderList,
@@ -6,17 +7,17 @@ import {
   createNodeOrderList,
   getNodeChildAt,
 } from '@flighthq/node/contract';
-import type { AnimationChannel, AnimationInterpolation, Node, NodeOrderList } from '@flighthq/types/contract';
+import type { Node, NodeOrderList } from '@flighthq/node/contract';
 
-import { getSkeleton2DAnimationTargetBinder } from './skeleton2dAnimationTarget';
+import { getSkeleton2DAnimationTargetBinder } from './skeleton2dAnimationTarget.ts';
 import {
   createSkeleton2DDrawOrderAnimationTarget,
   createSkeleton2DDrawOrderChannel,
   initializeSkeleton2DDrawOrderAnimationTarget,
   registerSkeleton2DDrawOrderAnimationBinder,
   unregisterSkeleton2DDrawOrderAnimationBinder,
-} from './skeleton2dDrawOrderTarget';
-import { setSkeleton2DCoercedInterpolationGuard } from './skeleton2dGuards';
+} from './skeleton2dDrawOrderTarget.ts';
+import { setSkeleton2DCoercedInterpolationGuard } from './skeleton2dGuards.ts';
 
 afterEach(() => {
   unregisterSkeleton2DDrawOrderAnimationBinder();

package/src/skeleton2dGuards.test.ts

@@ -1,11 +1,10 @@
-import type { Skeleton2DCoercedInterpolation, Skeleton2DDeformLengthMismatch } from '@flighthq/types/contract';
-
+import type { Skeleton2DCoercedInterpolation, Skeleton2DDeformLengthMismatch } from './contract.skeleton2d-types.ts';
 import {
   reportSkeleton2DCoercedInterpolation,
   reportSkeleton2DDeformLengthMismatch,
   setSkeleton2DCoercedInterpolationGuard,
   setSkeleton2DDeformLengthGuard,
-} from './skeleton2dGuards';
+} from './skeleton2dGuards.ts';
 
 afterEach(() => {
   setSkeleton2DCoercedInterpolationGuard(null);

package/src/skin2D.test.ts

@@ -1,6 +1,6 @@
-import { EntityRuntimeKey } from '@flighthq/types/contract';
+import { EntityRuntimeKey } from '@flighthq/entity/contract';
 
-import { createSkin2D, initializeSkin2D } from './skin2D';
+import { createSkin2D, initializeSkin2D } from './skin2D.ts';
 
 describe('createSkin2D', () => {
   it('adopts the streams it is given rather than copying them', () => {

package/src/skinAttachment2DPoints.test.ts

@@ -1,11 +1,11 @@
-import type { Bone2D, Skin2D } from '@flighthq/types/contract';
-import { TransformMode2D } from '@flighthq/types/contract';
 import { describe, expect, it } from 'vitest';
 
-import { computeSkeleton2DWorldTransforms, createSkeleton2D } from './skeleton2d';
-import { setSkeleton2DDeformLengthGuard } from './skeleton2dGuards';
-import { createSkin2D } from './skin2D';
-import { skinSkeleton2DAttachmentPoints } from './skinAttachment2DPoints';
+import type { Bone2D, Skin2D } from './contract.skeleton2d-types.ts';
+import { TransformMode2D } from './contract.skeleton2d-types.ts';
+import { computeSkeleton2DWorldTransforms, createSkeleton2D } from './skeleton2d.ts';
+import { setSkeleton2DDeformLengthGuard } from './skeleton2dGuards.ts';
+import { createSkin2D } from './skin2D.ts';
+import { skinSkeleton2DAttachmentPoints } from './skinAttachment2DPoints.ts';
 
 function makeBone(overrides: Partial<Bone2D> = {}): Bone2D {
   return {

package/src/slotDeform2D.test.ts

@@ -1,10 +1,10 @@
-import { allocateEntity, finishEntity } from '@flighthq/entity/contract';
-import type { Attachment2D, MeshAttachment2D, Skin2D, Slot2D } from '@flighthq/types/contract';
-import { MeshAttachment2DKind } from '@flighthq/types/contract';
+import { allocateEntity } from '@flighthq/entity/contract';
 import { describe, expect, it } from 'vitest';
 
-import { createSkin2D } from './skin2D';
-import { getSkeleton2DSlotDeformOffsets, setSkeleton2DSlotDeform } from './slotDeform2D';
+import type { Attachment2D, MeshAttachment2D, Skin2D, Slot2D } from './contract.skeleton2d-types.ts';
+import { MeshAttachment2DKind } from './contract.skeleton2d-types.ts';
+import { createSkin2D } from './skin2D.ts';
+import { getSkeleton2DSlotDeformOffsets, setSkeleton2DSlotDeform } from './slotDeform2D.ts';
 
 function slot(attachment: Attachment2D | null): Slot2D {
   return { attachment, boneIndex: 0, color: 0xffffffff, name: 's' };
@@ -19,7 +19,7 @@ function mesh(pointCount: number): MeshAttachment2D {
   out.uvs = new Float32Array(pointCount * 2);
   out.vertexCount = pointCount;
   out.vertices = null;
-  return finishEntity(out) as MeshAttachment2D;
+  return out as MeshAttachment2D;
 }
 
 describe('getSkeleton2DSlotDeformOffsets', () => {

package/src/transformConstraint2D.test.ts

@@ -1,18 +1,18 @@
-import { allocateEntity, finishEntity } from '@flighthq/entity/contract';
-import type { Bone2D, Skeleton2DTransformConstraint } from '@flighthq/types/contract';
-import { Skeleton2DConstraintKind, TransformMode2D } from '@flighthq/types/contract';
+import { allocateEntity } from '@flighthq/entity/contract';
 import { afterEach, describe, expect, it } from 'vitest';
 
-import { computeSkeleton2DWorldTransforms, createSkeleton2D } from './skeleton2d';
+import type { Bone2D, Skeleton2DTransformConstraint } from './contract.skeleton2d-types.ts';
+import { Skeleton2DConstraintKind, TransformMode2D } from './contract.skeleton2d-types.ts';
+import { computeSkeleton2DWorldTransforms, createSkeleton2D } from './skeleton2d.ts';
 import {
   getSkeleton2DConstraintSolver,
   registerSkeleton2DConstraintSolver,
   unregisterSkeleton2DConstraintSolver,
-} from './skeleton2dConstraint';
+} from './skeleton2dConstraint.ts';
 import {
   registerSkeleton2DTransformConstraintSolver,
   solveSkeleton2DTransformConstraint,
-} from './transformConstraint2D';
+} from './transformConstraint2D.ts';
 
 function makeBone(overrides: Partial<Bone2D> = {}): Bone2D {
   return {
@@ -51,7 +51,7 @@ function transform(overrides: Partial<Skeleton2DTransformConstraint> = {}): Skel
   out.offsetY = 0;
   out.targetBoneIndex = 1;
   Object.assign(out, overrides);
-  return finishEntity(out) as Skeleton2DTransformConstraint;
+  return out as Skeleton2DTransformConstraint;
 }
 
 // This file registers a built-in solver into a module-global registry, so it restores whatever it found