rig-play 0.8.0 → 1.1.0

package/dist/loadModel.d.ts

@@ -0,0 +1,92 @@
+import { type RegionImage } from './DomTexture.js';
+/**
+ * Loads a rig built by `rigc build`: the compiled model document
+ * (`skeleton.model.json`, spec `rigc-compiled/3`) and the page images its
+ * `pages` section names, cut into region bitmaps once.
+ *
+ * The document states everything the player reads — the skeleton, the
+ * animations, and where every region sits on its page — so the `.atlas` and
+ * `skeleton.json` the build writes beside it are not fetched. A Spine export
+ * (`.json`, `.skel`) is refused by name: this package poses the compiled model
+ * through `rig-c/core` and reads nothing else.
+ */
+export interface LoadModelOptions {
+    /** URL of the compiled model document (`skeleton.model.json`). */
+    modelUrl: string;
+    /**
+     * Maps a page name from the document's `pages` section to the URL its image
+     * lives at. Defaults to resolving the name against the model URL's
+     * directory: a build writes page names as paths relative to its own
+     * directory, which is where the document sits.
+     */
+    resolvePage?: (pageName: string, modelUrl: string) => string;
+    /**
+     * crossOrigin attribute for the page images. Needed when the images come
+     * from another origin: the region cut reads them into a canvas, and a
+     * tainted canvas cannot be exported (SecurityError from toBlob).
+     */
+    crossOrigin?: string;
+    /** fetch implementation, for custom headers or a test double. */
+    fetch?: typeof globalThis.fetch;
+}
+/**
+ * What `new RigPlayer(root, assets)` draws from. The caller owns it: one load
+ * can back any number of players, and nothing a player does disposes it.
+ */
+export interface ModelAssets {
+    /** The document's spec, e.g. `rigc-compiled/3`. */
+    readonly spec: string;
+    /** Every animation the document carries, in its order, with the runtime's duration. */
+    readonly animations: ReadonlyArray<{
+        readonly name: string;
+        readonly duration: number;
+    }>;
+    /** Every skin the document declares, in its order. */
+    readonly skins: readonly string[];
+    /**
+     * The setup pose's box in world units (Y up) as the document states it —
+     * the rig's own framing, for laying out a stage — or null where it states
+     * none.
+     */
+    readonly stage: {
+        readonly x: number;
+        readonly y: number;
+        readonly width: number;
+        readonly height: number;
+    } | null;
+    /** Unpacked per-region bitmaps, keyed by region name — the rigid tier's. */
+    readonly regionImages: Map<string, RegionImage>;
+    /** Page images, keyed by the document's page names — the mesh tier's. */
+    readonly pageImages: Map<string, HTMLImageElement>;
+    /**
+     * The document as `rig-c/core` read it. Opaque to callers: the player poses
+     * it, and its shape is rig-c's, not this package's.
+     */
+    readonly document: ModelDocument;
+    /**
+     * Frees the blob URLs this load created (see revokeRegions). Idempotent.
+     * Call it after the players drawing from these assets are disposed — a live
+     * <img> would be left pointing at a dead URL.
+     */
+    dispose(): void;
+}
+/** The read document, held for the player. Deliberately opaque. */
+export interface ModelDocument {
+    readonly spec: string;
+}
+/**
+ * Loads a rig built by `rigc build`.
+ *
+ * ```ts
+ * const assets = await loadModel({ modelUrl: '/rigs/walk/skeleton.model.json' });
+ * const player = new RigPlayer(root, assets);
+ * player.play('walk');
+ * // each frame: player.frame(dt)
+ * // …later: player.dispose(); assets.dispose();
+ * ```
+ *
+ * Page images load in parallel. If anything fails part-way, no blob URL is
+ * left behind.
+ */
+export declare function loadModel(options: LoadModelOptions): Promise<ModelAssets>;
+//# sourceMappingURL=loadModel.d.ts.map

package/dist/loadModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadModel.d.ts","sourceRoot":"","sources":["../src/loadModel.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,WAAW,EAAgC,MAAM,iBAAiB,CAAC;AAEjF;;;;;;;;;;GAUG;AAEH,MAAM,WAAW,gBAAgB;IAC/B,kEAAkE;IAClE,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC;IAC7D;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,iEAAiE;IACjE,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;CACjC;AAED;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,mDAAmD;IACnD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,uFAAuF;IACvF,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAC;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACzF,sDAAsD;IACtD,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE;QAAE,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IACnH,4EAA4E;IAC5E,QAAQ,CAAC,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IAChD,yEAAyE;IACzE,QAAQ,CAAC,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IACnD;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;IACjC;;;;OAIG;IACH,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,mEAAmE;AACnE,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAgED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,WAAW,CAAC,CAqC/E"}

