@rig-c/play 1.18.0 → 1.20.0

package/dist/DomRenderer.d.ts

@@ -1,5 +1,5 @@
 import type { LiveFrame } from './liveFrame.js';
-import { type RegionImage } from './DomTexture.js';
+import { type AtlasRegion, type RegionImage } from './DomTexture.js';
 import type { PosedFrame } from './posedFrame.js';
 /** Rasterizer used for the mesh (deform) tier. */
 export type MeshBackend = 'canvas2d' | 'webgl';
@@ -40,6 +40,7 @@ export declare class DomRenderer {
     private readonly root;
     private readonly regionImages;
     private readonly pages;
+    private readonly atlasRegions;
     /**
      * 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
@@ -63,6 +64,8 @@ export declare class DomRenderer {
     clipping: boolean;
     /** Clips applied last frame — distinct clip polygons over the drawn slots. */
     clipCount: number;
+    /** Atlas rigid canvases rasterized in the last frame; never includes meshes. */
+    rigidRasterCount: number;
     /**
      * 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
@@ -171,11 +174,13 @@ export declare class DomRenderer {
      *   and scaling of the root belong to the caller.
      * @param regionImages Unpacked per-region bitmaps (for the rigid tier),
      *   keyed by region name — `PosedRegion.region`.
+     * @param atlasRegions Optional page-backed rigid sources, from createAtlasRegions
+     *   or ModelAssets.atlasRegions. A matching entry takes precedence over regionImages.
      * @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: ReadonlyMap<string, RegionImage>, pages?: ReadonlyMap<string, HTMLImageElement>);
+    constructor(root: HTMLElement, regionImages: ReadonlyMap<string, RegionImage>, pages?: ReadonlyMap<string, HTMLImageElement>, atlasRegions?: ReadonlyMap<string, AtlasRegion>);
     /**
      * Backing-store pixels currently allocated across the mesh canvases
      * (Σ width × height). Computed on demand from the views — nothing is

package/dist/DomRenderer.d.ts.map

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

package/dist/DomTexture.d.ts

@@ -46,6 +46,14 @@ export interface RegionImage {
     /** Unpacked height in atlas units — see `width`. */
     height: number;
 }
