@melonjs/spine-plugin 2.2.1 → 3.1.0

package/CHANGELOG.md

@@ -1,5 +1,56 @@
 # Changelog
 
+## 3.1.0 - _2026-06-14_
+
+### Added
+
+- `Spine.findConstraint(name)` — convenience wrapper around the unified 4.3 constraints list; matches the `findBone()`/`findSlot()` shape and resolves any constraint type (IK, transform, path, physics, Slider) by name. Return type is typed as a union of the five concrete constraint classes (`SpineConstraint` typedef) for `instanceof` narrowing without a cast
+- `Spine.getConstraintNames()` — list all constraint names defined on the skeleton (mirrors `getAnimationNames()`/`getSkinNames()`)
+- spine-core constraint classes re-exported from `@melonjs/spine-plugin` so `instanceof` narrowing of `findConstraint()` results doesn't require a second runtime import (the plugin already owns the spine-core re-export, so identity matches): the new 4.3 Slider classes (`Slider`, `SliderData`, `SliderTimeline`, `SliderMixTimeline`) plus the four pre-existing constraint classes (`IkConstraint`, `TransformConstraint`, `PathConstraint`, `PhysicsConstraint`)
+
+### Fixed
+
+- `setSkeleton()` actually loads binary `.skel` skeletons — was hardcoded to `SkeletonJson` for every input, so passing a `.skel` file (loaded as a `Uint8Array` by the asset manager) threw inside the JSON parser. Now dispatches to `SkeletonBinary` for `.skel` filenames and `SkeletonJson` otherwise. The README and JSDoc have claimed binary support since the original 1.x release; this is the first version where it works. The `spineboy` example in the live preview now loads from `spineboy-pro.skel` to give the binary path continuous coverage
+
+### Chore
+
+- dev deps: `tsx` ^4.21.0 → ^4.22.4, `typescript` ^6.0.2 → ^6.0.3 (no consumer impact — devDependencies aren't installed by npm consumers of the plugin)
+
+## 3.0.0 - _2026-06-14_
+
+### **BREAKING CHANGES**
+
+- **Spine 4.3 editor required** — bundled Spine runtimes bumped from `^4.2.114` to `^4.3.7`. The 4.2 and 4.3 skeleton data formats are incompatible both ways: existing `.json`/`.skel` exports must be re-exported from a Spine 4.3 editor, and 4.3 exports will not load on plugin 2.x
+- the plugin now sets `Skeleton.yDown = true` (the official 4.3 Y-down switch, same approach as Spine's own pixi/phaser/canvaskit integrations). Code that reached into `spineObject.skeleton` and compensated for the old manual Y-flip (root bone `scaleY = -1`, inverted physics gravity) must drop those workarounds — the runtime now handles Y-down natively
+- Spine 4.3 moved bone/slot state into poses: code accessing `bone.x/.scaleX/.worldX` etc. through `spineObject.skeleton` must use `bone.pose.*` (unconstrained, for writing) or `bone.appliedPose.*` (constrained, for reading world transforms); `slot.color`/`slot.getAttachment()` are now `slot.appliedPose.color`/`slot.appliedPose.attachment`
+- other 4.3 core renames that surface through `spineObject.skeleton`: `setToSetupPose()` → `setupPose()`, `physicsConstraints` → `physics`, `MixBlend`/`MixDirection` removed (use `TrackEntry.additive`), `MeshAttachment.getParentMesh()` → `getSourceMesh()`. The plugin's own `Spine.setToSetupPose()` wrapper keeps its name
+
+### Added
+
+- Spine 4.3 feature support inherited with the runtime bump: slider constraints, sequence timelines, non-linear animation mixing (`TrackEntry.mixInterpolation`), convex/inverse clipping, physics force direction vectors (`skeleton.windX/Y`, `gravityX/Y`)
+- **WebGL context-loss recovery** — the plugin now survives a `webglcontextlost`/`webglcontextrestored` cycle (melonJS ≥ 19.7 recovery machinery): `SpineBatcher` builds its GPU resources in `init()` so the renderer's restore path can re-create them, and all spine GL resources (atlas textures, debug pipeline) are funneled through a single shared canvas-backed `ManagedWebGLRenderingContext` so spine's own restorables actually fire (a managed context built from a raw GL context has no element to listen on and silently never restores)
+
+### Changed
+
+- minimum melonJS version is now **19.7.1** (was 18.3.0) — required for the WebGL context-loss restore + blend-cache invalidation fix the plugin's recovery path relies on
+- skeleton positioning now goes through `skeleton.x/y` instead of writing to the root bone pose — root-bone-relative user code (e.g. custom bone offsets) is unaffected
+- `flipX()`/`flipY()` JSDoc corrected: flipping is around the root bone, not the visual center (behavior unchanged, was always root-relative)
+- mesh auto-detection for the canvas renderer now uses the public `Skin.getAttachments()` API instead of walking spine's internal `skin.attachments` array
+
+### Performance
+
+- Canvas `SkeletonRenderer` mesh vertex buffer slimmed from 8 floats per vertex down to 2 (positions only) — first removed the 4 dead per-vertex color floats (canvas tinting is applied per slot via `setTint()`/`setGlobalAlpha()`), then dropped the UV interleave entirely (UVs now read straight from `sequence.getUVs(index)` in `drawMesh`). Halves the buffer twice over, eliminates a per-vertex copy pass, and removes the dedicated `computeMeshVertices` method. Verified pixel-identical across all 15 example skeletons (cold-start harness drift falls in the same noise floor with the change applied or not)
+
+### Fixed
+
+- Canvas `SkeletonRenderer` no longer corrupts mesh vertex data while a `ClippingAttachment` is active — the stride-2 "clipped vertex size" was inherited from spine-webgl's `clipTriangles` repacking, which the canvas path never performs: positions were written at stride 2 then read at the full vertex stride, scrambling any mesh drawn inside an active clip (latent since the 4.2 plugin; canvas meshes are clipped per-triangle, so no example skeleton ever exposed it)
+- Canvas `SkeletonRenderer` now uses `color.alpha` (the melonJS `Color` accessor) instead of `color.a`, which was always `undefined`. Canvas's `globalAlpha = undefined` is silently ignored, so slot-alpha animation never faded attachments — the canvas renderer behaved as if every slot were fully opaque. Visible on `powerup` (the trailing stars stayed at full opacity instead of fading) and any other skeleton with slot-alpha keyframes
+- Canvas `SkeletonRenderer` correctly handles atlas regions packed at 90° rotation (`region.degrees === 90`) — the `translate(-w/2, -h/2)` after the dimension swap was using the *pre-swap* half-dimensions, so any attachment whose texture region was rotated in the atlas drew with its quad offset by `±(w−h)/2`. Visible as the tank turret floating detached from the chassis and the raptor rider's visor tilted off his head on canvas (WebGL was unaffected). Now matches the official `spine-canvas` SkeletonRenderer math by re-deriving the halves from post-swap `w`/`h`
+
+### Removed
+
+- all manual Y-down plumbing made obsolete by `Skeleton.yDown`: the root-bone `scaleY` inversion in `setToSetupPose()`, the per-constraint physics gravity flip in `setSkeleton()`, and the `+90°` Canvas rotation offset in `rotate()`
+
 ## 2.2.1 - 2026-05-11
 
 ### Changed

package/README.md

@@ -1,26 +1,27 @@
 # melonJS Spine Plugin
 
-A [Spine](http://en.esotericsoftware.com/spine-in-depth) 4.2 runtime integration for the [melonJS](http://www.melonjs.org) game engine, using the official [@esotericsoftware/spine-webgl](https://www.npmjs.com/package/@esotericsoftware/spine-webgl) and [@esotericsoftware/spine-canvas](https://www.npmjs.com/package/@esotericsoftware/spine-canvas) runtimes.
+A [Spine](http://en.esotericsoftware.com/spine-in-depth) 4.x runtime integration for the [melonJS](http://www.melonjs.org) game engine, using the official [@esotericsoftware/spine-webgl](https://www.npmjs.com/package/@esotericsoftware/spine-webgl) and [@esotericsoftware/spine-canvas](https://www.npmjs.com/package/@esotericsoftware/spine-canvas) runtimes.
 
 ![melonjs-spine-gif](https://github.com/melonjs/spine-plugin/assets/4033090/dc259c8e-def6-419e-83a9-cda374715686)
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://github.com/melonjs/melonJS/blob/master/packages/spine-plugin/LICENSE)
 [![NPM Package](https://img.shields.io/npm/v/@melonjs/spine-plugin)](https://www.npmjs.com/package/@melonjs/spine-plugin)
-[![Spine Runtime](https://img.shields.io/badge/spine--runtime-4.2-orange)](http://esotericsoftware.com/spine-runtimes)
+[![Spine Runtime](https://img.shields.io/badge/spine--runtime-4.3-orange)](http://esotericsoftware.com/spine-runtimes)
 
-[Live Example](https://melonjs.github.io/melonJS/examples/#/spine) — 17 official Spine characters including spineboy, raptor, owl, dragon, and more
+[Live Example](https://melonjs.github.io/melonJS/examples/#/spine) — 15 official Spine characters including spineboy, raptor, owl, dragon, and more
 
 ## Features
 -------------------------------------------------------------------------------
 - **WebGL rendering** via custom `SpineBatcher` extending melonJS `Batcher` with two-color tinting and indexed drawing
 - **Canvas rendering** with full mesh, clipping, tinting, and blend mode support
-- **Spine 4.2 physics** support with automatic gravity correction for Y-down coordinate system
+- **Spine physics** support — native Y-down handling via the official `Skeleton.yDown` runtime switch, including physics force direction vectors (`windX/Y`, `gravityX/Y`)
 - **Two-color tinting** (dark/light color) using Spine's official shader
 - **Blend modes** (Normal, Additive, Multiply, Screen) with premultiplied alpha support
 - **Clipping attachments** via melonJS masking (canvas) and Spine's SkeletonClipping (WebGL)
 - **Skin support** including mix-and-match skin combining via `setCombinedSkin()`
 - **Animation state events** (start, end, complete, event, interrupt, dispose)
-- **Skeleton introspection** — `findBone()`, `findSlot()`, `getAnimationNames()`, `getSkinNames()`
+- **Skeleton introspection** — `findBone()`, `findSlot()`, `findConstraint()`, `getAnimationNames()`, `getSkinNames()`
+- **Spine 4.3 Slider constraints** — full runtime support; all constraint classes (`Slider`/`SliderData`/`SliderTimeline`/`SliderMixTimeline`, plus `IkConstraint`, `TransformConstraint`, `PathConstraint`, `PhysicsConstraint`) re-exported for one-import `instanceof` narrowing of `findConstraint()` results
 - **Animation queuing** — `setAnimation()`, `addAnimation()`, `setEmptyAnimation()`
 - **Debug rendering** for bones, regions, meshes, and clipping areas
 - **Auto-detection** of mesh attachments for optimized canvas rendering (fast path for region-only skeletons)
@@ -30,7 +31,7 @@ A [Spine](http://en.esotericsoftware.com/spine-in-depth) 4.2 runtime integration
 ## Installation
 -------------------------------------------------------------------------------
 This plugin is already bundled with the required Spine [4.x runtime](package.json#dependencies), so there is no need to install it separately.
->Note: this plugin requires melonJS version 18.3.0 or higher.
+>Note: this plugin requires melonJS version 19.7.1 or higher.
 
 To install the plugin using npm:
 
@@ -109,9 +110,38 @@ me.loader.preload(DataManifest, function() {
 |---|---|
 | `findBone(boneName)` | Find a bone by name |
 | `findSlot(slotName)` | Find a slot by name |
+| `findConstraint(constraintName)` | Find a constraint by name (IK / Transform / Path / Physics / **Slider**) — added in 3.1.0 |
+| `getConstraintNames()` | Get the list of constraint names available in the skeleton — added in 3.1.0 |
 | `setToSetupPose()` | Reset skeleton to setup pose |
 | `setSkeleton(atlasFile, jsonFile)` | Load a skeleton (if not set via constructor) |
 
+### Spine 4.3 Slider constraints
+
+Spine 4.3 introduced [Slider constraints](https://esotericsoftware.com/blog/Spine-4.3-released#slider-constraints) — a pre-baked animation indexed by a numeric `time` value, optionally driven by a bone's rotation. The plugin re-exports the Spine runtime's Slider classes (and the four pre-existing constraint classes) alongside the default `Spine` export so consumers can do `instanceof Slider` (or `instanceof IkConstraint`, etc.) without a second import from `@esotericsoftware/spine-core`:
+
+```javascript
+import Spine, {
+    // 4.3 Slider classes
+    Slider, SliderData, SliderTimeline, SliderMixTimeline,
+    // other constraint classes — for narrowing findConstraint() results
+    IkConstraint, TransformConstraint, PathConstraint, PhysicsConstraint,
+} from "@melonjs/spine-plugin";
+
+const diamond = new Spine(750, 600, { atlasFile: "diamond-pma.atlas", jsonFile: "diamond-pro.json" });
+diamond.setAnimation(0, "idle-rotating", true);
+
+// query the "rotation" Slider constraint
+const slider = diamond.findConstraint("rotation");
+if (slider instanceof Slider) {
+    // scrub a slider manually (disable bone auto-driving first)
+    slider.bone = null;
+    slider.pose.time = 1.0;   // jump to t=1s in the slider's animation
+    slider.pose.mix = 1.0;    // 0..1 — how much of the slider pose to apply
+}
+```
+
+See the [diamond example](https://melonjs.github.io/melonJS/examples/#/spine) for an interactive demo.
+
 ### Transform
 | Method | Description |
 |---|---|
@@ -125,11 +155,14 @@ me.loader.preload(DataManifest, function() {
 
 | @melonjs/spine-plugin | melonJS | spine-runtime |
 |---|---|---|
-| v2.2.0 | v18.3.0 (or higher) | v4.2.x |
-| v2.1.0 | v18.3.0 (or higher) | v4.2.x |
-| v2.0.1 | v18.2.1 (or higher) | v4.2.x |
-| v2.0.0 | v18.2.0 | v4.2.x |
-| v1.5.x | v15.12.x — v18.0.x | v4.1, v4.2-beta |
+| v3.x.x | v19.7.1 (or higher) | v4.3.x |
+| v2.2.x | v18.3.0 (or higher) | v4.2.x |
+| v2.1.x | v18.3.0 (or higher) | v4.2.x |
+| v2.0.x | v18.2.1 (or higher) | v4.2.x |
+| v2.0.0 | v18.2.0 (or higher) | v4.2.x |
+| v1.5.x | v15.12.0 (or higher)| v4.1, v4.2-beta |
+
+> **Note:** skeleton data is editor-version locked — plugin 3.x requires assets exported from a Spine **4.3** editor; 4.2 exports will not load (and vice-versa on plugin 2.x).
 
 ## Questions, need help ?
 -------------------------------------------------------------------------------

package/build/AssetManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AssetManager.d.ts","sourceRoot":"","sources":["../src/AssetManager.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH;IACC;;;OAGG;IACH,sBAHW,cAAc,GAAC,aAAa,eAC5B,MAAM,EA0ChB;IAvCA;;;OAGG;IACH,sEAG4C;IAkC7C;;;OAGG;IACH,sBAFW,MAAM,QAIhB;IAED;;;;;;;;;OASG;IACH,iBARW,MAAM,QACN,MAAM,QAgBhB;IAED;;;;;OAKG;IACH,wBAJW,MAAM,+CAMhB;IAED;;;;;OAKG;IACH,iBAJW,MAAM,+CAMhB;IAED;;;;;OAKG;IACH,eAJW,MAAM,+CAMhB;IAED;;;;OAIG;IACH,wBAEC;IAED;;;;OAIG;IACH,cAHW,MAAM,GACJ,GAAC,CAIb;IAED;;OAEG;IACH,gBAEC;CACD;4BA3I2B,+BAA+B;6BAD9B,gCAAgC"}
+{"version":3,"file":"AssetManager.d.ts","sourceRoot":"","sources":["../src/AssetManager.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH;IACC;;;OAGG;IACH,sBAHW,cAAc,GAAC,aAAa,eAC5B,MAAM,EA+ChB;IA5CA;;;OAGG;IACH,sEAQ4C;IAkC7C;;;OAGG;IACH,sBAFW,MAAM,QAIhB;IAED;;;;;;;;;OASG;IACH,iBARW,MAAM,QACN,MAAM,QAgBhB;IAED;;;;;OAKG;IACH,wBAJW,MAAM,+CAMhB;IAED;;;;;OAKG;IACH,iBAJW,MAAM,+CAMhB;IAED;;;;;OAKG;IACH,eAJW,MAAM,+CAMhB;IAED;;;;OAIG;IACH,wBAEC;IAED;;;;OAIG;IACH,cAHW,MAAM,GACJ,GAAC,CAIb;IAED;;OAEG;IACH,gBAEC;CACD;4BAjJ2B,+BAA+B;6BAD9B,gCAAgC"}

package/build/SkeletonRenderer.d.ts

@@ -28,7 +28,6 @@ export default class SkeletonRenderer {
      */
     premultipliedAlpha: boolean;
     tintColor: MColor;
-    tempColor: MColor;
     clipper: SkeletonClipping;
     clippingVertices: any[];
     clippingMask: Polygon;
@@ -44,38 +43,31 @@ export default class SkeletonRenderer {
      * @param {HTMLImageElement} image
      * @param {Bone} bone
      * @param {RegionAttachment} attachment
+     * @param {SlotPose} slotPose - the slot's applied pose (resolves sequence offsets)
      * @param {TextureRegion} region
      * @param {Polygon|null} mask - clipping mask if active
      * @param {boolean} debug - whether to draw debug outline
      * @ignore
      */
-    drawRegion(renderer: CanvasRenderer, image: HTMLImageElement, bone: Bone, attachment: RegionAttachment, region: TextureRegion, mask: Polygon | null, debug: boolean): void;
+    drawRegion(renderer: CanvasRenderer, image: HTMLImageElement, bone: Bone, attachment: RegionAttachment, slotPose: SlotPose, region: TextureRegion, mask: Polygon | null, debug: boolean): void;
     /**
      * Draw a mesh attachment as a series of textured triangles.
      * @param {CanvasRenderer} renderer
      * @param {HTMLImageElement} image
-     * @param {Float32Array} vertices - world vertices
+     * @param {Float32Array} vertices - world positions, stride 2 (x, y per vertex)
+     * @param {NumberArrayLike} uvs - atlas UVs from `sequence.getUVs(index)`, stride 2
      * @param {number[]} triangles - triangle indices
      * @ignore
      */
-    drawMesh(renderer: CanvasRenderer, image: HTMLImageElement, vertices: Float32Array, triangles: number[]): void;
+    drawMesh(renderer: CanvasRenderer, image: HTMLImageElement, vertices: Float32Array, uvs: NumberArrayLike, triangles: number[]): void;
     /**
      * Draw a single textured triangle using affine transform.
      * @ignore
      */
     drawTriangle(renderer: any, img: any, x0: any, y0: any, u0: any, v0: any, x1: any, y1: any, u1: any, v1: any, x2: any, y2: any, u2: any, v2: any): void;
-    /**
-     * Compute world vertices for a mesh attachment with color and UV data.
-     * @param {Slot} slot
-     * @param {MeshAttachment} mesh
-     * @param {number} vertexSize - floats per vertex
-     * @ignore
-     */
-    computeMeshVertices(slot: Slot, mesh: MeshAttachment, vertexSize: number): void;
 }
 import { Color as MColor } from "melonjs";
 import { SkeletonClipping } from "@esotericsoftware/spine-core";
 import { Polygon } from "melonjs";
 import { RegionAttachment } from "@esotericsoftware/spine-core";
-import { MeshAttachment } from "@esotericsoftware/spine-core";
 //# sourceMappingURL=SkeletonRenderer.d.ts.map

package/build/SkeletonRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SkeletonRenderer.d.ts","sourceRoot":"","sources":["../src/SkeletonRenderer.js"],"names":[],"mappings":"AA0BA;;;;;;GAMG;AACH;IACC;;;;;;;OAOG;IACH,mBAHU,OAAO,CAGS;IAE1B;;;;OAIG;IACH,gBAHU,OAAO,CAGM;IAEvB;;;;OAIG;IACH,oBAHU,OAAO,CAGU;IAG3B,kBAAyB;IACzB,kBAAyB;IAGzB,0BAAiC;IACjC,wBAAsB;IACtB,sBAIG;IAEH;;;;OAIG;IACH,eAHW,cAAc,YACd,QAAQ,QAoGlB;IAED;;;;;;;;;;OAUG;IACH,qBATW,cAAc,SACd,gBAAgB,QAChB,IAAI,cACJ,gBAAgB,UAChB,aAAa,QACb,OAAO,GAAC,IAAI,SACZ,OAAO,QAqDjB;IAED;;;;;;;OAOG;IACH,mBANW,cAAc,SACd,gBAAgB,YAChB,YAAY,aACZ,MAAM,EAAE,QA8BlB;IAED;;;OAGG;IACH,wJA2CC;IAED;;;;;;OAMG;IACH,0BALW,IAAI,QACJ,cAAc,cACd,MAAM,QAwChB;CACD;gCA5WuD,SAAS;iCAD1D,8BAA8B;wBACmB,SAAS;iCAD1D,8BAA8B;+BAA9B,8BAA8B"}
+{"version":3,"file":"SkeletonRenderer.d.ts","sourceRoot":"","sources":["../src/SkeletonRenderer.js"],"names":[],"mappings":"AA2BA;;;;;;GAMG;AACH;IACC;;;;;;;OAOG;IACH,mBAHU,OAAO,CAGS;IAE1B;;;;OAIG;IACH,gBAHU,OAAO,CAGM;IAEvB;;;;OAIG;IACH,oBAHU,OAAO,CAGU;IAG3B,kBAAyB;IAGzB,0BAAiC;IACjC,wBAAsB;IACtB,sBAIG;IAEH;;;;OAIG;IACH,eAHW,cAAc,YACd,QAAQ,QA2HlB;IAED;;;;;;;;;;;OAWG;IACH,qBAVW,cAAc,SACd,gBAAgB,QAChB,IAAI,cACJ,gBAAgB,YAChB,QAAQ,UACR,aAAa,QACb,OAAO,GAAC,IAAI,SACZ,OAAO,QAiEjB;IAED;;;;;;;;OAQG;IACH,mBAPW,cAAc,SACd,gBAAgB,YAChB,YAAY,OACZ,eAAe,aACf,MAAM,EAAE,QA8BlB;IAED;;;OAGG;IACH,wJA2CC;CACD;gCAnWuD,SAAS;iCAD1D,8BAA8B;wBACmB,SAAS;iCAD1D,8BAA8B"}

package/build/Spine.d.ts

@@ -1,3 +1,16 @@
+/**
+ * Union of the five concrete constraint classes Spine 4.3 exposes via
+ * `skeleton.constraints` — returned by {@link Spine.findConstraint}.
+ * Narrow with `instanceof` against the corresponding re-export
+ * (`Slider`, `IkConstraint`, etc. from this plugin or
+ * `@esotericsoftware/spine-core`).
+ * @typedef {import("@esotericsoftware/spine-core").Slider
+ *   | import("@esotericsoftware/spine-core").IkConstraint
+ *   | import("@esotericsoftware/spine-core").TransformConstraint
+ *   | import("@esotericsoftware/spine-core").PathConstraint
+ *   | import("@esotericsoftware/spine-core").PhysicsConstraint
+ * } SpineConstraint
+ */
 /**
  * @classdesc
  * A renderable object to render Spine animated skeleton.
@@ -79,7 +92,6 @@ export default class Spine extends Renderable {
     currentTrack: TrackEntry;
     /** @ignore */
     isWebGL: boolean;
-    canvas: any;
     spineBatcher: any;
     shapesShader: spineWebGL.Shader | undefined;
     shapes: spineWebGL.ShapeRenderer | undefined;
@@ -115,13 +127,13 @@ export default class Spine extends Renderable {
     setSkeleton(atlasFile: string, jsonFile: string): void;
     premultipliedAlpha: any;
     /**
-     * Flip the Spine skeleton on the horizontal axis (around its center).
+     * Flip the Spine skeleton on the horizontal axis (around its root bone).
      * @param {boolean} [flip=true] - `true` to flip this Spine object.
      * @returns {Spine} Reference to this object for method chaining
      */
     flipX(flip?: boolean): Spine;
     /**
-     * Flip the Spine skeleton on the vertical axis (around its center).
+     * Flip the Spine skeleton on the vertical axis (around its root bone).
      * @param {boolean} [flip=true] - `true` to flip this Spine object.
      * @returns {Spine} Reference to this object for method chaining
      */
@@ -153,6 +165,12 @@ export default class Spine extends Renderable {
      * Called automatically when the renderable is removed from the world.
      */
     dispose(): void;
+    /**
+     * Called when the renderable is destroyed (removed from the world).
+     * Cleans up GPU resources automatically.
+     * @ignore
+     */
+    onDestroyEvent(): void;
     /**
      * Sets the current animation for a track by animation index, discarding any queued animations.
      * @param {number} trackIndex - the track index
@@ -257,6 +275,29 @@ export default class Spine extends Renderable {
      * @returns {Slot|null} the slot, or null if not found
      */
     findSlot(slotName: string): Slot | null;
+    /**
+     * Find a constraint (Slider, IK, transform, path, or physics) by name.
+     * Convenience wrapper around the 4.3 unified constraints list — like
+     * {@link findBone}/{@link findSlot} but for any constraint type.
+     *
+     * Returns the constraint instance whose `data.name` matches; use
+     * `instanceof Slider` (etc., re-exported by this plugin) to narrow
+     * the type if you need the constraint's specific pose API.
+     * @param {string} constraintName - the constraint name
+     * @returns {SpineConstraint|null} the constraint, or null if not found
+     * @example
+     * // drive a Slider constraint manually (4.3+)
+     * const rot = spine.findConstraint("rotation");
+     * rot.pose.time = 1.5;   // animation seconds; loops if `loop: true`
+     * rot.pose.mix = 1.0;    // 0..1+ — blend toward the constrained pose
+     */
+    findConstraint(constraintName: string): SpineConstraint | null;
+    /**
+     * Get the list of constraint names available in this skeleton
+     * (Slider, IK, transform, path, physics — 4.3 unified list).
+     * @returns {string[]} array of constraint names
+     */
+    getConstraintNames(): string[];
     /**
      * Register a listener for animation state events.
      * @param {object} listener - an object with event handler methods
@@ -304,6 +345,14 @@ export default class Spine extends Renderable {
      */
     setToSetupPose(): void;
 }
+/**
+ * Union of the five concrete constraint classes Spine 4.3 exposes via
+ * `skeleton.constraints` — returned by {@link Spine.findConstraint}.
+ * Narrow with `instanceof` against the corresponding re-export
+ * (`Slider`, `IkConstraint`, etc. from this plugin or
+ * `@esotericsoftware/spine-core`).
+ */
+export type SpineConstraint = import("@esotericsoftware/spine-core").Slider | import("@esotericsoftware/spine-core").IkConstraint | import("@esotericsoftware/spine-core").TransformConstraint | import("@esotericsoftware/spine-core").PathConstraint | import("@esotericsoftware/spine-core").PhysicsConstraint;
 import { Renderable } from "melonjs";
 import * as spineWebGL from "@esotericsoftware/spine-webgl";
 import * as spineCanvas from "@esotericsoftware/spine-canvas";

package/build/Spine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Spine.d.ts","sourceRoot":"","sources":["../src/Spine.js"],"names":[],"mappings":"AAWA;;;;GAIG;AACH;IAkCC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,eApCW,MAAM,KACN,MAAM,YAEd;QAA0B,SAAS;QACT,QAAQ;QACR,OAAO;KACjC,EA2FF;IAnID,gDAAQ;IACR,cAAS;IACT,0BAAO;IACP,oBAAe;IACf,iEAAiB;IACjB,UAAK;IACL,gCAAW;IACX,8BAAS;IACT;;;MAGE;IAEF;;;;;;;;;;;;;;;;;OAiBG;IACH,cAhBU,UAAU,CAgBP;IAmDZ,cAAc;IACd,iBAAyC;IAIxC,YAA0C;IAK1C,kBAAkD;IASlD,4CAA+D;IAC/D,6CAAyD;IACzD,oEAEC;IAmBF,gBAAsC;IAGrC,6BAAiC;IACjC,8BAAmC;IAcrC,0BANU,OAAO,EAQhB;IAXD;;;;OAIG;IACH,sBAFU,OAAO,CAIhB;IAMD;;;;;;;;;;;;;;;;;OAiBG;IACH,uBAfW,MAAM,YACN,MAAM,QAmEhB;IA3CA,wBAEE;IA2CH;;;;OAIG;IACH,aAHW,OAAO,GACL,KAAK,CASjB;IAED;;;;OAIG;IACH,aAHW,OAAO,GACL,KAAK,CASjB;IAED;;;;;OAKG;IACH,cAJW,MAAM,MACN,QAAQ,GAAC,kBAAkB,GACzB,KAAK,CAWjB;IAED;;;;;OAKG;IACH,SAJW,MAAM,MACN,MAAM,GACJ,KAAK,CAWjB;IAmFD;;;;;;OAMG;IACH,eAFW,cAAc,GAAC,aAAa,QA4CtC;IAED;;;OAGG;IACH,gBAMC;IAWD;;;;;;OAMG;IACH,gCALW,MAAM,SACN,MAAM,SACN,OAAO,GACL,UAAU,CAYtB;IAED;;;;;;;;;OASG;IACH,yBARW,MAAM,QACN,MAAM,SACN,OAAO,GACL,UAAU,CAYtB;IAED;;;;;;;;OAQG;IACH,yBAPW,MAAM,GACJ,OAAO,CAWnB;IAED;;;;;;;OAOG;IACH,gCANW,MAAM,SACN,MAAM,SACN,OAAO,UACP,MAAM,GACJ,UAAU,CAatB;IAED;;;;;;;OAOG;IACH,yBANW,MAAM,QACN,MAAM,SACN,OAAO,UACP,MAAM,GACJ,UAAU,CAItB;IAED;;;OAGG;IACH,2BAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,qCAJW,MAAM,mBACN,MAAM,WACN,MAAM,QAIhB;IAED;;;;;;;;;;;;;;;OAeG;IACH,wBAdW,MAAM,QAgBhB;IAED;;;;;;;OAOG;IACH,8BANW,MAAM,gBACH,MAAM,EAAA,QAkBnB;IAED;;;;;OAKG;IACH,8BAJW,MAAM,gBACN,MAAM,GACJ,UAAU,CAItB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,IAAI,GAAC,IAAI,CAIrB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,IAAI,GAAC,IAAI,CAIrB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,+BAhBG;QAA4B,KAAK;QACL,SAAS;QACT,GAAG;QACH,OAAO;QACP,QAAQ;QACR,KAAK;KACjC,QAYF;IAED;;;OAGG;IACH,kCAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,qBAFa,MAAM,EAAE,CAMpB;IAED;;;OAGG;IACH,gBAFa,MAAM,EAAE,CAMpB;IAED;;OAEG;IACH,uBAYC;CACD;2BAnrBwC,SAAS;4BADtB,+BAA+B;6BAF9B,gCAAgC;uBAGpB,SAAS;6BACrB,uBAAuB"}
+{"version":3,"file":"Spine.d.ts","sourceRoot":"","sources":["../src/Spine.js"],"names":[],"mappings":"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"}

package/build/SpineBatcher.d.ts

@@ -5,16 +5,21 @@
  */
 export default class SpineBatcher extends Batcher {
     /**
+     * Initialize (or re-initialize) the batcher.
+     * Settings are built here rather than in the constructor so the
+     * renderer's context-restore recovery can re-create all GPU
+     * resources with a bare `batcher.init(renderer)` call, matching
+     * the engine's built-in batchers.
      * @param {WebGLRenderer} renderer - the current WebGL renderer session
-     * @param {WebGLRenderingContext|WebGL2RenderingContext} canvas - the GL context for Spine shader creation
+     * @ignore
      */
-    constructor(renderer: WebGLRenderer, canvas: WebGLRenderingContext | WebGL2RenderingContext);
+    init(renderer: WebGLRenderer): void;
     /**
      * the current texture bound to the batcher
      * @type {object|null}
      * @ignore
      */
-    lastTexture: object | null;
+    lastTexture: object | null | undefined;
     /**
      * Set the blend mode for subsequent draw calls.
      * Maps Spine BlendMode enum to melonJS blend mode strings.

package/build/SpineBatcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SpineBatcher.d.ts","sourceRoot":"","sources":["../src/SpineBatcher.js"],"names":[],"mappings":"AAcA;;;;GAIG;AACH;IACC;;;OAGG;IACH,sBAHW,aAAa,UACb,qBAAqB,GAAC,sBAAsB,EAuDtD;IANA;;;;OAIG;IACH,aAHU,MAAM,GAAC,IAAI,CAGE;IAGxB;;;;;OAKG;IACH,wBAHW,MAAM,sBACN,OAAO,QAOjB;IAED;;;;;;OAMG;IACH,cAJW,MAAM,YACN,SAAS,CAAC,MAAM,CAAC,WACjB,MAAM,EAAE,QAwBlB;CAaD;wBArIuB,SAAS"}
+{"version":3,"file":"SpineBatcher.d.ts","sourceRoot":"","sources":["../src/SpineBatcher.js"],"names":[],"mappings":"AAeA;;;;GAIG;AACH;IACC;;;;;;;;OAQG;IACH,eAHW,aAAa,QA0DvB;IANA;;;;OAIG;IACH,uCAAuB;IAGxB;;;;;OAKG;IACH,wBAHW,MAAM,sBACN,OAAO,QAOjB;IAED;;;;;;OAMG;IACH,cAJW,MAAM,YACN,SAAS,CAAC,MAAM,CAAC,WACjB,MAAM,EAAE,QAwBlB;CAaD;wBA7IuB,SAAS"}

package/build/SpinePlugin.d.ts

@@ -4,7 +4,13 @@
  * @augments plugin.BasePlugin
  */
 export class SpinePlugin extends plugin.BasePlugin {
-    constructor();
+    /**
+     * @param {Application} [app] - the application instance this plugin
+     * belongs to (defaults to the active game instance). Pass it through
+     * `plugin.register(SpinePlugin, "SpinePlugin", app)` when running
+     * multiple applications.
+     */
+    constructor(app?: Application);
     assetManager: AssetManager;
 }
 import { plugin } from "melonjs";

package/build/SpinePlugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SpinePlugin.d.ts","sourceRoot":"","sources":["../src/SpinePlugin.js"],"names":[],"mappings":"AAWA;;;;GAIG;AACH;IACC,cAkBC;IALA,2BAAuD;CAMxD;uBApCgD,SAAS;yBAQjC,gBAAgB"}
+{"version":3,"file":"SpinePlugin.d.ts","sourceRoot":"","sources":["../src/SpinePlugin.js"],"names":[],"mappings":"AAWA;;;;GAIG;AACH;IACC;;;;;OAKG;IACH,kBALW,WAAW,EAuBrB;IALA,2BAAuD;CAMxD;uBA1CgD,SAAS;yBAQjC,gBAAgB"}

package/build/glContext.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Return the shared spine ManagedWebGLRenderingContext for the given canvas,
+ * creating it on first use.
+ *
+ * One shared instance per canvas matters for WebGL context-loss recovery:
+ * Spine's GLTexture/Shader/Mesh register themselves as restorables on their
+ * managed context, but a managed context only listens for
+ * `webglcontextrestored` when constructed from a canvas (a raw
+ * WebGLRenderingContext gives it no element to listen on). Funneling every
+ * spine GL resource through this single canvas-backed instance guarantees
+ * they are all restored after a context loss.
+ * @param {HTMLCanvasElement} canvas - the canvas the melonJS WebGL renderer draws to
+ * @returns {ManagedWebGLRenderingContext} the shared managed context
+ * @ignore
+ */
+export function getManagedContext(canvas: HTMLCanvasElement): ManagedWebGLRenderingContext;
+import { ManagedWebGLRenderingContext } from "@esotericsoftware/spine-webgl";
+//# sourceMappingURL=glContext.d.ts.map

package/build/glContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glContext.d.ts","sourceRoot":"","sources":["../src/glContext.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AACH,0CAJW,iBAAiB,GACf,4BAA4B,CAUxC;6CA1B4C,+BAA+B"}

package/build/index.d.ts

@@ -1,3 +1,4 @@
 export { SpinePlugin } from "./SpinePlugin.js";
+export { IkConstraint, PathConstraint, PhysicsConstraint, Slider, SliderData, SliderMixTimeline, SliderTimeline, TransformConstraint } from "@esotericsoftware/spine-core";
 export { default, default as Spine } from "./Spine.js";
 //# sourceMappingURL=index.d.ts.map