package/dist/player.d.ts

@@ -0,0 +1,198 @@
+import { CanvasRenderer } from './CanvasRenderer.js';
+import { DomRenderer, type MeshBackend } from './DomRenderer.js';
+import type { ModelAssets } from './loadModel.js';
+import { type PosedFrame } from './posedFrame.js';
+/**
+ * Plays a rig built by `rigc build` on a DOM root.
+ *
+ * The player owns the track and the renderer: `play` opens an animation on a
+ * live track (`openTrack` from `rig-c/core`), each `frame(dt)` steps it by
+ * `dt × timeScale`, turns the pose into a `PosedFrame` and hands that to its
+ * renderer — a `DomRenderer` (`mode: 'dom'`, the default) or a
+ * `CanvasRenderer` (`mode: 'canvas'`). Everything the pose holds is computed by
+ * the core from the compiled model document; this class schedules and draws.
+ */
+/**
+ * How a player draws: `'dom'` — elements, the rigid tier as `<img>` and the
+ * mesh tier on per-part canvases (`DomRenderer`); `'canvas'` — the whole frame
+ * into one `<canvas>` through the shared WebGL context (`CanvasRenderer`).
+ */
+export type RenderMode = 'dom' | 'canvas';
+export interface RigPlayerOptions {
+    /**
+     * The skin to pose under. Absent is the runtime's "no skin set" — a fresh
+     * skeleton whose `setSkin` was never called (`underNoSkin`): no skin's bones
+     * or constraints applied, every slot resolved through the default skin.
+     */
+    skin?: string;
+    /** How the player draws (see `RenderMode`). Default `'dom'`. Can be changed later through `mode`. */
+    mode?: RenderMode;
+    /** The mesh tier's rasterizer (see `DomRenderer.meshBackend`) — the DOM mode only. */
+    meshBackend?: MeshBackend;
+    /**
+     * The step `seek` walks the track forward with, in seconds. A seek is
+     * "reopen, then step to the time", never a jump: a physics rig has history,
+     * and the pose at a time depends on the steps taken to reach it.
+     */
+    seekStep?: number;
+}
+/** What `on('event', …)` hands a listener: one event key the step crossed. */
+export interface RigEvent {
+    name: string;
+    /** The key's time in the animation. */
+    time: number;
+    int: number;
+    float: number;
+    string: string | null;
+}
+type Listener<T> = (payload: T) => void;
+/**
+ * One rig on one root.
+ *
+ * ```ts
+ * const player = new RigPlayer(root, assets);
+ * player.play('walk');
+ * requestAnimationFrame(function tick(now) { player.frame(dt); requestAnimationFrame(tick); });
+ * ```
+ */
+/**
+ * Where a bone is in the pose the player holds — world units, Y up, the
+ * numbers `rig-c/core` posed (`RawBone`): the world matrix `a b c d`, the
+ * world position, the world rotation of each axis in degrees and the world
+ * scale of each, and whether the bone is active under the player's skin.
+ */
+export interface BoneWorld {
+    name: string;
+    active: boolean;
+    x: number;
+    y: number;
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    rotationX: number;
+    rotationY: number;
+    scaleX: number;
+    scaleY: number;
+}
+/** A box in world units, Y up: `y` is the bottom edge. */
+export interface PoseBounds {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare class RigPlayer {
+    /**
+     * The renderer this player draws through — its knobs and counters are the
+     * caller's to read and set. A `DomRenderer` in the DOM mode, a
+     * `CanvasRenderer` in the canvas mode; a new object after `mode` changes.
+     */
+    get renderer(): DomRenderer | CanvasRenderer;
+    /** Multiplies every step. 0 holds the pose (nothing is re-posed); negative is refused by the track. */
+    timeScale: number;
+    /** The player's whole-rig colour, r g b a — multiplied into every slot's tint. Not a document value. */
+    color: [number, number, number, number];
+    private active;
+    private readonly root;
+    private readonly assets;
+    private readonly meshBackend;
+    private readonly view;
+    private readonly source;
+    private readonly seekStep;
+    private track;
+    private animation;
+    private loop;
+    private paused;
+    private pose;
+    private setup;
+    private readonly listeners;
+    constructor(root: HTMLElement, assets: ModelAssets, options?: RigPlayerOptions);
+    /**
+     * How the player draws. Setting it swaps the renderer without reloading
+     * anything: the old one is disposed (its elements removed, its GPU pages
+     * handed back), the new one is created over the same root and the same
+     * assets, `pixelRatio` and `clipping` carry over, and the pose the player
+     * holds is drawn again at once.
+     */
+    get mode(): RenderMode;
+    set mode(mode: RenderMode);
+    private create;
+    /** The animation the track is playing, or null before `play`. */
+    get current(): string | null;
+    /** The track time — the running sum of the steps since `play` (or the last `seek`). */
+    get time(): number;
+    /**
+     * Opens `name` on the track at its first pose, the physics reset there. The
+     * pose is drawn on the next `frame`.
+     */
+    play(name: string, options?: {
+        loop?: boolean;
+    }): void;
+    /** Stops stepping; `frame` keeps drawing the pose it holds. */
+    pause(): void;
+    /** Resumes stepping after `pause`. */
+    resume(): void;
+    /**
+     * Moves the track to `time`: the animation is reopened and stepped forward
+     * in `seekStep` increments (the last one shorter) until the track time
+     * reaches `time`. Events and completes crossed on the way are not fired.
+     */
+    seek(time: number): void;
+    /** Adds a listener; returns a function that removes it. */
+    on(type: 'event', listener: Listener<RigEvent>): () => void;
+    on(type: 'complete', listener: Listener<{
+        animation: string;
+    }>): () => void;
+    /**
+     * Advances the track by `dt × timeScale` seconds and draws the pose —
+     * `advance(dt)` then `draw()`.
+     */
+    frame(dt: number): void;
+    /**
+     * Steps the track by `dt × timeScale` seconds and fires the step's listeners,
+     * without drawing. A paused player, or a step of zero, keeps the pose it
+     * holds without re-posing it, so a held rig costs the renderer's dirty
+     * checks and nothing else.
+     */
+    advance(dt: number): void;
+    /** Draws the pose the player holds. */
+    draw(): void;
+    /**
+     * Where `name` is in the pose the player holds — the pose of the last
+     * `advance`/`frame`/`seek`, or the setup pose before `play`. Read off the
+     * core's pose, so it is the same in `dom` and `canvas` mode and costs nothing
+     * until called. An unknown bone is refused by name.
+     */
+    bone(name: string): BoneWorld;
+    /**
+     * The box of what the pose the player holds draws, in world units, Y up:
+     * every region's four corners and every mesh's vertices, in the same frame
+     * record the renderer takes (`posedFrame`). A slot under a clip counts only
+     * inside the clip polygon's own box (an inverse clip removes nothing from
+     * the count); bounding boxes, paths and points are not drawn and do not
+     * count. `null` when nothing draws. The same numbers in `dom` and `canvas`
+     * mode; nothing is computed until called.
+     */
+    bounds(): PoseBounds | null;
+    /** The pose the reads above see: the track's, or the setup pose before `play` (posed once). */
+    private posed;
+    /** The pose the player holds, as the frame record the renderer draws. */
+    posedFrame(): PosedFrame;
+    /** Removes the renderer's elements and hands its GPU pages back. The assets stay the caller's. */
+    dispose(): void;
+    private open;
+    /**
+     * The step's events, then its complete. The core fires the keys
+     * (`pose.events`, in the runtime's order across a wrap) and leaves
+     * `complete` to the player, which derives it from the track time and the
+     * duration: on a looping track, once on a step whose whole cycles rose past
+     * 0 (rig-c `src/core/track.ts`, *Across the wrap*); on a held one, on the
+     * step that reaches the duration. The runtime queues a looping complete
+     * between the keys before the wrap and the keys after it; this player
+     * dispatches it after all of the step's keys.
+     */
+    private dispatch;
+}
+export {};
+//# sourceMappingURL=player.d.ts.map

package/dist/player.d.ts.map

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

package/dist/posedFrame.d.ts

@@ -0,0 +1,99 @@
+/**
+ * The record the DOM tier draws: one posed moment of a rig, every slot the
+ * renderer shows, in draw order.
+ *
+ * The renderer never needed a skeleton. Per slot it needs the kind, four world
+ * corners or world vertices with page UVs and triangles, the bitmap or the
+ * page image with its alpha convention, a tint, a blend mode, a clip polygon
+ * and a stacking position — and every one of those is a field of a pose that
+ * `rig-c/core` computes from the compiled model document, plus that document's
+ * `pages` section. This module is the adapter from one to the other
+ * (`frameOf`), and these types are the whole of what crosses it.
+ *
+ * Coordinates are world space, Y up, exactly as the poser computed them; the
+ * renderer does the Y flip. Nothing here is rounded or re-ordered.
+ */
+export interface PosedFrame {
+    /** Every slot that draws, in draw order. */
+    order: PosedSlot[];
+}
+/** The four blend modes, spelled as the runtime's enum names them. */
+export type BlendMode = 'Normal' | 'Additive' | 'Multiply' | 'Screen';
+/**
+ * A clip polygon in world space and whether it keeps what is outside it.
+ *
+ * One object per clip in force: every slot a clip covers carries the *same*
+ * object, which is how the renderer tells a clip that covers the whole frame
+ * (one `clip-path` on the root) from one that covers a range of it.
+ */
+export interface PosedClip {
+    /** Flat x, y pairs, world space. */
+    polygon: number[];
+    inverse: boolean;
+    /**
+     * The clipping attachment's `convex` flag: a polygon that is not convex is
+     * clipped against its hull rather than decomposed. The DOM tier's CSS
+     * `clip-path` takes the polygon as authored and does not read it; the canvas
+     * mode's triangle cut does (`clipThrough` in `rig-c/core`).
+     */
+    convex: boolean;
+}
+interface PosedSlotCommon {
+    /** The slot's name — the renderer keys its element on it. */
+    slot: string;
+    /** The slot's index in the full draw order (hidden slots included): its z-index. */
+    z: number;
+    blend: BlendMode;
+    /** Slot colour × attachment colour × the player's own colour, r g b a in [0, 1]. */
+    tint: [number, number, number, number];
+    /** The slot's dark (two-colour) tint, where it carries one. The DOM tier cannot draw it. */
+    dark?: [number, number, number];
+    /** The clip in force over this slot, where one is. */
+    clip?: PosedClip;
+}
+/** A rigid slot: an unpacked region bitmap posed by its four world corners. */
+export interface PosedRegion extends PosedSlotCommon {
+    kind: 'region';
+    /** The region drawn — the key into the region bitmap map (a sequence frame's own name). */
+    region: string;
+    /** Four world corners, bottom-left, upper-left, upper-right, bottom-right: x0 y0 … x3 y3. */
+    corners: number[];
+    /**
+     * The page the region sits on — the key into the page image map. The DOM tier
+     * draws the region's own bitmap and never reads it; the canvas mode samples
+     * the page through `uvs`.
+     */
+    page: string;
+    /** Whether the page's texels are premultiplied by their alpha. */
+    pma: boolean;
+    /**
+     * The region's page UVs at its four corners, in the corners' order (u, v
+     * pairs, the page spanning [0, 1]) — the runtime's region UVs, a 90°-packed
+     * region's turn included. The same array object from frame to frame for the
+     * same region.
+     */
+    uvs: number[];
+}
+/** A deform slot: world vertices over page UVs, rastered from the page image. */
+export interface PosedMesh extends PosedSlotCommon {
+    kind: 'mesh';
+    /** The page drawn — the key into the page image map. */
+    page: string;
+    /** Whether the page's texels are premultiplied by their alpha. */
+    pma: boolean;
+    /** World vertices, flat x, y pairs. */
+    vertices: number[];
+    /**
+     * Page UVs, flat u, v pairs, the page spanning [0, 1]. The same array object
+     * from frame to frame for the same region and attachment, so the renderer
+     * can tell a mesh whose texture did not change by identity.
+     */
+    uvs: number[];
+    /** Triangle indices into `vertices`, three per triangle. Stable by identity like `uvs`. */
+    triangles: number[];
+    /** The sequence frame drawn (0 for an attachment with no series). */
+    sequence: number;
+}
+export type PosedSlot = PosedRegion | PosedMesh;
+export {};
+//# sourceMappingURL=posedFrame.d.ts.map

package/dist/posedFrame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"posedFrame.d.ts","sourceRoot":"","sources":["../src/posedFrame.ts"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,UAAU;IACzB,4CAA4C;IAC5C,KAAK,EAAE,SAAS,EAAE,CAAC;CACpB;AAED,sEAAsE;AACtE,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,UAAU,GAAG,UAAU,GAAG,QAAQ,CAAC;AAEtE;;;;;;GAMG;AACH,MAAM,WAAW,SAAS;IACxB,oCAAoC;IACpC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB;;;;;OAKG;IACH,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,UAAU,eAAe;IACvB,6DAA6D;IAC7D,IAAI,EAAE,MAAM,CAAC;IACb,oFAAoF;IACpF,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,SAAS,CAAC;IACjB,oFAAoF;IACpF,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACvC,4FAA4F;IAC5F,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,sDAAsD;IACtD,IAAI,CAAC,EAAE,SAAS,CAAC;CAClB;AAED,+EAA+E;AAC/E,MAAM,WAAW,WAAY,SAAQ,eAAe;IAClD,IAAI,EAAE,QAAQ,CAAC;IACf,2FAA2F;IAC3F,MAAM,EAAE,MAAM,CAAC;IACf,6FAA6F;IAC7F,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,kEAAkE;IAClE,GAAG,EAAE,OAAO,CAAC;IACb;;;;;OAKG;IACH,GAAG,EAAE,MAAM,EAAE,CAAC;CACf;AAED,iFAAiF;AACjF,MAAM,WAAW,SAAU,SAAQ,eAAe;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,wDAAwD;IACxD,IAAI,EAAE,MAAM,CAAC;IACb,kEAAkE;IAClE,GAAG,EAAE,OAAO,CAAC;IACb,uCAAuC;IACvC,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB;;;;OAIG;IACH,GAAG,EAAE,MAAM,EAAE,CAAC;IACd,2FAA2F;IAC3F,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,qEAAqE;IACrE,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,MAAM,SAAS,GAAG,WAAW,GAAG,SAAS,CAAC"}

package/package.json

@@ -1,19 +1,23 @@
 {
   "name": "rig-play",
-  "version": "0.8.0",
-  "description": "Render Spine skeletal animations as plain DOM — rigid slots as <img> posed by CSS matrix, deform meshes on small per-part canvases, interleaved in one stacking context.",
+  "version": "1.1.0",
+  "description": "Plays skeleton.model.json written by rigc build as plain DOM elements — rigid slots as <img> posed by CSS matrix, deform meshes on small per-part canvases — or as one canvas.",
   "type": "module",
   "license": "MIT",
   "author": "firejune",
   "repository": {
     "type": "git",
-    "url": "https://github.com/firejune/spine-html.git"
+    "url": "https://github.com/firejune/rig-play.git"
   },
-  "homepage": "https://github.com/firejune/spine-html#readme",
-  "bugs": "https://github.com/firejune/spine-html/issues",
+  "homepage": "https://github.com/firejune/rig-play#readme",
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/firejune"
+  },
+  "bugs": "https://github.com/firejune/rig-play/issues",
   "keywords": [
-    "spine",
-    "spine2d",
+    "rigc",
+    "rig-c",
     "skeletal-animation",
     "mesh-deformation",
     "dom",
@@ -29,10 +33,6 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
-    },
-    "./binary": {
-      "types": "./dist/binary.d.ts",
-      "import": "./dist/binary.js"
     }
   },
   "files": [
@@ -45,9 +45,7 @@
     "dev": "vite",
     "prebuild": "bash scripts/fetch-assets.sh",
     "build": "tsc --noEmit && vite build",
-    "prebuild:pages": "bash scripts/fetch-assets.sh",
-    "build:pages": "vite build",
-    "build:lib": "rm -rf dist && tsc -p tsconfig.build.json",
+    "build:lib": "rm -rf dist && node scripts/build-lib.mjs dist",
     "prepublishOnly": "npm run build:lib",
     "preview": "vite preview",
     "test": "playwright test",
@@ -56,14 +54,10 @@
     "bench:build": "bash scripts/fetch-assets.sh && vite build --config bench/vite.config.ts",
     "fetch-assets": "bash scripts/fetch-assets.sh"
   },
-  "peerDependencies": {
-    "@esotericsoftware/spine-core": ">=4.0.0 <4.4.0"
-  },
   "devDependencies": {
-    "@esotericsoftware/spine-core": "^4.3.13",
-    "@esotericsoftware/spine-webgl": "4.3.13",
     "@playwright/test": "1.62.1",
     "@types/node": "^22",
+    "rig-c": "2.35.0",
     "typescript": "^5.6.0",
     "vite": "^6.0.0"
   }