rig-play 0.8.0 → 1.1.0

package/dist/CanvasRenderer.d.ts

@@ -0,0 +1,139 @@
+import type { PosedFrame } from './posedFrame.js';
+/** What actually drew the last frame of a `CanvasRenderer`. */
+export type CanvasBackend = 'webgl' | 'canvas2d';
+/** A rectangle of world space, Y up: `x`, `y` is its bottom-left corner. */
+export interface CanvasViewport {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * Renders a posed frame (`PosedFrame`) into **one `<canvas>`** — the canvas
+ * render mode, beside the DOM tier (`DomRenderer`) and with the same
+ * `render(frame)` interface.
+ *
+ * Every slot is drawn as textured triangles straight from its atlas page — a
+ * region as two triangles over its four corners and its page UVs, a mesh as its
+ * own triangles — through the **shared module-level WebGL context** of the mesh
+ * blitter (`MeshGlBlitter.ts`), into one rect of its offscreen buffer, and the
+ * rect is copied onto this renderer's visible canvas with one `drawImage`. No
+ * context is created per renderer, so any number of players draw under the
+ * browser's ~16-context cap, and the page textures are shared and
+ * reference-counted with every other renderer on the page.
+ *
+ * - **Tint** (slot × attachment × the player's colour) is a vertex colour,
+ *   premultiplied by its alpha; the **dark** (two-colour) tint is a second
+ *   vertex colour, carried only when some slot of the frame has one.
+ * - **Blend** is batch state: a run of triangles ends wherever the page or the
+ *   blend mode changes (`drawCalls`, and `blendFlushes` for the blend changes).
+ *   The blends are composed inside this canvas's own rect, which starts
+ *   transparent — an additive or multiply slot meets the slots under it, not
+ *   the page behind the canvas.
+ * - **Clipping** is the core's cut: every triangle a clip covers goes through
+ *   `clipThrough` from `rig-c/core` (convex polygons by the runtime's measured
+ *   rule, concave ones into convex pieces, inverse clips as the hull's
+ *   outside). No stencil, no `clip-path`.
+ * - **Projection**: the canvas covers a rect of the root's own coordinates
+ *   (world x, world −y — the DOM tier's frame), so a world point lands at
+ *   `((x − left) · pixelRatio, (−y − top) · pixelRatio)` device px. That rect
+ *   is the caller's `viewport` when set, and otherwise grows to cover what the
+ *   frames draw (grow-only, so steady animation reallocates nothing).
+ * - **Dirty-skip**: a frame whose record equals the last one drawn — vertex
+ *   arrays, tints, order, clips, pages — draws nothing (`framesReused`).
+ *
+ * When WebGL is unavailable or the shared context is lost, the frame is drawn
+ * on the same visible canvas with canvas2d: regions by `drawImage` under their
+ * affine, meshes and clipped pieces by the DOM tier's per-triangle mapping.
+ * That fallback multiplies **alpha only** — RGB and dark tints are not drawn
+ * there (`ctx.filter` is not available on Safari) — and it is a safety net,
+ * not the measured path.
+ */
+export declare class CanvasRenderer {
+    private readonly root;
+    private readonly pages;
+    /** Backing-store pixels per root CSS pixel; defaults to the device pixel ratio. Fold a root scale in, as for the DOM tier. */
+    pixelRatio: number;
+    /** Apply the clips the frame carries (default). False draws every slot unclipped and counts the clips in `clipSkipCount`. */
+    clipping: boolean;
+    /**
+     * The world rect the canvas covers. Null (default) sizes it from the frames
+     * themselves: it grows to cover everything drawn and never shrinks. Set it to
+     * pin the canvas to a stage box; what falls outside is not drawn.
+     */
+    viewport: CanvasViewport | null;
+    /** The backend to draw with: 'webgl' (default) through the shared context, or 'canvas2d' to force the fallback. */
+    backend: CanvasBackend;
+    /** What drew the last frame (or would have, had it not been reused). */
+    backendActive: CanvasBackend;
+    /** The visible canvas — the renderer's one element in the root. */
+    readonly canvas: HTMLCanvasElement;
+    /** Draw calls issued last frame — one per run of one page under one blend. */
+    drawCalls: number;
+    /** Of those runs, how many began because the blend mode changed. */
+    blendFlushes: number;
+    /** Triangles drawn last frame, clipped pieces counted as cut. */
+    trianglesDrawn: number;
+    /** 1 when the last render() found the record unchanged and drew nothing, else 0. */
+    framesReused: number;
+    /** Blits onto the visible canvas last frame (0 or 1). */
+    blits: number;
+    /** Visible-canvas backing reallocations last frame; settles at zero. */
+    canvasReallocCount: number;
+    /** Distinct clips applied last frame. */
+    clipCount: number;
+    /** Clips in the frame not applied last frame: `clipping` off, fewer than three points, or a polygon the core refuses to cut. */
+    clipSkipCount: number;
+    private readonly ctx;
+    /** The rect in root units the canvas covers: left, top, right, bottom (Y down). Empty until the first frame. */
+    private left;
+    private top;
+    private right;
+    private bottom;
+    private hasRect;
+    private backingW;
+    private backingH;
+    private backingRatio;
+    private data;
+    private readonly runs;
+    /** Pages retained from the shared blitter, one retain each, released by dispose(). */
+    private readonly glPages;
+    /** The dirty signature of the last frame drawn: its numbers, and the objects it compares by identity. */
+    private sig;
+    private sigLength;
+    private sigRefs;
+    private nextSig;
+    private nextRefs;
+    /**
+     * @param root Positioned element that becomes the skeleton origin, exactly as
+     *   for `DomRenderer`: the canvas is appended to it and placed in its own
+     *   coordinates; layout and scaling of the root belong to the caller.
+     * @param pages Page images keyed by page name — `PosedRegion.page` and
+     *   `PosedMesh.page`. Read on every draw.
+     */
+    constructor(root: HTMLElement, pages: ReadonlyMap<string, HTMLImageElement>);
+    /** Grows the automatic viewport to cover `box` (world units, Y up) ahead of the frames reaching it. */
+    reserve(box: CanvasViewport): void;
+    /** Draws one frame. */
+    render(frame: PosedFrame): void;
+    /** Removes the canvas from the root and hands the pages it uploaded back to the shared blitter. Idempotent. */
+    dispose(): void;
+    private growTo;
+    private setRect;
+    /** The backing store at `rect × pixelRatio`; reallocated only when that changes. */
+    private sizeBacking;
+    /** Writes this frame's signature and compares it with the last one drawn; keeps it when it differs. */
+    private signatureChanged;
+    /** The clip counters for a reused frame — what drawing it would have counted. */
+    private countClips;
+    private stride;
+    /**
+     * The slot's triangles in world space with their page UVs — cut by the clip
+     * over it when one applies — or null when the slot draws nothing.
+     */
+    private piecesOf;
+    /** Fills `data` and `runs` for the GL path. */
+    private buildVertices;
+    private draw2d;
+}
+//# sourceMappingURL=CanvasRenderer.d.ts.map

package/dist/CanvasRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CanvasRenderer.d.ts","sourceRoot":"","sources":["../src/CanvasRenderer.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAwB,UAAU,EAAa,MAAM,iBAAiB,CAAC;AAEnF,+DAA+D;AAC/D,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,UAAU,CAAC;AAEjD,4EAA4E;AAC5E,MAAM,WAAW,cAAc;IAC7B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAYD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,qBAAa,cAAc;IAgEvB,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,KAAK;IAhExB,8HAA8H;IAC9H,UAAU,SAA+D;IACzE,6HAA6H;IAC7H,QAAQ,UAAQ;IAChB;;;;OAIG;IACH,QAAQ,EAAE,cAAc,GAAG,IAAI,CAAQ;IACvC,mHAAmH;IACnH,OAAO,EAAE,aAAa,CAAW;IACjC,wEAAwE;IACxE,aAAa,EAAE,aAAa,CAAW;IACvC,mEAAmE;IACnE,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAC;IAEnC,8EAA8E;IAC9E,SAAS,SAAK;IACd,oEAAoE;IACpE,YAAY,SAAK;IACjB,iEAAiE;IACjE,cAAc,SAAK;IACnB,oFAAoF;IACpF,YAAY,SAAK;IACjB,yDAAyD;IACzD,KAAK,SAAK;IACV,wEAAwE;IACxE,kBAAkB,SAAK;IACvB,yCAAyC;IACzC,SAAS,SAAK;IACd,gIAAgI;IAChI,aAAa,SAAK;IAElB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAkC;IACtD,gHAAgH;IAChH,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,GAAG,CAAK;IAChB,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,YAAY,CAAM;IAC1B,OAAO,CAAC,IAAI,CAA0B;IACtC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAkB;IACvC,sFAAsF;IACtF,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA+B;IACvD,yGAAyG;IACzG,OAAO,CAAC,GAAG,CAAyB;IACpC,OAAO,CAAC,SAAS,CAAM;IACvB,OAAO,CAAC,OAAO,CAAiB;IAChC,OAAO,CAAC,OAAO,CAAyB;IACxC,OAAO,CAAC,QAAQ,CAAiB;IAEjC;;;;;;OAMG;gBAEgB,IAAI,EAAE,WAAW,EACjB,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAgB/D,uGAAuG;IACvG,OAAO,CAAC,GAAG,EAAE,cAAc,GAAG,IAAI;IAIlC,uBAAuB;IACvB,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IAuD/B,+GAA+G;IAC/G,OAAO,IAAI,IAAI;IAYf,OAAO,CAAC,MAAM;IAkBd,OAAO,CAAC,OAAO;IAUf,oFAAoF;IACpF,OAAO,CAAC,WAAW;IAkBnB,uGAAuG;IACvG,OAAO,CAAC,gBAAgB;IAoExB,iFAAiF;IACjF,OAAO,CAAC,UAAU;IAalB,OAAO,CAAC,MAAM,CAAa;IAE3B;;;OAGG;IACH,OAAO,CAAC,QAAQ;IA4BhB,+CAA+C;IAC/C,OAAO,CAAC,aAAa;IAmErB,OAAO,CAAC,MAAM;CAmEf"}

package/dist/{SpineHtmlRenderer.d.ts → DomRenderer.d.ts}

@@ -1,14 +1,14 @@
-import { type Skeleton } from '@esotericsoftware/spine-core';
 import { type RegionImage } from './DomTexture.js';
+import type { PosedFrame } from './posedFrame.js';
 /** Rasterizer used for the mesh (deform) tier. */
 export type MeshBackend = 'canvas2d' | 'webgl';
 /**
- * Renders a spine-core Skeleton as DOM, split by slot type:
+ * Renders a posed frame (`PosedFrame`) as DOM, split by slot kind:
  *
- * - Region attachments (rigid parts) become one absolutely-positioned <img>
+ * - Region slots (rigid parts) become one absolutely-positioned <img>
  *   posed with a single CSS matrix() write per frame — exact, since bone
  *   transforms are affine.
- * - Mesh attachments (deform parts) each get a small per-part <canvas> sized
+ * - Mesh slots (deform parts) each get a small per-part <canvas> sized
  *   to the mesh's world bounding box, redrawn per frame — either with the
  *   standard per-triangle clip+transform+drawImage mapping (default), or via
  *   a shared offscreen WebGL canvas that rect-blits into the same per-part
@@ -17,48 +17,50 @@ export type MeshBackend = 'canvas2d' | 'webgl';
  *
  * Both element kinds share one stacking context, so draw order interleaves
  * freely via z-index (rear hair canvas < torso img < front hair canvas).
- * RGB tint (skeleton × slot × attachment color) is applied per element with
- * an SVG feColorMatrix reference filter — exact channel multiply, works the
- * same on <img> and <canvas>. Dark (two-color) tint is not expressible that
- * way and is unsupported. Clipping attachments become a CSS clip-path per
- * element, in that element's own local frame, on spine-core's semantics — one
- * active clip at a time, ending at the end slot inclusive (see `clipping`).
+ * The RGB tint the frame carries (slot × attachment × the player's colour) is
+ * applied per element with an SVG feColorMatrix reference filter — exact
+ * channel multiply, works the same on <img> and <canvas>. Dark (two-color)
+ * tint is not expressible that way and is unsupported. A clip the frame
+ * carries becomes a CSS clip-path per element, in that element's own local
+ * frame (see `clipping`) — which slots a clip covers is decided by the poser's
+ * adapter (`frameOf`), not here.
  *
- * Coordinate mapping: Spine is Y-up, CSS is Y-down — world Y is negated.
- * spine-core computes everything (bones, constraints, physics, deformed
- * vertices) on the CPU; this class only draws.
+ * Coordinate mapping: the frame is world space, Y-up; CSS is Y-down — world Y
+ * is negated. The poser computes everything (bones, constraints, physics,
+ * deformed vertices) on the CPU; this class only draws.
  */
-export declare class SpineHtmlRenderer {
+export declare class DomRenderer {
     private readonly root;
     private readonly regionImages;
+    private readonly pages;
     /**
-     * Apply clipping attachments (default). Each element drawn inside an active
+     * Apply the clips the frame carries (default). Each element drawn inside a
      * clip gets a CSS `clip-path` in its own local frame — an element-level
      * feature, so both mesh backends see exactly the same thing and neither
      * raster path knows clipping exists.
      *
-     * spine-core's semantics, not an approximation of them: one clip is active
-     * at a time (a second clipping attachment met while one is active is
-     * ignored, as SkeletonClipping.clipStart does), a clip applies to the slots
-     * drawn after its own slot through its end slot inclusive, and an end slot
-     * that is the clip's own slot — or one already passed — never ends it, so
-     * the clip runs to the end of the draw order. That last case is the
-     * whole-skeleton clip, and it takes a fast path: one `clip-path` on the root
-     * instead of one per element. The root is the caller's element, so its
-     * inline `clip-path` is borrowed — saved on the first write and restored
-     * when the clip stops covering the frame, when `clipping` goes false, and by
-     * `dispose()`.
+     * Which slots a clip covers is the frame's, decided by the adapter on the
+     * runtime's semantics (`clipCover` in posedFrame.ts: one clip in force at a
+     * time, a second one met while one is in force ignored, a clip covering the
+     * slots after its own through its end slot inclusive, an end slot that is
+     * the clip's own slot — or one already passed — never ending it). A clip
+     * that covers every slot of the frame is the whole-skeleton clip, and it
+     * takes a fast path: one `clip-path` on the root instead of one per element.
+     * The root is the caller's element, so its inline `clip-path` is borrowed —
+     * saved on the first write and restored when the clip stops covering the
+     * frame, when `clipping` goes false, and by `dispose()`.
      *
      * False restores the pre-0.6 behaviour: clips are counted in clipSkipCount
      * and nothing is clipped, with any clip-path this renderer wrote removed.
      */
     clipping: boolean;
-    /** Clipping attachments applied last frame. */
+    /** Clips applied last frame — distinct clip polygons over the drawn slots. */
     clipCount: number;
     /**
-     * Clipping attachments NOT applied last frame: `clipping` is false, another
-     * clip was already active (spine-core ignores the second one), the slot's
-     * bone is inactive, or the polygon has fewer than three points.
+     * Clips in the frame NOT applied last frame: `clipping` is false, or the
+     * polygon has fewer than three points. A clip the runtime itself ignores (a
+     * second one met while one is in force, one on an inactive bone) never
+     * reaches the frame, so it is not counted here.
      */
     clipSkipCount: number;
     /**
@@ -110,14 +112,9 @@ export declare class SpineHtmlRenderer {
     meshBackend: MeshBackend;
     /** Backend that actually rasterized the mesh tier during the last render(). */
     meshBackendActive: MeshBackend;
-    /**
-     * How this renderer reaches spine-core, picked from the first skeleton it is
-     * handed and then reused — see coreCompat.ts. Null until then, because the
-     * constructor has no skeleton to look at and the installed core is not
-     * knowable from the root element.
-     */
-    private core;
     private readonly views;
+    /** Counts render() calls: the stamp a view drawn this frame carries (`SlotView.drawnIn`). */
+    private frameNumber;
     private readonly pendingJobs;
     private readonly pendingViews;
     /**
@@ -126,16 +123,22 @@ export declare class SpineHtmlRenderer {
      * that never leaves canvas2d holds nothing and gives nothing back.
      */
     private glPages;
+    /**
+     * World vertices copied out of the frame. Float32, as the rigid and mesh
+     * paths have always read them: the raster, the dirty signature and the
+     * clip-path quantization below are calibrated on single-precision
+     * coordinates, and the frame's doubles are rounded here once rather than
+     * changing what those paths see.
+     */
     private scratchVertices;
     private tintDefs;
-    /** The clip in force at the current point of the draw order, if any. */
-    private clipAttachment;
-    private clipEndSlot;
+    /** The clip whose polygon is loaded in `clipPolygon`, if any. */
+    private clipActive;
+    /** The clips counted so far this frame, applied or skipped — one count each. */
+    private readonly clipsSeen;
     private clipInverse;
     /** True while the active clip is served by one clip-path on the root. */
     private clipOnRoot;
-    /** Whether any element has been drawn yet this frame (the fast-path test). */
-    private drewAnything;
     /** The active clip polygon in CSS space (Y already negated), flat x,y. */
     private clipPolygon;
     private clipPolygonLength;
@@ -151,9 +154,13 @@ export declare class SpineHtmlRenderer {
      * @param root Positioned element (e.g. position:absolute) that becomes the
      *   skeleton origin. The renderer only appends slot elements to it — layout
      *   and scaling of the root belong to the caller.
-     * @param regionImages Unpacked per-region bitmaps (for the rigid tier).
+     * @param regionImages Unpacked per-region bitmaps (for the rigid tier),
+     *   keyed by region name — `PosedRegion.region`.
+     * @param pages Page images (for the mesh tier), keyed by page name —
+     *   `PosedMesh.page`. Read on every mesh draw, so a caller may fill it after
+     *   construction.
      */
-    constructor(root: HTMLElement, regionImages: Map<string, RegionImage>);
+    constructor(root: HTMLElement, regionImages: ReadonlyMap<string, RegionImage>, pages?: ReadonlyMap<string, HTMLImageElement>);
     /**
      * Backing-store pixels currently allocated across the mesh canvases
      * (Σ width × height). Computed on demand from the views — nothing is
@@ -204,7 +211,12 @@ export declare class SpineHtmlRenderer {
      * @returns the pixel ratio now in effect (the current one if nothing moved).
      */
     syncPixelRatio(): number;
-    render(skeleton: Skeleton): void;
+    /**
+     * Draws one frame. Slots the frame does not carry — no attachment, a
+     * clipping attachment, an inactive bone, a kind the DOM tier does not draw —
+     * are hidden, their elements kept for when they draw again.
+     */
+    render(frame: PosedFrame): void;
     /**
      * Removes every element this renderer added to the root (slot elements and
      * the tint filter defs), restores the root's own inline `clip-path` if the
@@ -297,27 +309,20 @@ export declare class SpineHtmlRenderer {
      */
     private drawTriangle;
     /**
-     * Begins a clip, mirroring SkeletonClipping.clipStart — whose first line is
-     * `if (this.clipAttachment) return`, so a second clipping attachment met
-     * while one is active is ignored rather than nested.
-     *
-     * The polygon is spine-core's: computeWorldVertices gives it in world space
-     * each frame, and the only thing done to it here is the Y negation the rest
-     * of the renderer already applies. It is NOT convexified or triangulated the
-     * way the CPU clipper does — CSS `polygon()` takes a concave polygon
-     * directly, so the decomposition that exists to feed a triangle rasterizer
-     * has no job here.
-     */
-    private clipStart;
-    /**
-     * Ends the active clip if this slot is its end slot, called after the slot
-     * has been drawn so that the end slot is itself clipped. Every other slot is
-     * ignored, exactly as SkeletonClipping.clipEnd ignores it.
+     * Makes `clip` the clip in force for the slot about to be drawn, loading its
+     * polygon when it is not the one already loaded. Each clip object is counted
+     * once per frame — in clipCount when applied, in clipSkipCount when
+     * `clipping` is off or the polygon has fewer than three points (no clip is
+     * in force then, so the slot draws unclipped, as the runtime would).
      *
-     * This cannot fire for a clip on the root fast path: that path is only taken
-     * when no slot ahead of the clip carries its end slot.
+     * The polygon is the poser's world-space one, and the only things done to it
+     * here are the single-precision read the vertex paths share and the Y
+     * negation the rest of the renderer already applies. It is NOT convexified
+     * or triangulated the way the CPU clipper does — CSS `polygon()` takes a
+     * concave polygon directly, so the decomposition that exists to feed a
+     * triangle rasterizer has no job here.
      */
-    private clipEnd;
+    private useClip;
     /**
      * Writes (or clears) this element's clip-path. `a…f` is the element's own
      * CSS transform, and the world polygon is carried through its INVERSE:
@@ -341,4 +346,4 @@ export declare class SpineHtmlRenderer {
     private view;
     private hide;
 }
-//# sourceMappingURL=SpineHtmlRenderer.d.ts.map
+//# sourceMappingURL=DomRenderer.d.ts.map

package/dist/DomRenderer.d.ts.map

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

package/dist/DomTexture.d.ts

@@ -1,13 +1,29 @@
-import { Texture, TextureAtlas, type TextureFilter, type TextureWrap } from '@esotericsoftware/spine-core';
 /**
- * Minimal Texture implementation for the DOM renderer. spine-core only needs
- * it as a handle attached to atlas pages; filtering/wrapping are GPU concepts
- * with no DOM equivalent, so they are no-ops.
+ * Where one region sits on its page — the fields of a model document's
+ * `pages[].regions[]` entry (`ModelPageRegion` in rig-c) that a cut reads.
+ * `width` and `height` are the artwork's own, unrotated: a region packed at
+ * `degrees: 90` occupies a `height × width` rect on the page.
  */
-export declare class DomTexture extends Texture {
-    setFilters(_minFilter: TextureFilter, _magFilter: TextureFilter): void;
-    setWraps(_uWrap: TextureWrap, _vWrap: TextureWrap): void;
-    dispose(): void;
+export interface PageRegion {
+    name: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    degrees: number;
+}
+/**
+ * One page of the layout `unpackRegions` cuts from — a model document's
+ * `pages[]` entry. `width`/`height` are the page's *declared* size (the atlas
+ * `size:` line the build wrote), not necessarily the image's.
+ */
+export interface PageLayout {
+    name: string;
+    width: number;
+    height: number;
+    /** Whether the page's texels are premultiplied by their alpha (absent: false). */
+    pma?: boolean;
+    regions: readonly PageRegion[];
 }
 export interface RegionImage {
     /**
@@ -75,9 +91,12 @@ export declare function straightAlphaDerivations(): number;
  */
 export declare function straightAlphaSource(page: HTMLImageElement, pma: boolean): PageSource;
 /**
- * Cuts every atlas region out of the page image into its own bitmap once at
- * load time, restoring 90° packing rotation, so the per-frame path never
- * touches a canvas. Returns image URLs keyed by region name.
+ * Cuts every region of a page layout — a model document's `pages` section —
+ * out of its page image into its own bitmap once at load time, restoring 90°
+ * packing rotation, so the per-frame path never touches a canvas. Returns
+ * image URLs keyed by region name. `pageImages` is keyed by page name.
+ * `loadModel` calls this; it is exported for callers whose page images do not
+ * come from a URL.
  *
  * This is a loading-pipeline step, not a rendering step: after this runs,
  * rendering is pure DOM (one <img> per slot, one CSS matrix write per frame).
@@ -111,8 +130,9 @@ export declare function straightAlphaSource(page: HTMLImageElement, pma: boolean
  *
  * Concurrency changes nothing a caller can observe:
  *
- * - **Order.** The returned map is keyed in `atlas.regions` order whatever
- *   order the blobs arrive in — the map is built after the cuts settle, from
+ * - **Order.** The returned map is keyed in layout order — pages in order,
+ *   each page's regions in order, which is the atlas's own order — whatever
+ *   order the blobs arrive in: the map is built after the cuts settle, from
  *   the region list, not from the arrivals.
  * - **Duplicate names.** The last region of a given name in atlas order wins,
  *   and the shadowed URL is revoked (and dropped from the ledger) rather than
@@ -131,7 +151,7 @@ export declare function straightAlphaSource(page: HTMLImageElement, pma: boolean
  * unpackRegions() with a revokeRegions(); a caller that loads once for the
  * page lifetime can ignore it.
  */
-export declare function unpackRegions(atlas: TextureAtlas, pageImages: Map<string, HTMLImageElement>): Promise<Map<string, RegionImage>>;
+export declare function unpackRegions(pages: readonly PageLayout[], pageImages: ReadonlyMap<string, HTMLImageElement>): Promise<Map<string, RegionImage>>;
 /**
  * Frees the blob URLs unpackRegions minted for `images` — the counterpart of
  * unpackRegions, to call once the skeletons using them are gone (after

package/dist/DomTexture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DomTexture.d.ts","sourceRoot":"","sources":["../src/DomTexture.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,YAAY,EAEZ,KAAK,aAAa,EAClB,KAAK,WAAW,EACjB,MAAM,8BAA8B,CAAC;AAEtC;;;;GAIG;AACH,qBAAa,UAAW,SAAQ,OAAO;IACrC,UAAU,CAAC,UAAU,EAAE,aAAa,EAAE,UAAU,EAAE,aAAa,GAAG,IAAI;IACtE,QAAQ,CAAC,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,WAAW,GAAG,IAAI;IACxD,OAAO,IAAI,IAAI;CAChB;AAED,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ;;;;;;;;;OASG;IACH,KAAK,EAAE,MAAM,CAAC;IACd,oDAAoD;IACpD,MAAM,EAAE,MAAM,CAAC;CAChB;AAkBD;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,gBAAgB,GAAG,iBAAiB,CAAC;AAqC9D;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,IAAI,MAAM,CAEjD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,gBAAgB,EAAE,GAAG,EAAE,OAAO,GAAG,UAAU,CAcpF;AA+RD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,YAAY,EACnB,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,GACxC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CA0EnC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,IAAI,CAEpE"}
+{"version":3,"file":"DomTexture.d.ts","sourceRoot":"","sources":["../src/DomTexture.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;GAIG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,kFAAkF;IAClF,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,SAAS,UAAU,EAAE,CAAC;CAChC;AAQD,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ;;;;;;;;;OASG;IACH,KAAK,EAAE,MAAM,CAAC;IACd,oDAAoD;IACpD,MAAM,EAAE,MAAM,CAAC;CAChB;AAkBD;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,gBAAgB,GAAG,iBAAiB,CAAC;AAqC9D;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,IAAI,MAAM,CAEjD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,gBAAgB,EAAE,GAAG,EAAE,OAAO,GAAG,UAAU,CAcpF;AAgSD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,SAAS,UAAU,EAAE,EAC5B,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,GAChD,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CA0EnC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,IAAI,CAEpE"}

package/dist/MeshGlBlitter.d.ts

@@ -29,7 +29,16 @@
  * release deletes the GL texture (a later job re-uploads it). The cache is
  * keyed weakly by the page image, so a consumer that never disposes still
  * loses nothing but GPU memory — this object never pins the caller's image.
+ *
+ * The canvas render mode (`CanvasRenderer`) draws through the same context: a
+ * `FrameJob` is a whole player's frame — every region and mesh as textured,
+ * vertex-coloured triangles in draw order, with the blend mode as batch state —
+ * into one rect, blitted onto that player's one visible canvas. It has its own
+ * program (colour and optional dark attributes) so the mesh tier's program and
+ * its output stay exactly what they were; both share the page textures and
+ * their reference counts.
  */
+import type { BlendMode } from './posedFrame.js';
 export interface MeshBlitJob {
     /** Destination per-part canvas; the blit clears its full backing first. */
     canvas: HTMLCanvasElement;
@@ -54,6 +63,38 @@ export interface MeshBlitJob {
     width: number;
     height: number;
 }
+/**
+ * One run of a frame job's triangles: a stretch of the vertex data that samples
+ * one page under one blend mode — one draw call.
+ */
+export interface FrameRun {
+    page: HTMLImageElement;
+    /** `page.pma`, as for MeshBlitJob. */
+    pma: boolean;
+    blend: BlendMode;
+    /** First vertex of the run (not float) in `FrameJob.data`. */
+    first: number;
+    /** Vertices in the run — three per triangle. */
+    count: number;
+}
+/**
+ * A whole frame of one player (the canvas render mode): unindexed triangles,
+ * interleaved per vertex as
+ * `x, y, u, v, r, g, b, a` (stride 8) or `x, y, u, v, r, g, b, a, dr, dg, db`
+ * (stride 11, the two-colour form, only when the frame carries a dark colour).
+ * Positions are device px relative to the job's rect, top-left origin; the
+ * colour is premultiplied by its alpha and so is the dark colour. Drawn into
+ * one rect of the offscreen buffer, then blitted onto `canvas` in one
+ * `drawImage`.
+ */
+export interface FrameJob {
+    canvas: HTMLCanvasElement;
+    width: number;
+    height: number;
+    data: Float32Array;
+    stride: 8 | 11;
+    runs: FrameRun[];
+}
 declare class MeshGlBlitter {
     lost: boolean;
     /**
@@ -65,6 +106,18 @@ declare class MeshGlBlitter {
     private readonly canvas;
     private readonly gl;
     private readonly uResolution;
+    private readonly meshProgram;
+    private readonly meshPos;
+    private readonly meshUV;
+    private readonly frameProgram;
+    private readonly frameResolution;
+    private readonly frameOrigin;
+    private readonly framePos;
+    private readonly frameUV;
+    private readonly frameColor;
+    private readonly frameDark;
+    /** Which program's attribute layout is bound — each flush binds its own. */
+    private bound;
     /**
      * Weak by the page image on purpose: a consumer that forgets dispose()
      * leaks its texture until context loss, but dropping the image still lets
@@ -84,12 +137,25 @@ declare class MeshGlBlitter {
      * cannot fit) so the caller can rasterize the batch on the canvas2d path.
      */
     flush(jobs: MeshBlitJob[]): boolean;
+    /**
+     * Draws one player's frame (the canvas render mode) into a rect of the
+     * offscreen buffer and blits it onto `job.canvas`, whose full backing is
+     * cleared first. Returns false when the context is lost or the rect cannot
+     * fit, so the caller can draw the frame on its canvas2d fallback instead.
+     */
+    flushFrame(job: FrameJob): boolean;
+    /** The mesh tier's layout, [x, y, u, v], and its premultiplied source-over. */
+    private bindMesh;
+    /** The frame layout: [x, y, u, v, r, g, b, a], and [dr, dg, db] at stride 11. */
+    private bindFrame;
+    private disableAttributes;
+    private link;
     /**
      * Declares one more user of `page`. The upload itself stays lazy (the first
      * flush that binds the page does it) — this only counts, so that the last
      * release() can free the texture instead of the module holding it forever.
      * Callers retain once per page and hand the same page back exactly once;
-     * SpineHtmlRenderer keeps that ledger and settles it in dispose().
+     * DomRenderer and CanvasRenderer each keep that ledger and settle it in dispose().
      */
     retain(page: HTMLImageElement): void;
     /**

package/dist/MeshGlBlitter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MeshGlBlitter.d.ts","sourceRoot":"","sources":["../src/MeshGlBlitter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,MAAM,WAAW,WAAW;IAC1B,2EAA2E;IAC3E,MAAM,EAAE,iBAAiB,CAAC;IAC1B,+EAA+E;IAC/E,IAAI,EAAE,gBAAgB,CAAC;IACvB;;;;;OAKG;IACH,GAAG,EAAE,OAAO,CAAC;IACb,mFAAmF;IACnF,QAAQ,EAAE,YAAY,CAAC;IACvB,mDAAmD;IACnD,GAAG,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;IACvB,gDAAgD;IAChD,SAAS,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;IAC7B,uCAAuC;IACvC,KAAK,EAAE,MAAM,CAAC;IACd,iFAAiF;IACjF,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAsCD,cAAM,aAAa;IACjB,IAAI,UAAS;IACb;;;;OAIG;IACH,gBAAgB,SAAK;IAErB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAoC;IAC3D,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAwB;IAC3C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAuB;IACnD;;;;;OAKG;IACH,OAAO,CAAC,QAAQ,CAAgD;IAChE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,UAAU,CAA0B;IAC5C,sDAAsD;IACtD,OAAO,CAAC,KAAK,CAAgB;IAC7B,OAAO,CAAC,KAAK,CAAgB;;IAoD7B;;;;OAIG;IACH,KAAK,CAAC,IAAI,EAAE,WAAW,EAAE,GAAG,OAAO;IAwGnC;;;;;;OAMG;IACH,MAAM,CAAC,IAAI,EAAE,gBAAgB,GAAG,IAAI;IAMpC;;;;;;OAMG;IACH,OAAO,CAAC,IAAI,EAAE,gBAAgB,GAAG,IAAI;IAarC;;;;;OAKG;IACH,OAAO,CAAC,QAAQ;IAMhB,OAAO,CAAC,OAAO;IAYf;;;;;;;;;;OAUG;IACH,OAAO,CAAC,UAAU;CAuCnB;AAID;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,aAAa,GAAG,IAAI,CASvD"}
+{"version":3,"file":"MeshGlBlitter.d.ts","sourceRoot":"","sources":["../src/MeshGlBlitter.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -1,5 +1,7 @@
-export { SpineHtmlRenderer, type MeshBackend } from './SpineHtmlRenderer.js';
-export { DomTexture, revokeRegions, unpackRegions, type RegionImage } from './DomTexture.js';
-export { type AtlasAssets, loadAtlasAssets, type LoadAtlasAssetsOptions, } from './loadAtlasAssets.js';
-export { loadSkeletonAssets, type LoadSkeletonAssetsOptions, loadSkeletonJson, type LoadSkeletonJsonOptions, type SkeletonAssets, } from './loadSkeletonAssets.js';
+export { type CanvasBackend, CanvasRenderer, type CanvasViewport } from './CanvasRenderer.js';
+export { DomRenderer, type MeshBackend } from './DomRenderer.js';
+export { type PageLayout, type PageRegion, type RegionImage, revokeRegions, unpackRegions } from './DomTexture.js';
+export { type LoadModelOptions, loadModel, type ModelAssets, type ModelDocument } from './loadModel.js';
+export { type BoneWorld, type PoseBounds, type RenderMode, type RigEvent, RigPlayer, type RigPlayerOptions } from './player.js';
+export type { BlendMode, PosedClip, PosedFrame, PosedMesh, PosedRegion, PosedSlot, } from './posedFrame.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,KAAK,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC7E,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,aAAa,EAAE,KAAK,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC7F,OAAO,EACL,KAAK,WAAW,EAChB,eAAe,EACf,KAAK,sBAAsB,GAC5B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,kBAAkB,EAClB,KAAK,yBAAyB,EAC9B,gBAAgB,EAChB,KAAK,uBAAuB,EAC5B,KAAK,cAAc,GACpB,MAAM,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC9F,OAAO,EAAE,WAAW,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACjE,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,UAAU,EAAE,KAAK,WAAW,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACnH,OAAO,EAAE,KAAK,gBAAgB,EAAE,SAAS,EAAE,KAAK,WAAW,EAAE,KAAK,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACxG,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,UAAU,EAAE,KAAK,UAAU,EAAE,KAAK,QAAQ,EAAE,SAAS,EAAE,KAAK,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAChI,YAAY,EACV,SAAS,EACT,SAAS,EACT,UAAU,EACV,SAAS,EACT,WAAW,EACX,SAAS,GACV,MAAM,iBAAiB,CAAC"}