rig-play 1.8.2 → 1.9.1

package/README.md

@@ -38,7 +38,21 @@ links to either earlier name keep working.
 
 ### Measured
 
-Measured on the 0.x line, on the spineboy exports it then played (PoC, Apple silicon —
+**The element mode's mesh backend is `'webgl'` by default since 1.9 (#109)**, read off
+macOS Safari on 2026-10-13 (1.8.2, gallery rig `look-packed`: 4 meshes, 464
+triangles, `sweep`; the demo's stats line after a 30 s settle; the Mac was also
+serving the builds, so absolute fps is low and only the comparison is the point —
+readings verbatim on #25):
+
+| macOS Safari | 1 rig | 10 rigs (4,640 triangles) |
+| --- | --: | --: |
+| canvas2d mesh backend | 21–26 fps | 2–3 fps |
+| webgl mesh backend | 60 fps | 58 fps |
+
+Nothing is claimed here for mobile browsers: no phone or tablet has been measured
+on the 1.x line.
+
+The numbers below are older: measured on the 0.x line, on the spineboy exports it then played (PoC, Apple silicon —
 headless and on-device numbers are labeled, they do **not** substitute for each other).
 The renderer tiers they describe carried over; they have not been re-measured since the
 player moved to rigc's model (#60):
@@ -150,8 +164,8 @@ default stays `dom`.
   37 fps, meshed ×10 = 3–4 fps with JS flat at ~4–5 ms — put the real cost in the
   GPU process: Safari antialiases canvas2d **clip paths**, so the per-triangle clip
   mapping pays a per-triangle AA-mask tax (the same AA that caused the seam cracks)
-- ✅ Optional WebGL blit backend for the mesh tier: `renderer.meshBackend =
-  'webgl'` (default stays `'canvas2d'`). All dirty meshes are shelf-packed into
+- ✅ WebGL blit backend for the mesh tier, the default since 1.9 (#109;
+  `renderer.meshBackend = 'canvas2d'` keeps the 2d raster). All dirty meshes are shelf-packed into
   **one shared offscreen WebGL context** (module-level — browsers cap contexts at
   ~16), drawn as textured triangles with premultiplied alpha, then rect-blitted
   onto the same per-part canvases with an unclipped `drawImage` — cheap on Safari.
@@ -586,12 +600,19 @@ onto shared pages instead. Both play here, unchanged:
   (Σ width × height), computed on demand. This is what `pixelRatio` moves
   quadratically, and the cheapest way to see an oversampling stage; the demo
   prints it in the stats line as `backing N Mpx`.
-- `renderer.meshBackend` — `'canvas2d'` (default) or `'webgl'`; same output, but
-  heavy deforming scenes on Safari want `'webgl'` (see Measured above). Falls back
-  to canvas2d automatically when WebGL is unavailable. Switching re-rasters every
+- `renderer.meshBackend` — `'webgl'` (default since 1.9) or `'canvas2d'`; same
+  output, and on macOS Safari webgl holds 58–60 fps where canvas2d reads 2–26
+  (see Measured above). Falls back to canvas2d automatically when WebGL is
+  unavailable or the shared context is lost; `meshBackendActive` says which drew. Switching re-rasters every
   mesh once (no reallocation), so it is fine to expose as a user setting.
 - `renderer.triangleExpand` — how far (canvas px) each triangle edge's clip is
   moved outward to close antialiased mesh seams (default 0.5). Also re-rasters every mesh once when changed.
+- `renderer.meshSourceRect` — what a canvas2d mesh triangle is drawn from:
+  `'page'` (the whole page) or `'triangle'` (a sub-rect covering its clip). Both
+  draw the same picture; the default is `'triangle'` on Linux WebKit, which
+  garbles whole-page draws, and `'page'` elsewhere, because macOS Safari ran the
+  sub-rect 12–15% slower (#25). Also on `CanvasRenderer` for its canvas2d
+  fallback. Re-rasters every mesh once when changed.
 - `renderer.clipping` — apply the clips the frame carries (default `true`).
   Which slots a clip covers is decided where the frame is made — the player's
   adapter walks the draw order the way the runtime's draw loop does (one clip in
@@ -643,6 +664,30 @@ on-device (Chromium, dpr 2, stage under `scale(0.25)`, ~2.2 M CSS px on screen):
 | 92 meshes | `devicePixelRatio` (2) | 141.1 Mpx | 36–39 |
 | 92 meshes | `dpr × zoom` (0.5) | 9.1 Mpx | 60–61 |
 
+## Coming from 1.8: meshes draw through WebGL by default
+
+From 1.9 the element mode rasterizes its meshes through the one shared WebGL
+context unless told otherwise (`DomRenderer.meshBackend` defaults to `'webgl'`,
+#109). The picture is the same within the parity suite's bounds, the API is
+unchanged, and canvas2d is still drawn wherever WebGL is unavailable or the
+context is lost. What a caller can notice:
+
+- The page holds one more WebGL context (one for every mesh of every player, not
+  one per player). A page already near the browser's cap of about 16 live
+  contexts can lose its oldest one when this one is created.
+- `meshBackendActive` reads `'webgl'` where it read `'canvas2d'`.
+- Frame cost moves from the page to the GPU blit (see *Measured*).
+
+To keep 1.8's raster, set it back, up front or on a live player:
+
+```ts
+const player = new RigPlayer(root, assets, { meshBackend: 'canvas2d' });
+// or, on a renderer you hold:
+renderer.meshBackend = 'canvas2d';
+```
+
+The canvas mode was already webgl by default and does not change.
+
 ## Coming from spine-html 0.8
 
 This is not a drop-in upgrade. 0.8 drew a Spine export (`.json` or `.skel`, plus its
@@ -695,7 +740,7 @@ name, and unloading is still elements first, bitmaps second.
 | `renderer.pixelRatio` | `player.renderer.pixelRatio` | On both renderers. Carried over when `player.mode` changes. |
 | `renderer.syncPixelRatio()` | `player.renderer.syncPixelRatio()` | On both renderers, the same meaning and the same deadband (since 1.3.0; before it, DOM mode only). |
 | `renderer.meshBackingPixels` | `DomRenderer.meshBackingPixels` | DOM mode only. |
-| `renderer.meshBackend`, `meshBackendActive`, type `MeshBackend` | `DomRenderer.meshBackend`, `meshBackendActive`, type `MeshBackend` | Same values (`'canvas2d'` default, `'webgl'`). Also settable up front as `RigPlayerOptions.meshBackend`. |
+| `renderer.meshBackend`, `meshBackendActive`, type `MeshBackend` | `DomRenderer.meshBackend`, `meshBackendActive`, type `MeshBackend` | Same values; the default is `'webgl'` since 1.9 (`'canvas2d'` before). Also settable up front as `RigPlayerOptions.meshBackend`. |
 | `renderer.triangleExpand` | `DomRenderer.triangleExpand` | Same default (0.5). |
 | `renderer.clipping` | `player.renderer.clipping` | On both renderers. Carried over when `player.mode` changes. |
 | `clipCount`, `clipSkipCount`, `clipWriteCount` | same names on `DomRenderer` | `clipSkipCount` counts less than it did: a second clip met while one is in force, and a clip on an inactive bone, no longer reach the frame, so they are not counted. |
@@ -833,7 +878,8 @@ scenes (floors 0.585–1.553%, Chromium and WebKit). The DOM tier's two mesh
 backends get the same A/B (`?backend=canvas2d` against `?backend=webgl`, at most
 0.5%). Hairline seams are guarded by a deterministic canary (`?expand=0` must
 change the canvas2d raster), the canvas2d source sub-rect by another (expand 32
-against 8), and counter tests pin the dirty-skip / grow-only-backing /
+against 8, forced to the sub-rect), the two source rects by an A/B that must
+match exactly, and counter tests pin the dirty-skip / grow-only-backing /
 clip-counter invariants plus the region corner order (BL, UL, UR, BR) and the
 turned-region UVs, read off rig-c's pose against hand-written numbers.
 

package/dist/CanvasRenderer.d.ts

@@ -1,3 +1,4 @@
+import { type MeshSourceRect } from './DomRenderer.js';
 import type { PosedFrame } from './posedFrame.js';
 /** What actually drew the last frame of a `CanvasRenderer`. */
 export type CanvasBackend = 'webgl' | 'canvas2d';
@@ -69,6 +70,8 @@ export declare class CanvasRenderer {
     viewport: CanvasViewport | null;
     /** The backend to draw with: 'webgl' (default) through the shared context, or 'canvas2d' to force the fallback. */
     backend: CanvasBackend;
+    /** What the canvas2d fallback draws each mesh triangle from — as `DomRenderer.meshSourceRect`, with the same default. */
+    meshSourceRect: MeshSourceRect;
     /** 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. */

package/dist/CanvasRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CanvasRenderer.d.ts","sourceRoot":"","sources":["../src/CanvasRenderer.ts"],"names":[],"mappings":"AAKA,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;IAqEvB,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,KAAK;IArExB;;;;;OAKG;IACH,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;;;;;;;;OAQG;IACH,cAAc,IAAI,MAAM;IAKxB,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"}
+{"version":3,"file":"CanvasRenderer.d.ts","sourceRoot":"","sources":["../src/CanvasRenderer.ts"],"names":[],"mappings":"AAEA,OAAO,EAA+C,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGpG,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;IAuEvB,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,KAAK;IAvExB;;;;;OAKG;IACH,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,yHAAyH;IACzH,cAAc,EAAE,cAAc,CAA2B;IACzD,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;;;;;;;;OAQG;IACH,cAAc,IAAI,MAAM;IAKxB,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;IAqExB,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/DomRenderer.d.ts

@@ -2,6 +2,12 @@ import { type RegionImage } from './DomTexture.js';
 import type { PosedFrame } from './posedFrame.js';
 /** Rasterizer used for the mesh (deform) tier. */
 export type MeshBackend = 'canvas2d' | 'webgl';
+/**
+ * What a canvas2d mesh triangle is drawn from: `'triangle'`, a source sub-rect
+ * of the page covering the triangle's clip, or `'page'`, the whole page. Both
+ * draw the same picture under the same clip; they differ in cost by engine.
+ */
+export type MeshSourceRect = 'triangle' | 'page';
 /**
  * Renders a posed frame (`PosedFrame`) as DOM, split by slot kind:
  *
@@ -88,6 +94,12 @@ export declare class DomRenderer {
      * to see them.
      */
     triangleExpand: number;
+    /**
+     * What the canvas2d mesh backend draws each triangle from (`MeshSourceRect`):
+     * by default the sub-rect on Linux WebKit and the whole page elsewhere.
+     * Re-rasters every mesh once when changed.
+     */
+    meshSourceRect: MeshSourceRect;
     /**
      * Mesh-canvas backing-store pixels per CSS pixel. Defaults to the device
      * pixel ratio. If the caller scales the root element, fold that scale in
@@ -97,9 +109,9 @@ export declare class DomRenderer {
      */
     pixelRatio: number;
     /**
-     * Rasterizer for the mesh (deform) tier. 'canvas2d' (default) maps each
-     * triangle with clip+transform+drawImage directly on the per-part canvas.
-     * 'webgl' rasterizes every dirty mesh into one shared offscreen WebGL
+     * Rasterizer for the mesh (deform) tier. 'canvas2d' maps each triangle
+     * with clip+transform+drawImage directly on the per-part canvas. 'webgl'
+     * (default) rasterizes every dirty mesh into one shared offscreen WebGL
      * canvas and rect-blits each mesh back onto its per-part canvas — the DOM
      * structure and all element-level behavior (z-index interleave, tint
      * filter, mix-blend-mode, dirty-skip) are identical, only the raster step
@@ -108,7 +120,8 @@ export declare class DomRenderer {
      * process that rAF-limits heavy scenes; GL rasterizes shared edges
      * seamlessly (no clip, no crack overdraw) and the blit is an unclipped
      * rect copy. Falls back to 'canvas2d' when WebGL is unavailable or the
-     * shared context is lost — see meshBackendActive.
+     * shared context is lost — see meshBackendActive. The default since 1.9
+     * (#109); before it, 'canvas2d'. Set 'canvas2d' to keep the 2d raster.
      */
     meshBackend: MeshBackend;
     /** Backend that actually rasterized the mesh tier during the last render(). */

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/index.d.ts

@@ -1,5 +1,5 @@
 export { type CanvasBackend, CanvasRenderer, type CanvasViewport } from './CanvasRenderer.js';
-export { DomRenderer, type MeshBackend } from './DomRenderer.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 LoadModelOptions, loadModel, type ModelAssets, type ModelDocument, type RegionLoading } from './loadModel.js';
 export { type AdjustableBones, type BoneAdjust, type BoneLocals, type BoneWorld, type PlayOptions, type PoseBounds, type QueueOptions, type RenderMode, type RigComplete, type RigEvent, RigPlayer, type RigPlayerOptions, type SlotFilter, type TrackEntry } from './player.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,MAAM,kBAAkB,CAAC;AACjE,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,KAAK,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC5H,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,UAAU,EAAE,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,KAAK,YAAY,EAAE,KAAK,UAAU,EAAE,KAAK,WAAW,EAAE,KAAK,QAAQ,EAAE,SAAS,EAAE,KAAK,gBAAgB,EAAE,KAAK,UAAU,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AACjR,YAAY,EACV,SAAS,EACT,SAAS,EACT,UAAU,EACV,SAAS,EACT,WAAW,EACX,SAAS,GACV,MAAM,iBAAiB,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,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,KAAK,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC5H,OAAO,EAAE,KAAK,eAAe,EAAE,KAAK,UAAU,EAAE,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,KAAK,YAAY,EAAE,KAAK,UAAU,EAAE,KAAK,WAAW,EAAE,KAAK,QAAQ,EAAE,SAAS,EAAE,KAAK,gBAAgB,EAAE,KAAK,UAAU,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AACjR,YAAY,EACV,SAAS,EACT,SAAS,EACT,UAAU,EACV,SAAS,EACT,WAAW,EACX,SAAS,GACV,MAAM,iBAAiB,CAAC"}

package/dist/index.js

@@ -6842,6 +6842,10 @@ function getMeshGlBlitter() {
   }
   return shared && !shared.lost ? shared : null;
 }
+function defaultMeshSourceRect(userAgent = typeof navigator === "object" ? navigator.userAgent : "") {
+  const linuxWebKit = /AppleWebKit/.test(userAgent) && /Linux|X11/.test(userAgent) && !/Android|Chrome|Chromium|CriOS|Edg/.test(userAgent);
+  return linuxWebKit ? "triangle" : "page";
+}
 const regionVertices = new Float32Array(8);
 const SVG_NS = "http://www.w3.org/2000/svg";
 let tintFilterSeq = 0;
@@ -6965,6 +6969,12 @@ class DomRenderer {
    * to see them.
    */
   triangleExpand = 0.5;
+  /**
+   * What the canvas2d mesh backend draws each triangle from (`MeshSourceRect`):
+   * by default the sub-rect on Linux WebKit and the whole page elsewhere.
+   * Re-rasters every mesh once when changed.
+   */
+  meshSourceRect = defaultMeshSourceRect();
   /**
    * Mesh-canvas backing-store pixels per CSS pixel. Defaults to the device
    * pixel ratio. If the caller scales the root element, fold that scale in
@@ -6974,9 +6984,9 @@ class DomRenderer {
    */
   pixelRatio = typeof devicePixelRatio === "number" ? devicePixelRatio : 1;
   /**
-   * Rasterizer for the mesh (deform) tier. 'canvas2d' (default) maps each
-   * triangle with clip+transform+drawImage directly on the per-part canvas.
-   * 'webgl' rasterizes every dirty mesh into one shared offscreen WebGL
+   * Rasterizer for the mesh (deform) tier. 'canvas2d' maps each triangle
+   * with clip+transform+drawImage directly on the per-part canvas. 'webgl'
+   * (default) rasterizes every dirty mesh into one shared offscreen WebGL
    * canvas and rect-blits each mesh back onto its per-part canvas — the DOM
    * structure and all element-level behavior (z-index interleave, tint
    * filter, mix-blend-mode, dirty-skip) are identical, only the raster step
@@ -6985,11 +6995,12 @@ class DomRenderer {
    * process that rAF-limits heavy scenes; GL rasterizes shared edges
    * seamlessly (no clip, no crack overdraw) and the blit is an unclipped
    * rect copy. Falls back to 'canvas2d' when WebGL is unavailable or the
-   * shared context is lost — see meshBackendActive.
+   * shared context is lost — see meshBackendActive. The default since 1.9
+   * (#109); before it, 'canvas2d'. Set 'canvas2d' to keep the 2d raster.
    */
-  meshBackend = "canvas2d";
+  meshBackend = "webgl";
   /** Backend that actually rasterized the mesh tier during the last render(). */
-  meshBackendActive = "canvas2d";
+  meshBackendActive = "webgl";
   views = /* @__PURE__ */ new Map();
   /** Counts render() calls: the stamp a view drawn this frame carries (`SlotView.drawnIn`). */
   frameNumber = 0;
@@ -7237,7 +7248,7 @@ class DomRenderer {
     const ratio = this.pixelRatio;
     const uvs = slot.uvs;
     const triangles = slot.triangles;
-    let dirty = view.meshUvs !== uvs || view.meshTriangles !== triangles || view.meshPage !== page || view.meshSequenceIndex !== sequenceIndex || view.meshExpand !== this.triangleExpand || view.meshVertexCount !== count || view.meshBackendDrawn !== this.meshBackendActive;
+    let dirty = view.meshUvs !== uvs || view.meshTriangles !== triangles || view.meshPage !== page || view.meshSequenceIndex !== sequenceIndex || view.meshExpand !== this.triangleExpand || view.meshSourceRect !== this.meshSourceRect || view.meshVertexCount !== count || view.meshBackendDrawn !== this.meshBackendActive;
     const needW = Math.max(1, Math.round(w * ratio));
     const needH = Math.max(1, Math.round(h * ratio));
     const ratioChanged = view.meshRatio !== ratio;
@@ -7277,6 +7288,7 @@ class DomRenderer {
       view.meshPage = page;
       view.meshSequenceIndex = sequenceIndex;
       view.meshExpand = this.triangleExpand;
+      view.meshSourceRect = this.meshSourceRect;
       view.meshVertexCount = count;
       view.meshBackendDrawn = this.meshBackendActive;
       if (this.meshBackendActive === "webgl") {
@@ -7409,7 +7421,7 @@ class DomRenderer {
    * class of offset the `uv * size` addressing removes.
    */
   drawTriangle(ctx, img, x0, y0, u0, v0, x1, y1, u1, v1, x2, y2, u2, v2) {
-    drawTexturedTriangle(ctx, img, this.triangleExpand, x0, y0, u0, v0, x1, y1, u1, v1, x2, y2, u2, v2);
+    drawTexturedTriangle(ctx, img, this.triangleExpand, this.meshSourceRect, x0, y0, u0, v0, x1, y1, u1, v1, x2, y2, u2, v2);
   }
   // --- clipping tier ---------------------------------------------------------
   /**
@@ -7635,6 +7647,7 @@ class DomRenderer {
         meshPage: null,
         meshSequenceIndex: -1,
         meshExpand: -1,
+        meshSourceRect: "",
         meshVertexCount: -1,
         meshBackendDrawn: "",
         meshVertices: new Float64Array(0),
@@ -7653,7 +7666,7 @@ class DomRenderer {
     this.setClipPath(view, "");
   }
 }
-function drawTexturedTriangle(ctx, img, expand, x0, y0, u0, v0, x1, y1, u1, v1, x2, y2, u2, v2) {
+function drawTexturedTriangle(ctx, img, expand, sourceRect, x0, y0, u0, v0, x1, y1, u1, v1, x2, y2, u2, v2) {
   const corners = offsetTriangle(x0, y0, x1, y1, x2, y2, expand);
   const px0 = corners[0], py0 = corners[1];
   const px1 = corners[2], py1 = corners[3];
@@ -7676,6 +7689,14 @@ function drawTexturedTriangle(ctx, img, expand, x0, y0, u0, v0, x1, y1, u1, v1,
   const d = (eu1 * ey2 - eu2 * ey1) * det;
   const e = x0 - a * u0 - c * v0;
   const f = y0 - b * u0 - d * v0;
+  if (sourceRect === "page") {
+    ctx.save();
+    ctx.transform(a, b, c, d, e, f);
+    ctx.clip();
+    ctx.drawImage(img, 0, 0);
+    ctx.restore();
+    return;
+  }
   let minU = Math.min(u0, u1, u2);
   let maxU = Math.max(u0, u1, u2);
   let minV = Math.min(v0, v1, v2);
@@ -7767,6 +7788,8 @@ class CanvasRenderer {
   viewport = null;
   /** The backend to draw with: 'webgl' (default) through the shared context, or 'canvas2d' to force the fallback. */
   backend = "webgl";
+  /** What the canvas2d fallback draws each mesh triangle from — as `DomRenderer.meshSourceRect`, with the same default. */
+  meshSourceRect = defaultMeshSourceRect();
   /** What drew the last frame (or would have, had it not been reused). */
   backendActive = "webgl";
   /** The visible canvas — the renderer's one element in the root. */
@@ -7940,7 +7963,8 @@ class CanvasRenderer {
         this.nextSig = grown;
       }
     };
-    need(8);
+    need(9);
+    sig[n++] = this.meshSourceRect === "triangle" ? 1 : 0;
     sig[n++] = this.left;
     sig[n++] = this.top;
     sig[n++] = this.backingW;
@@ -8155,6 +8179,7 @@ class CanvasRenderer {
           ctx,
           source,
           0.5,
+          this.meshSourceRect,
           X(vertices[i0]),
           Y(vertices[i0 + 1]),
           uvs[i0] * uw,