@flighthq/skeleton2d 0.3.0-next.906.07cea63 → 0.3.1-next.209.43ef1bc

package/dist/applyAnimationClipToSkeleton2D.d.ts

@@ -1,3 +1,3 @@
 import type { AnimationClip, Skeleton2D } from '@flighthq/types/contract';
-export declare function applyAnimationClipToSkeleton2D(clip: Readonly<AnimationClip>, skeleton: Skeleton2D, time: number): void;
+export declare function applyAnimationClipToSkeleton2D(clip: Readonly<AnimationClip>, setup: Readonly<Skeleton2D>, pose: Skeleton2D, time: number): void;
 //# sourceMappingURL=applyAnimationClipToSkeleton2D.d.ts.map

package/dist/applyAnimationClipToSkeleton2D.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"applyAnimationClipToSkeleton2D.d.ts","sourceRoot":"","sources":["../src/applyAnimationClipToSkeleton2D.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAA6B,MAAM,0BAA0B,CAAC;AAUrG,wBAAgB,8BAA8B,CAC5C,IAAI,EAAE,QAAQ,CAAC,aAAa,CAAC,EAC7B,QAAQ,EAAE,UAAU,EACpB,IAAI,EAAE,MAAM,GACX,IAAI,CA+BN"}
+{"version":3,"file":"applyAnimationClipToSkeleton2D.d.ts","sourceRoot":"","sources":["../src/applyAnimationClipToSkeleton2D.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAA6B,MAAM,0BAA0B,CAAC;AA2BrG,wBAAgB,8BAA8B,CAC5C,IAAI,EAAE,QAAQ,CAAC,aAAa,CAAC,EAC7B,KAAK,EAAE,QAAQ,CAAC,UAAU,CAAC,EAC3B,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,MAAM,GACX,IAAI,CAkBN"}

package/dist/applyAnimationClipToSkeleton2D.js

@@ -1,45 +1,44 @@
-import { sampleAnimationTrack } from '@flighthq/animation/contract';
-import { Skeleton2DAnimationPath } from '@flighthq/types/contract';
-// Poses a Skeleton2D from an AnimationClip at `time`: for each channel whose `targetRef` is a
-// Skeleton2DAnimationTarget, samples the channel's track and writes the value into the target bone's local
-// setup-transform fields. The 2D-skeletal analogue of @flighthq/scene3d's `applyAnimationClipToScene3D`, over
-// `Bone2D` instead of a `Node3D`. It mutates only the bones' local pose — the caller runs
-// `computeSkeleton2DWorldTransforms` (then the deform) afterward, so a whole clip applies before one world
-// propagation. Module scratch, allocation-free. A channel whose target is foreign (not a
-// Skeleton2DAnimationTarget) or out of range is skipped (sentinel guard, no throw).
-export function applyAnimationClipToSkeleton2D(clip, skeleton, time) {
+import { getSkeleton2DAnimationTargetBinder } from './skeleton2dAnimationTarget';
+// Poses `pose` from an AnimationClip at `time` by COMPOSING each channel's sampled value onto the
+// corresponding `setup` bone — the 2D-skeletal analogue of @flighthq/scene3d's `applyAnimationClipToScene3D`,
+// but relative rather than absolute. This mirrors Spine's SkeletonData(setup)/Skeleton(instance) split:
+// `setup` is the immutable rest pose, `pose` is the animated instance (typically a `cloneSkeleton2D(setup)`),
+// and a clip carries RELATIVE deltas — translate/rotate/shear ADD to setup, scale MULTIPLIES it (Spine's
+// timeline semantics; the `path` distinguishes which). Composing from `setup` every call (not from `pose`)
+// is what makes clips blendable — a mixer accumulates deltas as `pose = setup + Σ wᵢ·deltaᵢ`, which averaging
+// baked-absolute poses cannot express — and is why re-applying a clip does not accumulate across frames.
+//
+// One clip carries channels for several families at once — bone transforms, slot appearance, and whatever
+// else has registered a binder — so this walks the channels ONCE and hands each to the binder its target
+// kind names. Not every family follows the compose rule: a slot colour is an ABSOLUTE authored value that
+// its binder writes without reading `setup` at all.
+//
+// It writes only what a channel targets; untouched pose bones keep their clone-of-setup values. The caller
+// runs `computeSkeleton2DWorldTransforms(pose, …)` (then the deform) afterward, so a whole clip applies
+// before one world propagation. A channel whose target is foreign, unregistered, or out of range is
+// skipped (sentinel guard, no throw).
+//
+// This is the documented exception to the out-param aliasing rule: `setup` is read across the whole pass
+// while `pose` is written, so they cannot be the same object. Passing one skeleton as both would clobber
+// the rest pose the binder composes against and then accumulate against garbage every subsequent frame —
+// a silent, delayed corruption — so it is a programmer error the guard below throws on, not a sentinel.
+export function applyAnimationClipToSkeleton2D(clip, setup, pose, time) {
+    if (setup === pose) {
+        throw new Error('applyAnimationClipToSkeleton2D: setup and pose must be distinct skeletons — pass a cloneSkeleton2D(setup) as pose');
+    }
     const channels = clip.channels;
-    const bones = skeleton.bones;
     for (let i = 0; i < channels.length; i++) {
         const channel = channels[i];
         const target = channel.targetRef;
-        if (target === null || typeof target !== 'object' || typeof target.boneIndex !== 'number')
+        if (target === null || typeof target !== 'object')
             continue;
-        const boneIndex = target.boneIndex;
-        if (boneIndex < 0 || boneIndex >= bones.length)
+        // `targetRef` is opaque, so the target's own kind says which family owns it. A registry rather than a
+        // shape probe: the two 2D-skeletal formats animate eight things that are not bone transforms, and at
+        // that width a probe on overlapping field names reroutes a channel silently.
+        const bind = getSkeleton2DAnimationTargetBinder(target.kind);
+        if (bind === null)
             continue;
-        sampleAnimationTrack(_scratch, channel.track, time);
-        const bone = bones[boneIndex];
-        switch (target.path) {
-            case Skeleton2DAnimationPath.Translation:
-                bone.x = _scratch[0];
-                bone.y = _scratch[1];
-                break;
-            case Skeleton2DAnimationPath.Rotation:
-                bone.rotation = _scratch[0];
-                break;
-            case Skeleton2DAnimationPath.Scale:
-                bone.scaleX = _scratch[0];
-                bone.scaleY = _scratch[1];
-                break;
-            case Skeleton2DAnimationPath.Shear:
-                bone.shearX = _scratch[0];
-                bone.shearY = _scratch[1];
-                break;
-            default:
-                break;
-        }
+        bind(channel, setup, pose, target, time);
     }
 }
-const _scratch = [0, 0, 0, 0];
 //# sourceMappingURL=applyAnimationClipToSkeleton2D.js.map

package/dist/applyAnimationClipToSkeleton2D.js.map

@@ -1 +1 @@
-{"version":3,"file":"applyAnimationClipToSkeleton2D.js","sourceRoot":"","sources":["../src/applyAnimationClipToSkeleton2D.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAEpE,OAAO,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AAEnE,8FAA8F;AAC9F,2GAA2G;AAC3G,8GAA8G;AAC9G,0FAA0F;AAC1F,2GAA2G;AAC3G,yFAAyF;AACzF,oFAAoF;AACpF,MAAM,UAAU,8BAA8B,CAC5C,IAA6B,EAC7B,QAAoB,EACpB,IAAY;IAEZ,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;IAC/B,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC;IAC7B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACzC,MAAM,OAAO,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;QAC5B,MAAM,MAAM,GAAG,OAAO,CAAC,SAA6C,CAAC;QACrE,IAAI,MAAM,KAAK,IAAI,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,OAAO,MAAM,CAAC,SAAS,KAAK,QAAQ;YAAE,SAAS;QACpG,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC;QACnC,IAAI,SAAS,GAAG,CAAC,IAAI,SAAS,IAAI,KAAK,CAAC,MAAM;YAAE,SAAS;QACzD,oBAAoB,CAAC,QAAQ,EAAE,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QACpD,MAAM,IAAI,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC;QAC9B,QAAQ,MAAM,CAAC,IAAI,EAAE,CAAC;YACpB,KAAK,uBAAuB,CAAC,WAAW;gBACtC,IAAI,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;gBACrB,IAAI,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;gBACrB,MAAM;YACR,KAAK,uBAAuB,CAAC,QAAQ;gBACnC,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;gBAC5B,MAAM;YACR,KAAK,uBAAuB,CAAC,KAAK;gBAChC,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;gBAC1B,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;gBAC1B,MAAM;YACR,KAAK,uBAAuB,CAAC,KAAK;gBAChC,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;gBAC1B,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;gBAC1B,MAAM;YACR;gBACE,MAAM;QACV,CAAC;IACH,CAAC;AACH,CAAC;AAED,MAAM,QAAQ,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC"}
+{"version":3,"file":"applyAnimationClipToSkeleton2D.js","sourceRoot":"","sources":["../src/applyAnimationClipToSkeleton2D.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,kCAAkC,EAAE,MAAM,6BAA6B,CAAC;AAEjF,kGAAkG;AAClG,8GAA8G;AAC9G,wGAAwG;AACxG,8GAA8G;AAC9G,yGAAyG;AACzG,2GAA2G;AAC3G,8GAA8G;AAC9G,yGAAyG;AACzG,EAAE;AACF,0GAA0G;AAC1G,yGAAyG;AACzG,0GAA0G;AAC1G,oDAAoD;AACpD,EAAE;AACF,2GAA2G;AAC3G,wGAAwG;AACxG,oGAAoG;AACpG,sCAAsC;AACtC,EAAE;AACF,yGAAyG;AACzG,yGAAyG;AACzG,yGAAyG;AACzG,wGAAwG;AACxG,MAAM,UAAU,8BAA8B,CAC5C,IAA6B,EAC7B,KAA2B,EAC3B,IAAgB,EAChB,IAAY;IAEZ,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QACnB,MAAM,IAAI,KAAK,CACb,mHAAmH,CACpH,CAAC;IACJ,CAAC;IACD,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;IAC/B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACzC,MAAM,OAAO,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;QAC5B,MAAM,MAAM,GAAG,OAAO,CAAC,SAA6C,CAAC;QACrE,IAAI,MAAM,KAAK,IAAI,IAAI,OAAO,MAAM,KAAK,QAAQ;YAAE,SAAS;QAC5D,sGAAsG;QACtG,qGAAqG;QACrG,6EAA6E;QAC7E,MAAM,IAAI,GAAG,kCAAkC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAC7D,IAAI,IAAI,KAAK,IAAI;YAAE,SAAS;QAC5B,IAAI,CAAC,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;IAC3C,CAAC;AACH,CAAC"}

package/dist/boundingBoxAttachment2D.d.ts

@@ -0,0 +1,3 @@
+import type { BoundingBoxAttachment2D, Skeleton2D } from '@flighthq/types/contract';
+export declare function computeSkeleton2DBoundingBoxAttachmentVertices(out: Float32Array, attachment: Readonly<BoundingBoxAttachment2D>, skeleton: Readonly<Skeleton2D>, boneIndex: number, deform?: Readonly<Float32Array> | null): void;
+//# sourceMappingURL=boundingBoxAttachment2D.d.ts.map

package/dist/boundingBoxAttachment2D.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boundingBoxAttachment2D.d.ts","sourceRoot":"","sources":["../src/boundingBoxAttachment2D.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAapF,wBAAgB,8CAA8C,CAC5D,GAAG,EAAE,YAAY,EACjB,UAAU,EAAE,QAAQ,CAAC,uBAAuB,CAAC,EAC7C,QAAQ,EAAE,QAAQ,CAAC,UAAU,CAAC,EAC9B,SAAS,EAAE,MAAM,EACjB,MAAM,GAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,IAAW,GAC3C,IAAI,CAUN"}

package/dist/boundingBoxAttachment2D.js

@@ -0,0 +1,14 @@
+import { skinSkeleton2DAttachmentPoints } from './skinAttachment2DPoints';
+// Produces a bounding box's world polygon as flat interleaved `[x0, y0, x1, y1, …]` in `out` (length
+// ≥ 2 × attachment.pointCount), for hit testing and region queries. Requires
+// `computeSkeleton2DWorldTransforms` to have filled `skeleton.worldMatrices`. Out-parameter,
+// allocation-free.
+//
+// It is `compute*` rather than `deform*` because nothing here is being drawn: the result is queried. The
+// skinning underneath is identical to a mesh's, which is the point — a hit box bound to the same bones as
+// the art it covers tracks that art exactly, rather than approximating it with a shape that drifts as the
+// rig moves.
+export function computeSkeleton2DBoundingBoxAttachmentVertices(out, attachment, skeleton, boneIndex, deform = null) {
+    skinSkeleton2DAttachmentPoints(out, attachment.skin, attachment.vertices, skeleton, boneIndex, deform, 'BoundingBoxAttachment2D');
+}
+//# sourceMappingURL=boundingBoxAttachment2D.js.map

package/dist/boundingBoxAttachment2D.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"boundingBoxAttachment2D.js","sourceRoot":"","sources":["../src/boundingBoxAttachment2D.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,8BAA8B,EAAE,MAAM,0BAA0B,CAAC;AAE1E,qGAAqG;AACrG,6EAA6E;AAC7E,6FAA6F;AAC7F,mBAAmB;AACnB,EAAE;AACF,yGAAyG;AACzG,0GAA0G;AAC1G,0GAA0G;AAC1G,aAAa;AACb,MAAM,UAAU,8CAA8C,CAC5D,GAAiB,EACjB,UAA6C,EAC7C,QAA8B,EAC9B,SAAiB,EACjB,SAAwC,IAAI;IAE5C,8BAA8B,CAC5B,GAAG,EACH,UAAU,CAAC,IAAI,EACf,UAAU,CAAC,QAAQ,EACnB,QAAQ,EACR,SAAS,EACT,MAAM,EACN,yBAAyB,CAC1B,CAAC;AACJ,CAAC"}

package/dist/clippingAttachment2D.d.ts

@@ -0,0 +1,7 @@
+import type { ClippingAttachment2D, Skeleton2D } from '@flighthq/types/contract';
+export declare function computeSkeleton2DClippingAttachmentVertices(out: Float32Array, attachment: Readonly<ClippingAttachment2D>, skeleton: Readonly<Skeleton2D>, boneIndex: number, deform?: Readonly<Float32Array> | null): void;
+export declare function getSkeleton2DClippingAttachmentSlotRange(attachment: Readonly<ClippingAttachment2D>, slotIndex: number, slotCount: number): {
+    end: number;
+    start: number;
+};
+//# sourceMappingURL=clippingAttachment2D.d.ts.map

package/dist/clippingAttachment2D.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clippingAttachment2D.d.ts","sourceRoot":"","sources":["../src/clippingAttachment2D.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAYjF,wBAAgB,2CAA2C,CACzD,GAAG,EAAE,YAAY,EACjB,UAAU,EAAE,QAAQ,CAAC,oBAAoB,CAAC,EAC1C,QAAQ,EAAE,QAAQ,CAAC,UAAU,CAAC,EAC9B,SAAS,EAAE,MAAM,EACjB,MAAM,GAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,IAAW,GAC3C,IAAI,CAUN;AASD,wBAAgB,wCAAwC,CACtD,UAAU,EAAE,QAAQ,CAAC,oBAAoB,CAAC,EAC1C,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAKhC"}

package/dist/clippingAttachment2D.js

@@ -0,0 +1,26 @@
+import { skinSkeleton2DAttachmentPoints } from './skinAttachment2DPoints';
+// Produces a clipping polygon's world points as flat interleaved `[x0, y0, x1, y1, …]` in `out` (length
+// ≥ 2 × attachment.pointCount). Requires `computeSkeleton2DWorldTransforms` to have filled
+// `skeleton.worldMatrices`. Out-parameter, allocation-free.
+//
+// This computes the polygon and NOTHING ELSE. It does not clip, does not build a `ClipRegion`, and does
+// not consult `endSlotIndex` — turning a polygon plus a slot range into an applied clip is the display
+// layer's job, and doing it here would make a query function mutate a scene. See
+// `getSkeleton2DClippingAttachmentSlotRange` for the range half.
+export function computeSkeleton2DClippingAttachmentVertices(out, attachment, skeleton, boneIndex, deform = null) {
+    skinSkeleton2DAttachmentPoints(out, attachment.skin, attachment.vertices, skeleton, boneIndex, deform, 'ClippingAttachment2D');
+}
+// The half-open slot range a clipping attachment covers, given the slot it sits on: `[start, end)` into
+// the skeleton's draw-order slot array. Clipping starts AFTER its own slot and runs through
+// `endSlotIndex` INCLUSIVE, so the returned `end` is one past it; an `endSlotIndex` of -1, or one at or
+// before the clipping slot, runs to the end of the draw order.
+//
+// It exists so a consumer does not re-derive the off-by-one from the field's prose. The two conventions
+// in play — inclusive in the format, half-open in the result — are exactly where that mistake lives.
+export function getSkeleton2DClippingAttachmentSlotRange(attachment, slotIndex, slotCount) {
+    const start = slotIndex + 1;
+    const declared = attachment.endSlotIndex;
+    const end = declared < start ? slotCount : Math.min(declared + 1, slotCount);
+    return { end: Math.max(start, end), start };
+}
+//# sourceMappingURL=clippingAttachment2D.js.map

package/dist/clippingAttachment2D.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clippingAttachment2D.js","sourceRoot":"","sources":["../src/clippingAttachment2D.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,8BAA8B,EAAE,MAAM,0BAA0B,CAAC;AAE1E,wGAAwG;AACxG,2FAA2F;AAC3F,4DAA4D;AAC5D,EAAE;AACF,wGAAwG;AACxG,uGAAuG;AACvG,iFAAiF;AACjF,iEAAiE;AACjE,MAAM,UAAU,2CAA2C,CACzD,GAAiB,EACjB,UAA0C,EAC1C,QAA8B,EAC9B,SAAiB,EACjB,SAAwC,IAAI;IAE5C,8BAA8B,CAC5B,GAAG,EACH,UAAU,CAAC,IAAI,EACf,UAAU,CAAC,QAAQ,EACnB,QAAQ,EACR,SAAS,EACT,MAAM,EACN,sBAAsB,CACvB,CAAC;AACJ,CAAC;AAED,wGAAwG;AACxG,4FAA4F;AAC5F,wGAAwG;AACxG,+DAA+D;AAC/D,EAAE;AACF,wGAAwG;AACxG,qGAAqG;AACrG,MAAM,UAAU,wCAAwC,CACtD,UAA0C,EAC1C,SAAiB,EACjB,SAAiB;IAEjB,MAAM,KAAK,GAAG,SAAS,GAAG,CAAC,CAAC;IAC5B,MAAM,QAAQ,GAAG,UAAU,CAAC,YAAY,CAAC;IACzC,MAAM,GAAG,GAAG,QAAQ,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,GAAG,CAAC,EAAE,SAAS,CAAC,CAAC;IAC7E,OAAO,EAAE,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC;AAC9C,CAAC"}

package/dist/contract.d.ts

@@ -2,4 +2,21 @@ export * from './skeleton2d';
 export * from './deformMeshAttachment2D';
 export * from './regionAttachment2D';
 export * from './applyAnimationClipToSkeleton2D';
+export * from './skeleton2dAnimationTarget';
+export * from './deformPathAttachment2D';
+export * from './skeleton2dConstraint';
+export * from './ikConstraint2D';
+export * from './transformConstraint2D';
+export * from './pathConstraint2D';
+export * from './skeleton2dGuards';
+export * from './enableSkeleton2DGuards';
+export * from './explainSkeleton2DChannel';
+export * from './skinAttachment2DPoints';
+export * from './boundingBoxAttachment2D';
+export * from './clippingAttachment2D';
+export * from './pointAttachment2D';
+export * from './explainSkeleton2DDeformLength';
+export * from './slotDeform2D';
+export * from './deformAnimationTarget2D';
+export * from './skeleton2dDrawOrderTarget';
 //# sourceMappingURL=contract.d.ts.map

package/dist/contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../src/contract.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,0BAA0B,CAAC;AACzC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kCAAkC,CAAC"}
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../src/contract.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,0BAA0B,CAAC;AACzC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kCAAkC,CAAC;AACjD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,kBAAkB,CAAC;AACjC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,iCAAiC,CAAC;AAChD,cAAc,gBAAgB,CAAC;AAC/B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC"}

package/dist/contract.js

@@ -2,4 +2,21 @@ export * from './skeleton2d';
 export * from './deformMeshAttachment2D';
 export * from './regionAttachment2D';
 export * from './applyAnimationClipToSkeleton2D';
+export * from './skeleton2dAnimationTarget';
+export * from './deformPathAttachment2D';
+export * from './skeleton2dConstraint';
+export * from './ikConstraint2D';
+export * from './transformConstraint2D';
+export * from './pathConstraint2D';
+export * from './skeleton2dGuards';
+export * from './enableSkeleton2DGuards';
+export * from './explainSkeleton2DChannel';
+export * from './skinAttachment2DPoints';
+export * from './boundingBoxAttachment2D';
+export * from './clippingAttachment2D';
+export * from './pointAttachment2D';
+export * from './explainSkeleton2DDeformLength';
+export * from './slotDeform2D';
+export * from './deformAnimationTarget2D';
+export * from './skeleton2dDrawOrderTarget';
 //# sourceMappingURL=contract.js.map

package/dist/contract.js.map

@@ -1 +1 @@
-{"version":3,"file":"contract.js","sourceRoot":"","sources":["../src/contract.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,0BAA0B,CAAC;AACzC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kCAAkC,CAAC"}
+{"version":3,"file":"contract.js","sourceRoot":"","sources":["../src/contract.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,0BAA0B,CAAC;AACzC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kCAAkC,CAAC;AACjD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,kBAAkB,CAAC;AACjC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,iCAAiC,CAAC;AAChD,cAAc,gBAAgB,CAAC;AAC/B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC"}

package/dist/deformAnimationTarget2D.d.ts

@@ -0,0 +1,2 @@
+export declare function registerSkeleton2DDeformAnimationTarget(): void;
+//# sourceMappingURL=deformAnimationTarget2D.d.ts.map

package/dist/deformAnimationTarget2D.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deformAnimationTarget2D.d.ts","sourceRoot":"","sources":["../src/deformAnimationTarget2D.ts"],"names":[],"mappings":"AAUA,wBAAgB,uCAAuC,IAAI,IAAI,CAE9D"}

package/dist/deformAnimationTarget2D.js

@@ -0,0 +1,40 @@
+import { sampleAnimationTrack } from '@flighthq/animation/contract';
+import { Skeleton2DAnimationTargetKind } from '@flighthq/types/contract';
+import { registerSkeleton2DAnimationTargetBinder } from './skeleton2dAnimationTarget';
+import { setSkeleton2DSlotDeform } from './slotDeform2D';
+// Opts a bundle into deform channels. Unlike the bone and slot binders — which are pre-entered because a
+// bundle that shed them would leave the pose pass a silent no-op — a rig with no deform timeline should
+// not carry this, so it registers explicitly like a constraint solver does.
+export function registerSkeleton2DDeformAnimationTarget() {
+    registerSkeleton2DAnimationTargetBinder(Skeleton2DAnimationTargetKind.Deform, bindSkeleton2DDeformChannel);
+}
+// Samples a deform channel onto its slot, stamping the attachment the offsets were authored for so the
+// pull seam can reject them once the slot shows something else.
+//
+// The track is ordinary and numeric: `components` is the whole offset stream length, so a keyframe is one
+// complete set of offsets and `sampleAnimationTrack` interpolates between them normally. That is the right
+// behaviour here and the opposite of an attachment-swap index — a morph that snapped between drawn keys
+// instead of blending would be the bug.
+//
+// A channel whose slot is out of range writes nothing rather than throwing; a rig can carry a timeline for
+// a slot a trimmed skeleton no longer has.
+function bindSkeleton2DDeformChannel(channel, _setup, pose, target, time) {
+    const deformTarget = target;
+    const slots = pose.slots;
+    if (slots === undefined || slots === null)
+        return;
+    const slotIndex = deformTarget.slotIndex;
+    if (typeof slotIndex !== 'number' || slotIndex < 0 || slotIndex >= slots.length)
+        return;
+    const components = channel.track.components;
+    if (components <= 0)
+        return;
+    if (_scratch.length < components)
+        _scratch = new Float32Array(components);
+    sampleAnimationTrack(_scratch, channel.track, time);
+    // `_scratch` may be longer than the stream after a previous, wider channel, so only the components this
+    // track actually carries are written.
+    setSkeleton2DSlotDeform(slots[slotIndex], deformTarget.attachment ?? null, _scratch.subarray(0, components));
+}
+let _scratch = new Float32Array(0);
+//# sourceMappingURL=deformAnimationTarget2D.js.map

package/dist/deformAnimationTarget2D.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deformAnimationTarget2D.js","sourceRoot":"","sources":["../src/deformAnimationTarget2D.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAEpE,OAAO,EAAE,6BAA6B,EAAE,MAAM,0BAA0B,CAAC;AAEzE,OAAO,EAAE,uCAAuC,EAAE,MAAM,6BAA6B,CAAC;AACtF,OAAO,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AAEzD,yGAAyG;AACzG,wGAAwG;AACxG,4EAA4E;AAC5E,MAAM,UAAU,uCAAuC;IACrD,uCAAuC,CAAC,6BAA6B,CAAC,MAAM,EAAE,2BAA2B,CAAC,CAAC;AAC7G,CAAC;AAED,uGAAuG;AACvG,gEAAgE;AAChE,EAAE;AACF,0GAA0G;AAC1G,2GAA2G;AAC3G,wGAAwG;AACxG,wCAAwC;AACxC,EAAE;AACF,2GAA2G;AAC3G,2CAA2C;AAC3C,SAAS,2BAA2B,CAClC,OAAmC,EACnC,MAA4B,EAC5B,IAAgB,EAChB,MAAe,EACf,IAAY;IAEZ,MAAM,YAAY,GAAG,MAAmD,CAAC;IACzE,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;IACzB,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO;IAClD,MAAM,SAAS,GAAG,YAAY,CAAC,SAAS,CAAC;IACzC,IAAI,OAAO,SAAS,KAAK,QAAQ,IAAI,SAAS,GAAG,CAAC,IAAI,SAAS,IAAI,KAAK,CAAC,MAAM;QAAE,OAAO;IAExF,MAAM,UAAU,GAAG,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC;IAC5C,IAAI,UAAU,IAAI,CAAC;QAAE,OAAO;IAC5B,IAAI,QAAQ,CAAC,MAAM,GAAG,UAAU;QAAE,QAAQ,GAAG,IAAI,YAAY,CAAC,UAAU,CAAC,CAAC;IAC1E,oBAAoB,CAAC,QAAQ,EAAE,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IACpD,wGAAwG;IACxG,sCAAsC;IACtC,uBAAuB,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,YAAY,CAAC,UAAU,IAAI,IAAI,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC;AAC/G,CAAC;AAED,IAAI,QAAQ,GAAG,IAAI,YAAY,CAAC,CAAC,CAAC,CAAC"}

package/dist/deformMeshAttachment2D.d.ts

@@ -1,3 +1,3 @@
 import type { MeshAttachment2D, Skeleton2D } from '@flighthq/types/contract';
-export declare function deformSkeleton2DMeshAttachment(out: Float32Array, attachment: Readonly<MeshAttachment2D>, skeleton: Readonly<Skeleton2D>, boneIndex: number): void;
+export declare function deformSkeleton2DMeshAttachment(out: Float32Array, attachment: Readonly<MeshAttachment2D>, skeleton: Readonly<Skeleton2D>, boneIndex: number, deform?: Readonly<Float32Array> | null): void;
 //# sourceMappingURL=deformMeshAttachment2D.d.ts.map

package/dist/deformMeshAttachment2D.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deformMeshAttachment2D.d.ts","sourceRoot":"","sources":["../src/deformMeshAttachment2D.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAgB7E,wBAAgB,8BAA8B,CAC5C,GAAG,EAAE,YAAY,EACjB,UAAU,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EACtC,QAAQ,EAAE,QAAQ,CAAC,UAAU,CAAC,EAC9B,SAAS,EAAE,MAAM,GAChB,IAAI,CA4CN"}
+{"version":3,"file":"deformMeshAttachment2D.d.ts","sourceRoot":"","sources":["../src/deformMeshAttachment2D.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AA4B7E,wBAAgB,8BAA8B,CAC5C,GAAG,EAAE,YAAY,EACjB,UAAU,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EACtC,QAAQ,EAAE,QAAQ,CAAC,UAAU,CAAC,EAC9B,SAAS,EAAE,MAAM,EACjB,MAAM,GAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,IAAW,GAC3C,IAAI,CAUN"}

package/dist/deformMeshAttachment2D.js

@@ -1,5 +1,4 @@
-// 6 floats per bone in the flat world-transform buffer (a, b, c, d, tx, ty).
-const MATRIX_STRIDE = 6;
+import { skinSkeleton2DAttachmentPoints } from './skinAttachment2DPoints';
 // Deforms a MeshAttachment2D's vertices into flat interleaved world positions `[x0, y0, x1, y1, …]` in
 // `out` (length ≥ 2 × attachment.vertexCount), for the display layer to draw. Requires
 // `computeSkeleton2DWorldTransforms` to have filled `skeleton.worldMatrices`. Out-parameter,
@@ -11,49 +10,20 @@ const MATRIX_STRIDE = 6;
 //   RIGID (attachment.skin null): the mesh's setup-pose local `vertices` are transformed by bone
 //     `boneIndex`'s (the slot's bone) world matrix. Alias-safe — each vertex is read into locals before its
 //     output is written, so `out` may be the same buffer as `attachment.vertices`.
-export function deformSkeleton2DMeshAttachment(out, attachment, skeleton, boneIndex) {
-    const world = skeleton.worldMatrices;
-    const skin = attachment.skin;
-    if (skin !== null && skin !== undefined) {
-        const counts = skin.influenceCounts;
-        const inf = skin.influences;
-        let vi = 0; // influence-stream cursor (stride 4: boneIndex, localX, localY, weight)
-        let oi = 0; // output cursor (stride 2)
-        for (let v = 0; v < counts.length; v++) {
-            let wx = 0;
-            let wy = 0;
-            const n = counts[v];
-            for (let k = 0; k < n; k++) {
-                const b = inf[vi] * MATRIX_STRIDE;
-                const lx = inf[vi + 1];
-                const ly = inf[vi + 2];
-                const weight = inf[vi + 3];
-                wx += weight * (world[b] * lx + world[b + 2] * ly + world[b + 4]);
-                wy += weight * (world[b + 1] * lx + world[b + 3] * ly + world[b + 5]);
-                vi += 4;
-            }
-            out[oi] = wx;
-            out[oi + 1] = wy;
-            oi += 2;
-        }
-        return;
-    }
-    // Rigid mesh: the whole attachment follows one bone's world transform.
-    const vertices = attachment.vertices;
-    if (vertices === null || vertices === undefined)
-        return;
-    const b = boneIndex * MATRIX_STRIDE;
-    const a = world[b];
-    const bb = world[b + 1];
-    const c = world[b + 2];
-    const d = world[b + 3];
-    const tx = world[b + 4];
-    const ty = world[b + 5];
-    for (let i = 0; i < vertices.length; i += 2) {
-        const vx = vertices[i];
-        const vy = vertices[i + 1];
-        out[i] = a * vx + c * vy + tx;
-        out[i + 1] = bb * vx + d * vy + ty;
-    }
+//
+// `deform` is the animated offset stream layered on top of the skinning, or null for the undeformed
+// attachment. It is ADDRESSED BY WHATEVER THE ATTACHMENT STORES ITS POSITIONS AS, which is the one rule
+// that makes deform work for meshes and paths alike: a weighted attachment's offsets parallel its
+// INFLUENCE stream (two floats per influence, so a vertex with three bones consumes three pairs), and a
+// rigid one's parallel its vertex stream. Offsets are in the same space as what they displace — bone-local
+// for a weighted attachment, so they are added BEFORE the weighted sum. Adding them to the world position
+// afterwards would put a bone-local displacement into world space, which looks correct at rest and wrong
+// the moment the rig moves.
+//
+// A `deform` too short for the stream it parallels is ignored entirely rather than read past: an importer
+// sizing that buffer from vertex count instead of influence count is an expected failure, not a
+// programmer error, so it takes the sentinel.
+export function deformSkeleton2DMeshAttachment(out, attachment, skeleton, boneIndex, deform = null) {
+    skinSkeleton2DAttachmentPoints(out, attachment.skin, attachment.vertices, skeleton, boneIndex, deform, 'MeshAttachment2D');
 }
 //# sourceMappingURL=deformMeshAttachment2D.js.map

package/dist/deformMeshAttachment2D.js.map

@@ -1 +1 @@
-{"version":3,"file":"deformMeshAttachment2D.js","sourceRoot":"","sources":["../src/deformMeshAttachment2D.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"deformMeshAttachment2D.js","sourceRoot":"","sources":["../src/deformMeshAttachment2D.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,8BAA8B,EAAE,MAAM,0BAA0B,CAAC;AAE1E,uGAAuG;AACvG,uFAAuF;AACvF,6FAA6F;AAC7F,mBAAmB;AACnB,EAAE;AACF,2GAA2G;AAC3G,2GAA2G;AAC3G,mFAAmF;AACnF,iGAAiG;AACjG,4GAA4G;AAC5G,mFAAmF;AACnF,EAAE;AACF,oGAAoG;AACpG,wGAAwG;AACxG,kGAAkG;AAClG,wGAAwG;AACxG,2GAA2G;AAC3G,0GAA0G;AAC1G,yGAAyG;AACzG,4BAA4B;AAC5B,EAAE;AACF,0GAA0G;AAC1G,gGAAgG;AAChG,8CAA8C;AAC9C,MAAM,UAAU,8BAA8B,CAC5C,GAAiB,EACjB,UAAsC,EACtC,QAA8B,EAC9B,SAAiB,EACjB,SAAwC,IAAI;IAE5C,8BAA8B,CAC5B,GAAG,EACH,UAAU,CAAC,IAAI,EACf,UAAU,CAAC,QAAQ,EACnB,QAAQ,EACR,SAAS,EACT,MAAM,EACN,kBAAkB,CACnB,CAAC;AACJ,CAAC"}

package/dist/deformPathAttachment2D.d.ts

@@ -0,0 +1,3 @@
+import type { Path, PathAttachment2D, Skeleton2D } from '@flighthq/types/contract';
+export declare function deformSkeleton2DPathAttachment(out: Path, attachment: Readonly<PathAttachment2D>, skeleton: Readonly<Skeleton2D>, boneIndex: number, deform?: Readonly<Float32Array> | null): void;
+//# sourceMappingURL=deformPathAttachment2D.d.ts.map

package/dist/deformPathAttachment2D.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deformPathAttachment2D.d.ts","sourceRoot":"","sources":["../src/deformPathAttachment2D.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AA2BnF,wBAAgB,8BAA8B,CAC5C,GAAG,EAAE,IAAI,EACT,UAAU,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EACtC,QAAQ,EAAE,QAAQ,CAAC,UAAU,CAAC,EAC9B,SAAS,EAAE,MAAM,EACjB,MAAM,GAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,IAAW,GAC3C,IAAI,CAkBN"}

package/dist/deformPathAttachment2D.js

@@ -0,0 +1,36 @@
+import { skinSkeleton2DAttachmentPoints } from './skinAttachment2DPoints';
+// Deforms a PathAttachment2D into `out`, filling its `data` with world coordinates under the attachment's
+// own verb stream. Requires `computeSkeleton2DWorldTransforms` to have filled `skeleton.worldMatrices`.
+// Out-parameter; allocates only when `out`'s arrays have to grow to fit.
+//
+// The math is the same as `deformSkeleton2DMeshAttachment` — deliberately so. A skinned point is a
+// skinned point whether a triangle or a curve reads it, and Skin2D carries no triangles and no UVs, so it
+// was already geometry-agnostic. Only the output target differs: a Path's `data` stream instead of an
+// interleaved vertex buffer.
+//
+// CONTROL POINTS NEED NO SPECIAL CASE HERE, and that is by construction rather than by luck: a cubic
+// handle is given its anchor's influence set at IMPORT (see PathAttachment2D), so it arrives as an
+// ordinary entry in the influence stream. Nothing below distinguishes an anchor from a handle, which is
+// exactly why a curve cannot end up with its anchors moved and its handles left behind, or with its
+// tangents sheared by influences blended across a segment.
+//
+// `deform` is the animated offset stream layered on top of the skinning, addressed the same way the mesh
+// deformer addresses it: parallel to the INFLUENCE stream when weighted (two floats per influence),
+// parallel to the coordinate stream when rigid, and applied to the BONE-LOCAL offset before the weighted
+// sum. A stream too short for what it parallels is ignored rather than read past.
+//
+// This writes coordinates and never queries geometry, so it needs the `Path` TYPE and no function from
+// `@flighthq/path`. That is the whole reason path skinning can live here beside mesh skinning instead of
+// in a package that depends on the path kernel.
+export function deformSkeleton2DPathAttachment(out, attachment, skeleton, boneIndex, deform = null) {
+    const commands = attachment.commands;
+    const data = out.data;
+    const outCommands = out.commands;
+    outCommands.length = commands.length;
+    for (let i = 0; i < commands.length; i++)
+        outCommands[i] = commands[i];
+    out.winding = attachment.winding;
+    data.length = attachment.pointCount * 2;
+    skinSkeleton2DAttachmentPoints(data, attachment.skin, attachment.vertices, skeleton, boneIndex, deform, 'PathAttachment2D');
+}
+//# sourceMappingURL=deformPathAttachment2D.js.map

package/dist/deformPathAttachment2D.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deformPathAttachment2D.js","sourceRoot":"","sources":["../src/deformPathAttachment2D.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,8BAA8B,EAAE,MAAM,0BAA0B,CAAC;AAE1E,0GAA0G;AAC1G,wGAAwG;AACxG,yEAAyE;AACzE,EAAE;AACF,mGAAmG;AACnG,0GAA0G;AAC1G,sGAAsG;AACtG,6BAA6B;AAC7B,EAAE;AACF,qGAAqG;AACrG,mGAAmG;AACnG,wGAAwG;AACxG,oGAAoG;AACpG,2DAA2D;AAC3D,EAAE;AACF,yGAAyG;AACzG,oGAAoG;AACpG,yGAAyG;AACzG,kFAAkF;AAClF,EAAE;AACF,uGAAuG;AACvG,yGAAyG;AACzG,gDAAgD;AAChD,MAAM,UAAU,8BAA8B,CAC5C,GAAS,EACT,UAAsC,EACtC,QAA8B,EAC9B,SAAiB,EACjB,SAAwC,IAAI;IAE5C,MAAM,QAAQ,GAAG,UAAU,CAAC,QAAQ,CAAC;IACrC,MAAM,IAAI,GAAG,GAAG,CAAC,IAAI,CAAC;IACtB,MAAM,WAAW,GAAG,GAAG,CAAC,QAAQ,CAAC;IACjC,WAAW,CAAC,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC;IACrC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE;QAAE,WAAW,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;IACvE,GAAG,CAAC,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC;IACjC,IAAI,CAAC,MAAM,GAAG,UAAU,CAAC,UAAU,GAAG,CAAC,CAAC;IAExC,8BAA8B,CAC5B,IAAI,EACJ,UAAU,CAAC,IAAI,EACf,UAAU,CAAC,QAAQ,EACnB,QAAQ,EACR,SAAS,EACT,MAAM,EACN,kBAAkB,CACnB,CAAC;AACJ,CAAC"}

package/dist/enableSkeleton2DGuards.d.ts

@@ -0,0 +1,22 @@
+export declare function disableSkeleton2DGuards(): void;
+/**
+ * Installs the caller-facing skeleton guards (opt-in, dev-only). Idempotent.
+ *
+ * This package does two things that are **correct and invisible**, which is the combination worth
+ * announcing. Neither is a bug to fix — coercing is right in both cases — but a coercion nobody can see
+ * is indistinguishable from the file having been authored that way, so an author who set an easing and
+ * never saw it take effect has no way to find out why.
+ *
+ * 1. **A non-blendable channel is walked as steps** whatever its track claims. An attachment index
+ *    blended between two table entries names art that was never authored; a draw order blended between
+ *    two orderings yields fractional sort keys and a sequence nobody wrote.
+ * 2. **A deform offset stream whose length does not match the vertex stream it addresses is ignored.**
+ *    There is no correct prefix to consume, so applying what fits would deform some vertices and leave
+ *    others behind, and reading past the buffer is never an option.
+ *
+ * The messages live here rather than beside the code that knows the fact, so a shipped build that never
+ * imports this module carries neither them nor `@flighthq/log`. Every case also has a `has*`/`explain*`
+ * query for a caller that wants the fact as data instead of a log line.
+ */
+export declare function enableSkeleton2DGuards(): void;
+//# sourceMappingURL=enableSkeleton2DGuards.d.ts.map

package/dist/enableSkeleton2DGuards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enableSkeleton2DGuards.d.ts","sourceRoot":"","sources":["../src/enableSkeleton2DGuards.ts"],"names":[],"mappings":"AAOA,wBAAgB,uBAAuB,IAAI,IAAI,CAG9C;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,sBAAsB,IAAI,IAAI,CAG7C"}

package/dist/enableSkeleton2DGuards.js

@@ -0,0 +1,42 @@
+import { logOnce } from '@flighthq/log/contract';
+import { LogLevel } from '@flighthq/types/contract';
+import { setSkeleton2DCoercedInterpolationGuard, setSkeleton2DDeformLengthGuard } from './skeleton2dGuards';
+// Uninstalls the guards installed by enableSkeleton2DGuards.
+export function disableSkeleton2DGuards() {
+    setSkeleton2DCoercedInterpolationGuard(null);
+    setSkeleton2DDeformLengthGuard(null);
+}
+/**
+ * Installs the caller-facing skeleton guards (opt-in, dev-only). Idempotent.
+ *
+ * This package does two things that are **correct and invisible**, which is the combination worth
+ * announcing. Neither is a bug to fix — coercing is right in both cases — but a coercion nobody can see
+ * is indistinguishable from the file having been authored that way, so an author who set an easing and
+ * never saw it take effect has no way to find out why.
+ *
+ * 1. **A non-blendable channel is walked as steps** whatever its track claims. An attachment index
+ *    blended between two table entries names art that was never authored; a draw order blended between
+ *    two orderings yields fractional sort keys and a sequence nobody wrote.
+ * 2. **A deform offset stream whose length does not match the vertex stream it addresses is ignored.**
+ *    There is no correct prefix to consume, so applying what fits would deform some vertices and leave
+ *    others behind, and reading past the buffer is never an option.
+ *
+ * The messages live here rather than beside the code that knows the fact, so a shipped build that never
+ * imports this module carries neither them nor `@flighthq/log`. Every case also has a `has*`/`explain*`
+ * query for a caller that wants the fact as data instead of a log line.
+ */
+export function enableSkeleton2DGuards() {
+    setSkeleton2DCoercedInterpolationGuard(warnOnCoercedInterpolation);
+    setSkeleton2DDeformLengthGuard(warnOnDeformLengthMismatch);
+}
+function warnOnCoercedInterpolation(report) {
+    logOnce(`skeleton2d:coerced-interpolation:${report.subject}`, LogLevel.Warn, {
+        message: `A ${report.subject} channel states '${report.stated}' interpolation but is walked as '${report.applied}'. The value it carries cannot be blended — an attachment index between two table entries names art nobody authored, and a draw order between two orderings gives fractional sort keys — so the step is forced and the stated easing has no effect. Author the track as '${report.applied}' to say what actually happens, or drive a blendable property instead.`,
+    }, 'skeleton2d');
+}
+function warnOnDeformLengthMismatch(report) {
+    logOnce(`skeleton2d:deform-length:${report.subject}`, LogLevel.Warn, {
+        message: `Deform offsets on '${report.subject}' carry ${report.offsets} values but the vertex stream they address needs ${report.addressed}. The offsets are ignored rather than partly applied: a stream of the wrong length has no correct prefix, so consuming what fits would deform some vertices and silently leave the rest in their setup pose. Re-export the attachment, or check that the deform timeline belongs to this attachment.`,
+    }, 'skeleton2d');
+}
+//# sourceMappingURL=enableSkeleton2DGuards.js.map

package/dist/enableSkeleton2DGuards.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enableSkeleton2DGuards.js","sourceRoot":"","sources":["../src/enableSkeleton2DGuards.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAEjD,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEpD,OAAO,EAAE,sCAAsC,EAAE,8BAA8B,EAAE,MAAM,oBAAoB,CAAC;AAE5G,6DAA6D;AAC7D,MAAM,UAAU,uBAAuB;IACrC,sCAAsC,CAAC,IAAI,CAAC,CAAC;IAC7C,8BAA8B,CAAC,IAAI,CAAC,CAAC;AACvC,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,sBAAsB;IACpC,sCAAsC,CAAC,0BAA0B,CAAC,CAAC;IACnE,8BAA8B,CAAC,0BAA0B,CAAC,CAAC;AAC7D,CAAC;AAED,SAAS,0BAA0B,CAAC,MAAgD;IAClF,OAAO,CACL,oCAAoC,MAAM,CAAC,OAAO,EAAE,EACpD,QAAQ,CAAC,IAAI,EACb;QACE,OAAO,EAAE,KAAK,MAAM,CAAC,OAAO,oBAAoB,MAAM,CAAC,MAAM,qCAAqC,MAAM,CAAC,OAAO,4QAA4Q,MAAM,CAAC,OAAO,wEAAwE;KACnd,EACD,YAAY,CACb,CAAC;AACJ,CAAC;AAED,SAAS,0BAA0B,CAAC,MAAgD;IAClF,OAAO,CACL,4BAA4B,MAAM,CAAC,OAAO,EAAE,EAC5C,QAAQ,CAAC,IAAI,EACb;QACE,OAAO,EAAE,sBAAsB,MAAM,CAAC,OAAO,WAAW,MAAM,CAAC,OAAO,oDAAoD,MAAM,CAAC,SAAS,sSAAsS;KACjb,EACD,YAAY,CACb,CAAC;AACJ,CAAC"}

package/dist/explainSkeleton2DChannel.d.ts

@@ -0,0 +1,20 @@
+import type { AnimationChannel, Skeleton2DCoercedInterpolation } from '@flighthq/types/contract';
+/**
+ * Whether this channel's stated interpolation will be overridden, as plain data — the shakeable query
+ * beside the guard's log line, for a caller that wants to check a whole clip before playing it rather
+ * than watch warnings arrive during playback.
+ *
+ * Returns `null` when nothing is coerced, which is the common answer. `subject` names the channel
+ * family the caller is about to bind the channel as, since the same track is only coerced by virtue of
+ * what it drives: an identical `Linear` track is honoured on a bone and stepped on an attachment.
+ */
+export declare function explainSkeleton2DChannelInterpolation(channel: Readonly<AnimationChannel>, subject: string): Skeleton2DCoercedInterpolation | null;
+/**
+ * Whether a channel family carries a value that cannot be blended, and is therefore walked as steps
+ * whatever its track states.
+ *
+ * Kept a query rather than a field on the target: it is a property of what the channel *drives*, not
+ * of the channel, so a caller can ask before it has built a target at all.
+ */
+export declare function isSkeleton2DSteppedChannelSubject(subject: string): boolean;
+//# sourceMappingURL=explainSkeleton2DChannel.d.ts.map

package/dist/explainSkeleton2DChannel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"explainSkeleton2DChannel.d.ts","sourceRoot":"","sources":["../src/explainSkeleton2DChannel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,8BAA8B,EAAE,MAAM,0BAA0B,CAAC;AAEjG;;;;;;;;GAQG;AACH,wBAAgB,qCAAqC,CACnD,OAAO,EAAE,QAAQ,CAAC,gBAAgB,CAAC,EACnC,OAAO,EAAE,MAAM,GACd,8BAA8B,GAAG,IAAI,CAKvC;AAED;;;;;;GAMG;AACH,wBAAgB,iCAAiC,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAE1E"}

package/dist/explainSkeleton2DChannel.js

@@ -0,0 +1,33 @@
+/**
+ * Whether this channel's stated interpolation will be overridden, as plain data — the shakeable query
+ * beside the guard's log line, for a caller that wants to check a whole clip before playing it rather
+ * than watch warnings arrive during playback.
+ *
+ * Returns `null` when nothing is coerced, which is the common answer. `subject` names the channel
+ * family the caller is about to bind the channel as, since the same track is only coerced by virtue of
+ * what it drives: an identical `Linear` track is honoured on a bone and stepped on an attachment.
+ */
+export function explainSkeleton2DChannelInterpolation(channel, subject) {
+    if (!isSkeleton2DSteppedChannelSubject(subject))
+        return null;
+    const stated = channel.track.interpolation;
+    if (stated === STEP_INTERPOLATION)
+        return null;
+    return { applied: STEP_INTERPOLATION, stated, subject };
+}
+/**
+ * Whether a channel family carries a value that cannot be blended, and is therefore walked as steps
+ * whatever its track states.
+ *
+ * Kept a query rather than a field on the target: it is a property of what the channel *drives*, not
+ * of the channel, so a caller can ask before it has built a target at all.
+ */
+export function isSkeleton2DSteppedChannelSubject(subject) {
+    return subject === ATTACHMENT_SUBJECT || subject === DRAW_ORDER_SUBJECT;
+}
+// An attachment index blended between two table entries names art nobody authored; a draw order
+// blended between two orderings gives fractional sort keys and a sequence nobody wrote.
+const ATTACHMENT_SUBJECT = 'Attachment';
+const DRAW_ORDER_SUBJECT = 'DrawOrder';
+const STEP_INTERPOLATION = 'Step';
+//# sourceMappingURL=explainSkeleton2DChannel.js.map

package/dist/explainSkeleton2DChannel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"explainSkeleton2DChannel.js","sourceRoot":"","sources":["../src/explainSkeleton2DChannel.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,MAAM,UAAU,qCAAqC,CACnD,OAAmC,EACnC,OAAe;IAEf,IAAI,CAAC,iCAAiC,CAAC,OAAO,CAAC;QAAE,OAAO,IAAI,CAAC;IAC7D,MAAM,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,aAAa,CAAC;IAC3C,IAAI,MAAM,KAAK,kBAAkB;QAAE,OAAO,IAAI,CAAC;IAC/C,OAAO,EAAE,OAAO,EAAE,kBAAkB,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;AAC1D,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,iCAAiC,CAAC,OAAe;IAC/D,OAAO,OAAO,KAAK,kBAAkB,IAAI,OAAO,KAAK,kBAAkB,CAAC;AAC1E,CAAC;AAED,gGAAgG;AAChG,wFAAwF;AACxF,MAAM,kBAAkB,GAAG,YAAY,CAAC;AACxC,MAAM,kBAAkB,GAAG,WAAW,CAAC;AACvC,MAAM,kBAAkB,GAAG,MAAM,CAAC"}

package/dist/explainSkeleton2DDeformLength.d.ts

@@ -0,0 +1,3 @@
+import type { Skeleton2DDeformLengthExplanation, Skin2D } from '@flighthq/types/contract';
+export declare function explainSkeleton2DDeformLength(skin: Readonly<Skin2D> | null | undefined, vertices: Readonly<Float32Array> | null | undefined, deform: Readonly<Float32Array> | null): Skeleton2DDeformLengthExplanation;
+//# sourceMappingURL=explainSkeleton2DDeformLength.d.ts.map

package/dist/explainSkeleton2DDeformLength.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"explainSkeleton2DDeformLength.d.ts","sourceRoot":"","sources":["../src/explainSkeleton2DDeformLength.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AAa1F,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,IAAI,GAAG,SAAS,EACzC,QAAQ,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,IAAI,GAAG,SAAS,EACnD,MAAM,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,IAAI,GACpC,iCAAiC,CAUnC"}