+/** One region's page-backed source, without an encoded per-region URL. */
+export interface AtlasRegion {
+    readonly page: PageLayout;
+    readonly region: PageRegion;
+    readonly image: HTMLImageElement;
+}
+/** Maps atlas entries in layout order; duplicate names keep the last entry. */
+export declare function createAtlasRegions(pages: readonly PageLayout[], images: ReadonlyMap<string, HTMLImageElement>): Map<string, AtlasRegion>;
 /**
  * Page pixels in the alpha convention a DOM/canvas2d consumer needs: the page
  * image itself, or the derived canvas below when the page is premultiplied.

package/dist/DomTexture.d.ts.map

@@ -1 +1 @@
-{"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;AAuSD;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,MAAM,CAAC;AAE7C,MAAM,WAAW,oBAAoB;IACnC,2BAA2B;IAC3B,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,SAAS,UAAU,EAAE,EAC5B,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,EACjD,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CA4EnC;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;AAED,0EAA0E;AAC1E,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAC;CAClC;AAED,+EAA+E;AAC/E,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,SAAS,UAAU,EAAE,EAC5B,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,GAC5C,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAQ1B;AAwBD;;;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;AAiTD;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,MAAM,CAAC;AAE7C,MAAM,WAAW,oBAAoB;IACnC,2BAA2B;IAC3B,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,SAAS,UAAU,EAAE,EAC5B,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,EACjD,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CA4EnC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,IAAI,CAEpE"}

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { type CanvasBackend, CanvasRenderer, type CanvasViewport } from './CanvasRenderer.js';
 export { DomRenderer, type MeshBackend, type MeshSourceRect } from './DomRenderer.js';
-export { type PageLayout, type PageRegion, type RegionEncoding, type RegionImage, revokeRegions, type UnpackRegionsOptions, unpackRegions } from './DomTexture.js';
+export { type AtlasRegion, createAtlasRegions, type PageLayout, type PageRegion, type RegionEncoding, type RegionImage, revokeRegions, type UnpackRegionsOptions, unpackRegions } from './DomTexture.js';
 export { type LoadModelOptions, loadModel, type ModelAssets, type ModelDocument, readSetupMesh, type RegionLoading, type RigSet, type SetupMesh, type SetupMeshTarget } from './loadModel.js';
 export { type AdjustableBones, type BoneAdjust, type BoneAdjustContext, type BoneLocals, type BoneWorld, type PhysicsParameters, type PhysicsParameterPatch, type PhysicsParameterRead, type PlayOptions, type PoseBounds, type QueueOptions, type RenderMode, type RigComplete, type RigEnvironment, type RigEvent, RigPlayer, type RigPlayerOptions, type SetActivationOptions, type SlotFilter, type SlotIdentity, type SlotIdentityReason, type SlotIdentitySnapshot, type TrackEntry } from './player.js';
 export type { BlendMode, PosedClip, PosedFrame, PosedMesh, PosedRegion, PosedSlot, } from './posedFrame.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"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,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACtF,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,UAAU,EAAE,KAAK,cAAc,EAAE,KAAK,WAAW,EAAE,aAAa,EAAE,KAAK,oBAAoB,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACnK,OAAO,EAAE,KAAK,gBAAgB,EAAE,SAAS,EAAE,KAAK,WAAW,EAAE,KAAK,aAAa,EAAE,aAAa,EAAE,KAAK,aAAa,EAAE,KAAK,MAAM,EAAE,KAAK,SAAS,EAAE,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAC9L,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,UAAU,EAAE,KAAK,iBAAiB,EAAE,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,KAAK,iBAAiB,EAAE,KAAK,qBAAqB,EAAE,KAAK,oBAAoB,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,KAAK,YAAY,EAAE,KAAK,UAAU,EAAE,KAAK,WAAW,EAAE,KAAK,cAAc,EAAE,KAAK,QAAQ,EAAE,SAAS,EAAE,KAAK,gBAAgB,EAAE,KAAK,oBAAoB,EAAE,KAAK,UAAU,EAAE,KAAK,YAAY,EAAE,KAAK,kBAAkB,EAAE,KAAK,oBAAoB,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAC/e,YAAY,EACV,SAAS,EACT,SAAS,EACT,UAAU,EACV,SAAS,EACT,WAAW,EACX,SAAS,GACV,MAAM,iBAAiB,CAAC;AAEzB,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,gBAAgB,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,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACtF,OAAO,EAAE,KAAK,WAAW,EAAE,kBAAkB,EAAE,KAAK,UAAU,EAAE,KAAK,UAAU,EAAE,KAAK,cAAc,EAAE,KAAK,WAAW,EAAE,aAAa,EAAE,KAAK,oBAAoB,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACzM,OAAO,EAAE,KAAK,gBAAgB,EAAE,SAAS,EAAE,KAAK,WAAW,EAAE,KAAK,aAAa,EAAE,aAAa,EAAE,KAAK,aAAa,EAAE,KAAK,MAAM,EAAE,KAAK,SAAS,EAAE,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAC9L,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,UAAU,EAAE,KAAK,iBAAiB,EAAE,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,KAAK,iBAAiB,EAAE,KAAK,qBAAqB,EAAE,KAAK,oBAAoB,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,KAAK,YAAY,EAAE,KAAK,UAAU,EAAE,KAAK,WAAW,EAAE,KAAK,cAAc,EAAE,KAAK,QAAQ,EAAE,SAAS,EAAE,KAAK,gBAAgB,EAAE,KAAK,oBAAoB,EAAE,KAAK,UAAU,EAAE,KAAK,YAAY,EAAE,KAAK,kBAAkB,EAAE,KAAK,oBAAoB,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAC/e,YAAY,EACV,SAAS,EACT,SAAS,EACT,UAAU,EACV,SAAS,EACT,WAAW,EACX,SAAS,GACV,MAAM,iBAAiB,CAAC;AAEzB,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -964,7 +964,8 @@ function clipHalf(input, p, q) {
   return { points: out, cut };
 }
 function clipThrough(shape, vertices, triangles, uvs, clip = clipTriangles, reading = {}) {
-  const plan = clipShapeOf(shape);
+  let plan = clipShapeOf(shape);
+  if (plan.kind === "pieces") plan = clipShapeOf({ ...shape, polygon: shape.polygon.map(Math.fround) });
   if (plan.kind === "refused") return null;
   if (plan.kind === "convex") return clip(plan.polygon, vertices, triangles, uvs);
   const f = Math.fround;
@@ -6703,6 +6704,19 @@ function drawnRegions(doc, shown, order, source) {
   if (unmeasured.length > 0) return { drawn: null, why: `${unmeasured.join("; ")} — which of the two counts the runtime steps it over was not measured` };
   return { drawn, why: null };
 }
+function createAtlasRegions(pages, images) {
+  const result = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    const image = images.get(page.name);
+    if (!image) throw new Error(`Missing page image: ${page.name}`);
+    for (const region of page.regions) result.set(region.name, { page, region, image });
+  }
+  return result;
+}
+function drawAtlasRegion(canvas, entry, ratio) {
+  const plan = planCut(entry, entry.image);
+  paintRegion(canvas, entry, entry.image, plan, ratio);
+}
 const ownedUrls = /* @__PURE__ */ new Set();
 function revokeOwned(url) {
   if (!ownedUrls.delete(url)) return;
@@ -6794,16 +6808,7 @@ async function cutRegion(placed, pageImages, encoding) {
   const plan = planCut(placed, image);
   if (plan.passThrough) return { url: image.src, width: w, height: h };
   const canvas = document.createElement("canvas");
-  canvas.width = plan.cw;
-  canvas.height = plan.ch;
-  const ctx = canvas.getContext("2d");
-  if (!ctx) throw new Error("2d context unavailable");
-  if (region.degrees === 90) {
-    ctx.translate(plan.cw, 0);
-    ctx.rotate(Math.PI / 2);
-  }
-  const source = straightAlphaSource(image, page.pma === true);
-  ctx.drawImage(source, plan.sx, plan.sy, plan.sw, plan.sh, 0, 0, plan.sw, plan.sh);
+  paintRegion(canvas, placed, image, plan);
   if (encoding === "data") return { url: canvas.toDataURL("image/png"), width: w, height: h };
   const blob = await new Promise((resolve, reject) => {
     canvas.toBlob((b) => b ? resolve(b) : reject(new Error("toBlob failed")), "image/png");
@@ -6812,6 +6817,22 @@ async function cutRegion(placed, pageImages, encoding) {
   ownedUrls.add(url);
   return { url, width: w, height: h };
 }
+function paintRegion(canvas, placed, image, plan, ratio) {
+  canvas.width = ratio === void 0 ? plan.cw : Math.min(plan.cw, Math.max(1, Math.ceil(placed.region.width * ratio)));
+  canvas.height = ratio === void 0 ? plan.ch : Math.min(plan.ch, Math.max(1, Math.ceil(placed.region.height * ratio)));
+  const ctx = canvas.getContext("2d");
+  if (!ctx) throw new Error("2d context unavailable");
+  if (ratio !== void 0) {
+    ctx.imageSmoothingQuality = "high";
+    ctx.scale(canvas.width / plan.cw, canvas.height / plan.ch);
+  }
+  if (placed.region.degrees === 90) {
+    ctx.translate(plan.cw, 0);
+    ctx.rotate(Math.PI / 2);
+  }
+  const source = straightAlphaSource(image, placed.page.pma === true);
+  ctx.drawImage(source, plan.sx, plan.sy, plan.sw, plan.sh, 0, 0, plan.sw, plan.sh);
+}
 async function unpackRegions(pages, pageImages, options = {}) {
   const encoding = options.encoding ?? "blob";
   if (encoding !== "blob" && encoding !== "data") throw new Error(`encoding must be 'blob' or 'data', got ${String(options.encoding)}`);
@@ -7403,14 +7424,17 @@ class DomRenderer {
    *   and scaling of the root belong to the caller.
    * @param regionImages Unpacked per-region bitmaps (for the rigid tier),
    *   keyed by region name — `PosedRegion.region`.
+   * @param atlasRegions Optional page-backed rigid sources, from createAtlasRegions
+   *   or ModelAssets.atlasRegions. A matching entry takes precedence over regionImages.
    * @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, regionImages, pages = /* @__PURE__ */ new Map()) {
+  constructor(root, regionImages, pages = /* @__PURE__ */ new Map(), atlasRegions = /* @__PURE__ */ new Map()) {
     this.root = root;
     this.regionImages = regionImages;
     this.pages = pages;
+    this.atlasRegions = atlasRegions;
   }
   /**
    * Apply the clips the frame carries (default). Each element drawn inside a
@@ -7435,6 +7459,8 @@ class DomRenderer {
   clipping = true;
   /** Clips applied last frame — distinct clip polygons over the drawn slots. */
   clipCount = 0;
+  /** Atlas rigid canvases rasterized in the last frame; never includes meshes. */
+  rigidRasterCount = 0;
   /**
    * 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
@@ -7604,6 +7630,7 @@ class DomRenderer {
   render(input) {
     const frame2 = renderFrameOf(input);
     this.clipCount = 0;
+    this.rigidRasterCount = 0;
     this.clipSkipCount = 0;
     this.clipWriteCount = 0;
     this.meshCount = 0;
@@ -7690,16 +7717,10 @@ class DomRenderer {
   }
   // --- rigid tier -----------------------------------------------------------
   renderRegion(slot) {
-    const regionImage = this.regionImages.get(slot.region);
+    const atlas = this.atlasRegions.get(slot.region);
+    const regionImage = atlas ? atlas.region : this.regionImages.get(slot.region);
     if (!regionImage) return null;
-    const view = this.view(slot.slot, "image");
-    const img = view.el;
-    if (view.regionName !== slot.region) {
-      view.regionName = slot.region;
-      img.src = regionImage.url;
-      img.width = regionImage.width;
-      img.height = regionImage.height;
-    }
+    const view = this.view(slot.slot, atlas ? "region-canvas" : "image");
     const corners = slot.corners;
     for (let v = 0; v < 8; v++) regionVertices[v] = corners[v];
     const blx = regionVertices[0], bly = -regionVertices[1];
@@ -7711,6 +7732,23 @@ class DomRenderer {
     const b = (ury - uly) / w;
     const c = (blx - ulx) / h;
     const d = (bly - uly) / h;
+    const effective = this.pixelRatio * Math.max(Math.hypot(a, b), Math.hypot(c, d));
+    const band = effective > 0 && effective < 1 ? 1.25 ** Math.ceil(Math.log(effective) / Math.log(1.25)) : 1;
+    if (view.regionName !== slot.region || atlas && view.regionRatio !== band) {
+      view.regionName = slot.region;
+      view.regionRatio = band;
+      if (atlas) {
+        drawAtlasRegion(view.el, atlas, band < 1 ? band : void 0);
+        view.el.style.width = `${w}px`;
+        view.el.style.height = `${h}px`;
+        this.rigidRasterCount++;
+      } else {
+        const img = view.el;
+        img.src = this.regionImages.get(slot.region).url;
+        img.width = w;
+        img.height = h;
+      }
+    }
     this.setTransform(view, `matrix(${a},${b},${c},${d},${ulx},${uly})`);
     this.applyClip(view, a, b, c, d, ulx, uly, w, h);
     this.applyCommon(view, slot);
@@ -8135,6 +8173,7 @@ class DomRenderer {
         kind,
         el,
         regionName: "",
+        regionRatio: -1,
         visible: false,
         zIndex: -1,
         opacity: 1,
@@ -8944,8 +8983,8 @@ async function loadModel(options) {
     );
   }
   const regions = options.regions ?? "blob";
-  if (regions !== "blob" && regions !== "data" && regions !== "none") {
-    throw new Error(`regions must be 'blob', 'data' or 'none', got ${String(options.regions)}`);
+  if (regions !== "atlas" && regions !== "blob" && regions !== "data" && regions !== "none") {
+    throw new Error(`regions must be 'atlas', 'blob', 'data' or 'none', got ${String(options.regions)}`);
   }
   const fetchImpl = options.fetch ?? globalThis.fetch.bind(globalThis);
   const resolvePage = options.resolvePage ?? resolveAgainstModel;
@@ -8958,7 +8997,7 @@ async function loadModel(options) {
     })
   );
   const sets = await loadSets(fetchImpl, modelUrl, options.setsUrl, read.doc);
-  const regionImages = regions === "none" ? /* @__PURE__ */ new Map() : await unpackRegions(pages, pageImages, { encoding: regions });
+  const regionImages = regions === "none" || regions === "atlas" ? /* @__PURE__ */ new Map() : await unpackRegions(pages, pageImages, { encoding: regions });
   let disposed = false;
   return {
     spec: read.spec,
@@ -8968,6 +9007,7 @@ async function loadModel(options) {
     stage: stageOf(read.doc),
     regions,
     regionImages,
+    atlasRegions: regions === "atlas" ? createAtlasRegions(pages, pageImages) : /* @__PURE__ */ new Map(),
     pageImages,
     document: read,
     dispose() {
@@ -9034,7 +9074,37 @@ function channelValue(curve, i, c, t) {
   const y0 = p[o + q - 1];
   return y0 + (t - x0) / (p[o + q] - x0) * (p[o + q + 1] - y0);
 }
-const RUNTIME_STAGE = 1;
+function compileDeformCurve(keys) {
+  const curve = compileCurve(keys.map((k) => ({ time: k.time, values: [0], curve: "linear", stated: { time: k.stated, values: [0] } })), 1);
+  for (let i = 0; i < keys.length; i++) {
+    const a = keys[i];
+    curve.kinds[i] = a.curve === "linear" ? CURVE_LINEAR : a.curve === "stepped" ? CURVE_STEPPED : CURVE_BEZIER;
+    if (typeof a.curve === "string" || i + 1 === keys.length) continue;
+    const b = keys[i + 1];
+    const c = a.curve;
+    const inner = bezierPolyline(a.stated, 0, c[0], c[1], c[2], c[3], b.stated, DEFORM_CURVE_END);
+    const o = i * POLYLINE;
+    curve.polylines[o] = a.time;
+    curve.polylines[o + 1] = 0;
+    curve.polylines.set(inner, o + 2);
+    curve.polylines[o + POLYLINE - 2] = b.time;
+    curve.polylines[o + POLYLINE - 1] = 1;
+  }
+  return curve;
+}
+function deformFraction(curve, i, t) {
+  if (curve.kinds[i] === CURVE_STEPPED) return 0;
+  if (curve.kinds[i] === CURVE_LINEAR) return (t - curve.times[i]) / (curve.times[i + 1] - curve.times[i]);
+  const p = curve.polylines;
+  const o = i * POLYLINE;
+  let q = 2;
+  while (q < POLYLINE - 2 && p[o + q] < t) q += 2;
+  const x0 = p[o + q - 2], y0 = p[o + q - 1], x1 = p[o + q], y1 = p[o + q + 1];
+  if (q === 2) return y1 * (t - x0) / (x1 - x0);
+  if (q === POLYLINE - 2) return y0 + (1 - y0) * (t - x0) / (x1 - x0);
+  return y0 + (t - x0) / (x1 - x0) * (y1 - y0);
+}
+const RUNTIME_STAGE = 2;
 function missingText(m) {
   return `${m.feature}: ${m.detail}${m.animation === null ? "" : ` (animation "${m.animation}")`}`;
 }
@@ -9178,6 +9248,7 @@ function compileRuntime(doc, options = {}, plant = {}) {
   }
   const attachments = [];
   let vertexCount = 0;
+  let deformCount = 0;
   const sourceOf = sourceOfDoc(doc);
   const attachmentView = plant.attachmentSkin === void 0 ? doc : underSkin(doc, plant.attachmentSkin);
   const resolvedBySlot = doc.slots.map(() => /* @__PURE__ */ new Map());
@@ -9198,7 +9269,7 @@ function compileRuntime(doc, options = {}, plant = {}) {
     if ("conflict" in shown) return { index: -1, missing: ["skin-conflict", `slot "${slot.name}" placeholder "${placeholder}" is filled by skins that disagree`] };
     const row = shownRow(shown);
     const g = shown.record.geometry;
-    const at = { slot: si, name: row.name, skin: shown.skin, placeholder: shown.placeholder, path: CORE_REGION_KINDS.has(shown.record.kind) ? row.path : null, bone: indexOf(slot.bone), offset: vertexCount };
+    const at = { timeline: timelineIdentity(slot.name, shown), deformOffset: deformCount, slot: si, name: row.name, skin: shown.skin, placeholder: shown.placeholder, path: CORE_REGION_KINDS.has(shown.record.kind) ? row.path : null, bone: indexOf(slot.bone), offset: vertexCount };
     let made = null;
     let missing = null;
     if (g?.kind === "clipping") missing = ["clipping", `slot "${slot.name}" shows clipping attachment "${row.name}"`];
@@ -9240,6 +9311,7 @@ function compileRuntime(doc, options = {}, plant = {}) {
     if (made === null) made = vertexAttachment(at, DRAW_NONE, new Float64Array(0), 0);
     attachments.push(made);
     vertexCount += made.count;
+    deformCount += made.deformCount;
     return { index: attachments.length - 1, missing };
   };
   const slots = doc.slots.map((slot, si) => {
@@ -9261,7 +9333,7 @@ function compileRuntime(doc, options = {}, plant = {}) {
   const refused = [];
   let cursorMax = 0;
   for (const anim of doc.animations) {
-    const compiled = compileAnimation(anim, refusals, ignoreEvents, boneIndex2, slotIndex, slots, constraints, (si, ph) => resolve(si, ph, anim.name));
+    const compiled = compileAnimation(anim, refusals, ignoreEvents, boneIndex2, slotIndex, slots, constraints, doc, (si, ph) => resolve(si, ph, anim.name));
     const missing = refusals.byAnimation.get(anim.name);
     if (missing !== void 0 && missing.length > 0) refused.push({ animation: anim.name, missing });
     else {
@@ -9272,6 +9344,9 @@ function compileRuntime(doc, options = {}, plant = {}) {
   if (refusals.model.length > 0) throw new RuntimeRefusal(refusals.model);
   const names = doc.animations.map((a) => a.name);
   return {
+    omitDeform: plant.omitDeform === true,
+    deformAfterWeights: plant.deformAfterWeights === true,
+    deformCount,
     eventWrapOffByOne: plant.eventWrapOffByOne === true,
     restoreEventsFromStart: plant.restoreEventsFromStart === true,
     doc,
@@ -9303,7 +9378,7 @@ function compileRuntime(doc, options = {}, plant = {}) {
 const NO_INTS = new Int32Array(0);
 const NO_NUMBERS = new Float64Array(0);
 function vertexAttachment(at, draw, local, count) {
-  return { ...at, draw, local, count, bindingCounts: NO_INTS, bindingBones: NO_INTS, bindingX: NO_NUMBERS, bindingY: NO_NUMBERS, bindingWeights: NO_NUMBERS };
+  return { ...at, draw, local, count, deformCount: draw === DRAW_MESH ? count : 0, bindingCounts: NO_INTS, bindingBones: NO_INTS, bindingX: NO_NUMBERS, bindingY: NO_NUMBERS, bindingWeights: NO_NUMBERS };
 }
 function meshAttachment(at, vertices, indexOf, rewrite, bones) {
   if (!vertices.weighted) {
@@ -9327,7 +9402,7 @@ function meshAttachment(at, vertices, indexOf, rewrite, bones) {
       ws.push(Math.fround(b.weight));
     }
   }
-  return { ...at, draw: DRAW_WEIGHTED, local: NO_NUMBERS, count: counts.length * 2, bindingCounts: Int32Array.from(counts), bindingBones: Int32Array.from(ids), bindingX: Float64Array.from(xs), bindingY: Float64Array.from(ys), bindingWeights: Float64Array.from(ws) };
+  return { ...at, deformCount: ids.length * 2, draw: DRAW_WEIGHTED, local: NO_NUMBERS, count: counts.length * 2, bindingCounts: Int32Array.from(counts), bindingBones: Int32Array.from(ids), bindingX: Float64Array.from(xs), bindingY: Float64Array.from(ys), bindingWeights: Float64Array.from(ws) };
 }
 function compileIk(r, index, applied, bones, indexOf) {
   return {
@@ -9387,13 +9462,12 @@ function compileTransform(r, index, applied, bones, indexOf) {
     clamp: r.clamp
   };
 }
-function compileAnimation(anim, refusals, ignoreEvents, boneIndex2, slotIndex, slots, constraints, resolve) {
+function compileAnimation(anim, refusals, ignoreEvents, boneIndex2, slotIndex, slots, constraints, doc, resolve) {
   const tl = anim.timelines;
   const name = anim.name;
   let cursors = 0;
   const deform = tl.attachments.filter((a) => a.deform !== null);
   const sequence = tl.attachments.filter((a) => a.sequence !== null);
-  if (deform.length > 0) refusals.note("deform-timeline", `${deform.length} deform timeline(s): ${deform.slice(0, 3).map((a) => `${a.skin}/${a.slot}/${a.attachment}`).join(", ")}${deform.length > 3 ? ", …" : ""}`, name);
   if (sequence.length > 0) refusals.note("sequence-timeline", `${sequence.length} sequence timeline(s): ${sequence.slice(0, 3).map((a) => `${a.skin}/${a.slot}/${a.attachment}`).join(", ")}${sequence.length > 3 ? ", …" : ""}`, name);
   if (tl.drawOrder.length > 0) refusals.note("draw-order-timeline", `${tl.drawOrder.length} draw-order key(s)`, name);
   const lastBy = (targets) => new Map(targets.map((t) => [t.name, t]));
@@ -9441,7 +9515,14 @@ function compileAnimation(anim, refusals, ignoreEvents, boneIndex2, slotIndex, s
       constraintTimelines[c.index] = { constraint: c.index, curve: compileCurve(keyed.keys, TRANSFORM_PROPERTIES.length), cursor: cursors++, flags: null };
     }
   }
-  return { name, duration: tl.duration, bones, slots: slotTimelines, constraints: constraintTimelines, cursors, events: tl.events.length, eventKeys: Object.freeze(ignoreEvents ? [] : tl.events.map((key) => Object.freeze({ name: key.name, time: key.time, int: key.int, float: key.float, string: key.string, volume: key.volume ?? 0, balance: key.balance ?? 0 }))) };
+  const deforms = deform.map((a) => {
+    const g = doc.skins.find((s) => s.name === a.skin)?.attachments[a.slot]?.[a.attachment]?.geometry;
+    if (g === void 0 || g.kind === "region" || g.kind === "linkedmesh") throw new RuntimeInputError(`deform "${a.skin}/${a.slot}/${a.attachment}" has no vertex geometry (readModel refuses it first)`);
+    const keys = a.deform;
+    const arrays = keys.map((k) => heldArray(g.vertices, k));
+    return { identity: `${a.skin}/${a.slot}/${a.attachment}`, cursor: cursors++, curve: compileDeformCurve(keys), count: arrays[0].length, held: Float64Array.from(arrays.flat()) };
+  });
+  return { name, duration: tl.duration, deforms, bones, slots: slotTimelines, constraints: constraintTimelines, cursors, events: tl.events.length, eventKeys: Object.freeze(ignoreEvents ? [] : tl.events.map((key) => Object.freeze({ name: key.name, time: key.time, int: key.int, float: key.float, string: key.string, volume: key.volume ?? 0, balance: key.balance ?? 0 }))) };
 }
 const DEG = RUNTIME_DEG;
 const TWO_PI = 2 * RUNTIME_PI;
@@ -9474,6 +9555,8 @@ class RuntimePose {
     this.light = new Float64Array(ns * 4);
     this.shown = new Int32Array(ns);
     this.vertices = new Float64Array(model.vertexCount);
+    this.deform = new Float64Array(model.deformCount);
+    this.deformed = new Uint8Array(model.attachments.length);
     this.cursors = new Int32Array(Math.max(1, model.cursors)).fill(-1);
     this.ikMix = new Float64Array(nc);
     this.ikSoftness = new Float64Array(nc);
@@ -9523,6 +9606,7 @@ class RuntimePose {
     this.constraintValues(null, 0);
     this.solveConstraints();
     this.slotValues(null, 0);
+    this.deformValues(null, 0);
   }
   /** The animation posed at its time `t`, from the setup pose (the header). */
   apply(t) {
@@ -9536,6 +9620,7 @@ class RuntimePose {
     this.constraintValues(anim, t);
     this.solveConstraints();
     this.slotValues(anim, t);
+    this.deformValues(anim, t);
   }
   /** One step of a looping track: the track time moved by `dt`, the animation posed at it wrapped by the duration (`loopedTime` in src/core/raw.ts). */
   step(dt) {
@@ -10245,6 +10330,31 @@ class RuntimePose {
       }
     }
   }
+  /** Reset on every pose, then match source identity after switches; no old frame's offsets survive. */
+  deformValues(anim, t) {
+    this.deformed.fill(0);
+    this.deform.fill(0);
+    if (anim === null || this.model.omitDeform) return;
+    for (let k = 0; k < anim.deforms.length; k++) {
+      const tl = anim.deforms[k];
+      const i = keyAt(tl.curve, this.cursors, tl.cursor, t);
+      if (i < 0) continue;
+      const held = i + 1 === tl.curve.keys || tl.curve.kinds[i] === CURVE_STEPPED;
+      const p = held ? 0 : deformFraction(tl.curve, i, t);
+      const start = i * tl.count;
+      for (let s = 0; s < this.shown.length; s++) {
+        const index = this.shown[s];
+        if (index < 0 || !this.model.slots[s].live) continue;
+        const at = this.model.attachments[index];
+        if (at.timeline !== tl.identity || at.deformCount === 0) continue;
+        this.deformed[index] = 1;
+        for (let q = 0; q < tl.count; q++) {
+          const v = tl.held[start + q];
+          this.deform[at.deformOffset + q] = held ? v : v + (tl.held[start + tl.count + q] - v) * p;
+        }
+      }
+    }
+  }
   /** Every shown attachment's world vertices into `vertices` at its offset (`regionCorners`, `worldVertices`). */
   computeVertices() {
     const m = this.model;
@@ -10266,7 +10376,8 @@ class RuntimePose {
         const d = W[b + W_D];
         const wx = W[b + W_X];
         const wy = W[b + W_Y];
-        const local = at.local;
+        const local = this.deformed[index] && at.draw === DRAW_MESH ? this.deform : at.local;
+        const lo = this.deformed[index] && at.draw === DRAW_MESH ? at.deformOffset : 0;
         if (at.draw === DRAW_REGION) {
           for (let q = 0; q < 8; q += 2) {
             const lx = local[q];
@@ -10276,8 +10387,8 @@ class RuntimePose {
           }
         } else {
           for (let q = 0; q < at.count; q += 2) {
-            const x = local[q];
-            const y = local[q + 1];
+            const x = local[lo + q];
+            const y = local[lo + q + 1];
             out[o++] = x * a + y * bb + wx;
             out[o++] = x * c + y * d + wy;
           }
@@ -10296,9 +10407,15 @@ class RuntimePose {
         const end = n + counts[v];
         for (; n < end; n++) {
           const b = bones[n] * WORLDS;
-          const x = xs[n];
-          const y = ys[n];
           const weight = weights[n];
+          const deformed = this.deformed[index] !== 0;
+          const x = deformed ? xs[n] + this.deform[at.deformOffset + n * 2] : xs[n];
+          const y = deformed ? ys[n] + this.deform[at.deformOffset + n * 2 + 1] : ys[n];
+          if (deformed && m.deformAfterWeights) {
+            wx += (xs[n] * W[b + W_A] + ys[n] * W[b + W_B] + W[b + W_X]) * weight + this.deform[at.deformOffset + n * 2];
+            wy += (xs[n] * W[b + W_C] + ys[n] * W[b + W_D] + W[b + W_Y]) * weight + this.deform[at.deformOffset + n * 2 + 1];
+            continue;
+          }
           wx += (x * W[b + W_A] + y * W[b + W_B] + W[b + W_X]) * weight;
           wy += (x * W[b + W_C] + y * W[b + W_D] + W[b + W_Y]) * weight;
         }
@@ -11195,10 +11312,10 @@ class RigPlayer {
     if (mode !== "dom") throw new Error(`mode must be 'dom' or 'canvas', got ${String(mode)}`);
     if (this.assets.regions === "none") {
       throw new Error(
-        "these assets were loaded with regions: 'none' (no region bitmaps, for the canvas mode only); the DOM mode needs a load with regions 'blob' or 'data'"
+        "these assets were loaded with regions: 'none' (no region bitmaps, for the canvas mode only); the DOM mode needs a load with regions 'atlas', 'blob' or 'data'"
       );
     }
-    const renderer = new DomRenderer(this.root, this.assets.regionImages, this.assets.pageImages);
+    const renderer = new DomRenderer(this.root, this.assets.regionImages, this.assets.pageImages, this.assets.atlasRegions);
     if (this.meshBackend) renderer.meshBackend = this.meshBackend;
     return renderer;
   }
@@ -12663,6 +12780,7 @@ export {
   CanvasRenderer,
   DomRenderer,
   RigPlayer,
+  createAtlasRegions,
   loadModel,
   readSetupMesh,
   revokeRegions,