@taole/giftstage 0.3.2 → 0.3.3

package/dist/gift-stage.es.js

@@ -85,186 +85,186 @@ void main() {\r
     vec4 c = texture(u_atlas, v_uv);\r
     fragColor = vec4(c.rgb * v_color.rgb * v_color.a, c.a * v_color.a);\r
 }\r
-`, RE = `#version 300 es
-precision highp float;
-precision highp int;
-
-/**
- * Table-aware SVGA instanced vertex stage.
- *
- * The frame table is a RGBA32F/NEAREST texture with three texels per
- * (sprite, frame) row:
- *   texel 0 = layoutW, layoutH, a, b
- *   texel 1 = c, d, tx, ty
- *   texel 2 = alpha, 0, 0, 0
- *
- * Static sprite metadata is a second RGBA32F/NEAREST texture with two texels
- * per row:
- *   texel 0 = atlas UV min.xy / max.xy
- *   texel 1 = sourceSpriteIndex, atlasPage, flags, reserved
- *
- * One draw covers a single atlas page of one slot.  \`gl_InstanceID\` selects a
- * metadata row (\`u_spriteBase + gl_InstanceID\`), so the only per-frame CPU
- * state is the slot transform/opacity/clip and the authoritative frame index.
- */
-layout(location = 0) in vec2 a_corner;
-// Optional Hybrid scheduling row. Direct draws leave these attributes disabled
-// and use the uniform slot state below.
-layout(location = 1) in vec4 a_instanceParent;
-layout(location = 2) in vec4 a_instanceTranslateOpacityFrame;
-layout(location = 3) in vec4 a_instanceClipRect;
-/** x=clipEnabled, y=metadataRow, z=atlasPage, w=present. */
-layout(location = 4) in vec4 a_instanceInfo;
-
-uniform mat4 u_projection;
-uniform highp sampler2D u_frameTable;
-uniform highp sampler2D u_spriteMetadata;
-/**
- * Canonical compact state (four RGBA32F texels / 16 floats):
- * affine; translate+opacity+frame; clip rect; clipEnabled+metadataBase+atlasPage+track+1.
- */
-uniform highp sampler2D u_slotStates;
-/** x = frameCount, y = spriteCount, z = texels per frame (3), w = default frame. */
-uniform ivec4 u_tableInfo;
-/** x/y = frame-table texture width/height in texels. */
-uniform ivec2 u_frameTableSize;
-/** x/y = sprite metadata texture width/height in texels. */
-uniform ivec2 u_spriteMetadataSize;
-uniform int u_spriteMetadataTexelsPerRow;
-uniform ivec2 u_slotStateSize;
-/** First static metadata row consumed by this slot/page draw. */
-uniform int u_spriteBase;
-/** Authoritative SVGA frame selected by RenderManager/PlaybackScope. */
-uniform int u_frameIndex;
-uniform vec4 u_parentAffine;
-uniform vec2 u_parentTranslate;
-uniform float u_slotOpacity;
-/** Atlas page for this draw; negative means metadata page filtering is disabled. */
-uniform int u_atlasPage;
-uniform vec4 u_clipRect;
-uniform float u_clipEnabled;
-/** WebGL's gl_FragCoord has a bottom-left origin; input clip rects are top-left. */
-uniform float u_canvasHeight;
-uniform float u_instanceStateEnabled;
-uniform float u_compactSlotStateEnabled;
-uniform int u_spritesPerSlot;
-
-out vec2 v_uv;
-out vec4 v_color;
-flat out vec4 v_clipRect;
-flat out float v_clipEnabled;
-out vec2 v_localPosition;
-flat out vec4 v_localClipRect;
-flat out float v_localClipEnabled;
-
-ivec2 texelCoord(int linearIndex, ivec2 textureSize) {
-    int width = max(textureSize.x, 1);
-    return ivec2(linearIndex - (linearIndex / width) * width, linearIndex / width);
-}
-
-void main() {
-    int frameCount = max(u_tableInfo.x, 1);
-    int spriteCount = max(u_tableInfo.y, 1);
-    bool instanceState = u_instanceStateEnabled > 0.5;
-    bool compactSlotState = u_compactSlotStateEnabled > 0.5;
-    int spritesPerSlot = max(u_spritesPerSlot, 1);
-    int slotStateIndex = gl_InstanceID / spritesPerSlot;
-    int spriteWithinSlot = gl_InstanceID - slotStateIndex * spritesPerSlot;
-    vec4 compactParent = vec4(0.0);
-    vec4 compactTranslateOpacityFrame = vec4(0.0);
-    vec4 compactClip = vec4(0.0);
-    vec4 compactInfo = vec4(0.0);
-    if (compactSlotState) {
-        int compactBase = slotStateIndex * 4;
-        compactParent = texelFetch(u_slotStates, texelCoord(compactBase, u_slotStateSize), 0);
-        compactTranslateOpacityFrame = texelFetch(u_slotStates, texelCoord(compactBase + 1, u_slotStateSize), 0);
-        compactClip = texelFetch(u_slotStates, texelCoord(compactBase + 2, u_slotStateSize), 0);
-        compactInfo = texelFetch(u_slotStates, texelCoord(compactBase + 3, u_slotStateSize), 0);
-    }
-    int metadataRow = instanceState
-        ? max(int(a_instanceInfo.y + 0.5), 0)
-        : compactSlotState
-            ? max(u_spriteBase + spriteWithinSlot, 0)
-            : max(u_spriteBase + gl_InstanceID, 0);
-    int metadataStride = max(u_spriteMetadataTexelsPerRow, 2);
-    int metadataTexel = metadataRow * metadataStride;
-    vec4 metadata0 = texelFetch(
-        u_spriteMetadata,
-        texelCoord(metadataTexel, u_spriteMetadataSize),
-        0
-    );
-    vec4 metadata1 = texelFetch(
-        u_spriteMetadata,
-        texelCoord(metadataTexel + 1, u_spriteMetadataSize),
-        0
-    );
-    vec4 metadata2 = metadataStride >= 3
-        ? texelFetch(u_spriteMetadata, texelCoord(metadataTexel + 2, u_spriteMetadataSize), 0)
-        : vec4(0.0);
-    // Metadata carries the source sprite index so a page-specific range can
-    // represent non-contiguous atlas pages. Its y component is the atlas page.
-    int spriteIndex = clamp(int(max(metadata1.x, 0.0) + 0.5), 0, spriteCount - 1);
-    int frameIndex = instanceState
-        ? int(a_instanceTranslateOpacityFrame.w + 0.5)
-        : compactSlotState
-            ? int(compactTranslateOpacityFrame.w + 0.5)
-            : u_frameIndex;
-    if (frameIndex < 0) frameIndex = u_tableInfo.w;
-    frameIndex = clamp(frameIndex, 0, frameCount - 1);
-
-    int row = spriteIndex * frameCount + frameIndex;
-    int frameTexel = row * u_tableInfo.z;
-    vec4 frame0 = texelFetch(u_frameTable, texelCoord(frameTexel, u_frameTableSize), 0);
-    vec4 frame1 = texelFetch(u_frameTable, texelCoord(frameTexel + 1, u_frameTableSize), 0);
-    vec4 frame2 = texelFetch(u_frameTable, texelCoord(frameTexel + 2, u_frameTableSize), 0);
-
-    float layoutW = frame0.x;
-    float layoutH = frame0.y;
-    vec2 local = vec2(
-        frame0.z * layoutW * a_corner.x + frame1.x * layoutH * a_corner.y + frame1.z,
-        frame0.w * layoutW * a_corner.x + frame1.y * layoutH * a_corner.y + frame1.w
-    );
-
-    vec4 parentAffine = instanceState
-        ? a_instanceParent
-        : compactSlotState ? compactParent : u_parentAffine;
-    vec2 parentTranslate = instanceState
-        ? a_instanceTranslateOpacityFrame.xy
-        : compactSlotState ? compactTranslateOpacityFrame.xy : u_parentTranslate;
-    float slotOpacity = instanceState
-        ? a_instanceTranslateOpacityFrame.z
-        : compactSlotState ? compactTranslateOpacityFrame.z : u_slotOpacity;
-    int atlasPage = instanceState
-        ? int(a_instanceInfo.z + 0.5)
-        : compactSlotState
-            ? (compactInfo.z < -0.5 ? -1 : int(compactInfo.z + 0.5))
-            : u_atlasPage;
-    vec4 clipRect = instanceState
-        ? a_instanceClipRect
-        : compactSlotState ? compactClip : u_clipRect;
-    float clipEnabled = instanceState
-        ? a_instanceInfo.x
-        : compactSlotState ? compactInfo.x : u_clipEnabled;
-    vec2 world = vec2(
-        parentAffine.x * local.x + parentAffine.z * local.y + parentTranslate.x,
-        parentAffine.y * local.x + parentAffine.w * local.y + parentTranslate.y
-    );
-
-    gl_Position = u_projection * vec4(world, 0.0, 1.0);
-    v_uv = mix(metadata0.xy, metadata0.zw, a_corner);
-    bool pageMatches = atlasPage < 0 || int(max(metadata1.y, 0.0) + 0.5) == atlasPage;
-    int metadataFlags = int(max(metadata1.z, 0.0) + 0.5);
-    bool metadataPresent = (metadataFlags & 1) == 0;
-    float pageAlpha = pageMatches && metadataPresent ? 1.0 : 0.0;
-    float effectiveAlpha = frame2.x * slotOpacity * pageAlpha;
-    // Match the CPU reference's strict \`< 0.05\` visibility cutoff.
-    v_color = vec4(1.0, 1.0, 1.0, effectiveAlpha >= 0.05 ? effectiveAlpha : 0.0);
-    v_clipRect = clipRect;
-    v_clipEnabled = clipEnabled;
-    v_localPosition = vec2(layoutW * a_corner.x, layoutH * a_corner.y);
-    v_localClipRect = metadata2;
-    v_localClipEnabled = (metadataFlags & 2) != 0 ? 1.0 : 0.0;
-}
+`, RE = `#version 300 es\r
+precision highp float;\r
+precision highp int;\r
+\r
+/**\r
+ * Table-aware SVGA instanced vertex stage.\r
+ *\r
+ * The frame table is a RGBA32F/NEAREST texture with three texels per\r
+ * (sprite, frame) row:\r
+ *   texel 0 = layoutW, layoutH, a, b\r
+ *   texel 1 = c, d, tx, ty\r
+ *   texel 2 = alpha, 0, 0, 0\r
+ *\r
+ * Static sprite metadata is a second RGBA32F/NEAREST texture with two texels\r
+ * per row:\r
+ *   texel 0 = atlas UV min.xy / max.xy\r
+ *   texel 1 = sourceSpriteIndex, atlasPage, flags, reserved\r
+ *\r
+ * One draw covers a single atlas page of one slot.  \`gl_InstanceID\` selects a\r
+ * metadata row (\`u_spriteBase + gl_InstanceID\`), so the only per-frame CPU\r
+ * state is the slot transform/opacity/clip and the authoritative frame index.\r
+ */\r
+layout(location = 0) in vec2 a_corner;\r
+// Optional Hybrid scheduling row. Direct draws leave these attributes disabled\r
+// and use the uniform slot state below.\r
+layout(location = 1) in vec4 a_instanceParent;\r
+layout(location = 2) in vec4 a_instanceTranslateOpacityFrame;\r
+layout(location = 3) in vec4 a_instanceClipRect;\r
+/** x=clipEnabled, y=metadataRow, z=atlasPage, w=present. */\r
+layout(location = 4) in vec4 a_instanceInfo;\r
+\r
+uniform mat4 u_projection;\r
+uniform highp sampler2D u_frameTable;\r
+uniform highp sampler2D u_spriteMetadata;\r
+/**\r
+ * Canonical compact state (four RGBA32F texels / 16 floats):\r
+ * affine; translate+opacity+frame; clip rect; clipEnabled+metadataBase+atlasPage+track+1.\r
+ */\r
+uniform highp sampler2D u_slotStates;\r
+/** x = frameCount, y = spriteCount, z = texels per frame (3), w = default frame. */\r
+uniform ivec4 u_tableInfo;\r
+/** x/y = frame-table texture width/height in texels. */\r
+uniform ivec2 u_frameTableSize;\r
+/** x/y = sprite metadata texture width/height in texels. */\r
+uniform ivec2 u_spriteMetadataSize;\r
+uniform int u_spriteMetadataTexelsPerRow;\r
+uniform ivec2 u_slotStateSize;\r
+/** First static metadata row consumed by this slot/page draw. */\r
+uniform int u_spriteBase;\r
+/** Authoritative SVGA frame selected by RenderManager/PlaybackScope. */\r
+uniform int u_frameIndex;\r
+uniform vec4 u_parentAffine;\r
+uniform vec2 u_parentTranslate;\r
+uniform float u_slotOpacity;\r
+/** Atlas page for this draw; negative means metadata page filtering is disabled. */\r
+uniform int u_atlasPage;\r
+uniform vec4 u_clipRect;\r
+uniform float u_clipEnabled;\r
+/** WebGL's gl_FragCoord has a bottom-left origin; input clip rects are top-left. */\r
+uniform float u_canvasHeight;\r
+uniform float u_instanceStateEnabled;\r
+uniform float u_compactSlotStateEnabled;\r
+uniform int u_spritesPerSlot;\r
+\r
+out vec2 v_uv;\r
+out vec4 v_color;\r
+flat out vec4 v_clipRect;\r
+flat out float v_clipEnabled;\r
+out vec2 v_localPosition;\r
+flat out vec4 v_localClipRect;\r
+flat out float v_localClipEnabled;\r
+\r
+ivec2 texelCoord(int linearIndex, ivec2 textureSize) {\r
+    int width = max(textureSize.x, 1);\r
+    return ivec2(linearIndex - (linearIndex / width) * width, linearIndex / width);\r
+}\r
+\r
+void main() {\r
+    int frameCount = max(u_tableInfo.x, 1);\r
+    int spriteCount = max(u_tableInfo.y, 1);\r
+    bool instanceState = u_instanceStateEnabled > 0.5;\r
+    bool compactSlotState = u_compactSlotStateEnabled > 0.5;\r
+    int spritesPerSlot = max(u_spritesPerSlot, 1);\r
+    int slotStateIndex = gl_InstanceID / spritesPerSlot;\r
+    int spriteWithinSlot = gl_InstanceID - slotStateIndex * spritesPerSlot;\r
+    vec4 compactParent = vec4(0.0);\r
+    vec4 compactTranslateOpacityFrame = vec4(0.0);\r
+    vec4 compactClip = vec4(0.0);\r
+    vec4 compactInfo = vec4(0.0);\r
+    if (compactSlotState) {\r
+        int compactBase = slotStateIndex * 4;\r
+        compactParent = texelFetch(u_slotStates, texelCoord(compactBase, u_slotStateSize), 0);\r
+        compactTranslateOpacityFrame = texelFetch(u_slotStates, texelCoord(compactBase + 1, u_slotStateSize), 0);\r
+        compactClip = texelFetch(u_slotStates, texelCoord(compactBase + 2, u_slotStateSize), 0);\r
+        compactInfo = texelFetch(u_slotStates, texelCoord(compactBase + 3, u_slotStateSize), 0);\r
+    }\r
+    int metadataRow = instanceState\r
+        ? max(int(a_instanceInfo.y + 0.5), 0)\r
+        : compactSlotState\r
+            ? max(u_spriteBase + spriteWithinSlot, 0)\r
+            : max(u_spriteBase + gl_InstanceID, 0);\r
+    int metadataStride = max(u_spriteMetadataTexelsPerRow, 2);\r
+    int metadataTexel = metadataRow * metadataStride;\r
+    vec4 metadata0 = texelFetch(\r
+        u_spriteMetadata,\r
+        texelCoord(metadataTexel, u_spriteMetadataSize),\r
+        0\r
+    );\r
+    vec4 metadata1 = texelFetch(\r
+        u_spriteMetadata,\r
+        texelCoord(metadataTexel + 1, u_spriteMetadataSize),\r
+        0\r
+    );\r
+    vec4 metadata2 = metadataStride >= 3\r
+        ? texelFetch(u_spriteMetadata, texelCoord(metadataTexel + 2, u_spriteMetadataSize), 0)\r
+        : vec4(0.0);\r
+    // Metadata carries the source sprite index so a page-specific range can\r
+    // represent non-contiguous atlas pages. Its y component is the atlas page.\r
+    int spriteIndex = clamp(int(max(metadata1.x, 0.0) + 0.5), 0, spriteCount - 1);\r
+    int frameIndex = instanceState\r
+        ? int(a_instanceTranslateOpacityFrame.w + 0.5)\r
+        : compactSlotState\r
+            ? int(compactTranslateOpacityFrame.w + 0.5)\r
+            : u_frameIndex;\r
+    if (frameIndex < 0) frameIndex = u_tableInfo.w;\r
+    frameIndex = clamp(frameIndex, 0, frameCount - 1);\r
+\r
+    int row = spriteIndex * frameCount + frameIndex;\r
+    int frameTexel = row * u_tableInfo.z;\r
+    vec4 frame0 = texelFetch(u_frameTable, texelCoord(frameTexel, u_frameTableSize), 0);\r
+    vec4 frame1 = texelFetch(u_frameTable, texelCoord(frameTexel + 1, u_frameTableSize), 0);\r
+    vec4 frame2 = texelFetch(u_frameTable, texelCoord(frameTexel + 2, u_frameTableSize), 0);\r
+\r
+    float layoutW = frame0.x;\r
+    float layoutH = frame0.y;\r
+    vec2 local = vec2(\r
+        frame0.z * layoutW * a_corner.x + frame1.x * layoutH * a_corner.y + frame1.z,\r
+        frame0.w * layoutW * a_corner.x + frame1.y * layoutH * a_corner.y + frame1.w\r
+    );\r
+\r
+    vec4 parentAffine = instanceState\r
+        ? a_instanceParent\r
+        : compactSlotState ? compactParent : u_parentAffine;\r
+    vec2 parentTranslate = instanceState\r
+        ? a_instanceTranslateOpacityFrame.xy\r
+        : compactSlotState ? compactTranslateOpacityFrame.xy : u_parentTranslate;\r
+    float slotOpacity = instanceState\r
+        ? a_instanceTranslateOpacityFrame.z\r
+        : compactSlotState ? compactTranslateOpacityFrame.z : u_slotOpacity;\r
+    int atlasPage = instanceState\r
+        ? int(a_instanceInfo.z + 0.5)\r
+        : compactSlotState\r
+            ? (compactInfo.z < -0.5 ? -1 : int(compactInfo.z + 0.5))\r
+            : u_atlasPage;\r
+    vec4 clipRect = instanceState\r
+        ? a_instanceClipRect\r
+        : compactSlotState ? compactClip : u_clipRect;\r
+    float clipEnabled = instanceState\r
+        ? a_instanceInfo.x\r
+        : compactSlotState ? compactInfo.x : u_clipEnabled;\r
+    vec2 world = vec2(\r
+        parentAffine.x * local.x + parentAffine.z * local.y + parentTranslate.x,\r
+        parentAffine.y * local.x + parentAffine.w * local.y + parentTranslate.y\r
+    );\r
+\r
+    gl_Position = u_projection * vec4(world, 0.0, 1.0);\r
+    v_uv = mix(metadata0.xy, metadata0.zw, a_corner);\r
+    bool pageMatches = atlasPage < 0 || int(max(metadata1.y, 0.0) + 0.5) == atlasPage;\r
+    int metadataFlags = int(max(metadata1.z, 0.0) + 0.5);\r
+    bool metadataPresent = (metadataFlags & 1) == 0;\r
+    float pageAlpha = pageMatches && metadataPresent ? 1.0 : 0.0;\r
+    float effectiveAlpha = frame2.x * slotOpacity * pageAlpha;\r
+    // Match the CPU reference's strict \`< 0.05\` visibility cutoff.\r
+    v_color = vec4(1.0, 1.0, 1.0, effectiveAlpha >= 0.05 ? effectiveAlpha : 0.0);\r
+    v_clipRect = clipRect;\r
+    v_clipEnabled = clipEnabled;\r
+    v_localPosition = vec2(layoutW * a_corner.x, layoutH * a_corner.y);\r
+    v_localClipRect = metadata2;\r
+    v_localClipEnabled = (metadataFlags & 2) != 0 ? 1.0 : 0.0;\r
+}\r
 `, uE = `#version 300 es
 precision highp float;
 
@@ -791,67 +791,67 @@ void main() {\r
   float coverage = 1.0 - smoothstep(0.45, 1.0, distanceToCenter);\r
   outColor = v_color * coverage;\r
 }\r
-`, TE = `#version 300 es
-precision highp float;
-
-layout(location = 0) in vec2 a_corner;
-layout(location = 1) in vec4 a_birthLifePosition;
-layout(location = 2) in vec4 a_velocityAcceleration;
-layout(location = 3) in vec4 a_scaleRotation;
-layout(location = 4) in vec4 a_color;
-layout(location = 5) in vec4 a_sizeAnchor;
-layout(location = 6) in vec4 a_uvRect;
-
-uniform mat4 u_projection;
-uniform float u_time;
-uniform float u_globalAlpha;
-uniform float u_sizeEnvelope;
-uniform float u_fadeMode;
-uniform vec2 u_cssScale;
-
-out vec2 v_uv;
-out vec4 v_modulation;
-
-void main() {
-  float age = u_time - a_birthLifePosition.x;
-  float life = max(a_birthLifePosition.y, 0.0001);
-  bool alive = age >= 0.0 && age <= life;
-  float safeAge = max(age, 0.0);
-  vec2 position = a_birthLifePosition.zw
-    + a_velocityAcceleration.xy * safeAge
-    + 0.5 * a_velocityAcceleration.zw * safeAge * safeAge;
-  float scale = max(0.04, a_scaleRotation.x + a_scaleRotation.y * safeAge) * u_sizeEnvelope;
-  vec2 unitCorner = a_corner + 0.5;
-  vec2 local = (unitCorner - a_sizeAnchor.zw) * a_sizeAnchor.xy * scale;
-  float angle = a_scaleRotation.z + a_scaleRotation.w * safeAge;
-  float c = cos(angle);
-  float s = sin(angle);
-  vec2 rotated = vec2(c * local.x - s * local.y, s * local.x + c * local.y);
-  float progress = clamp(safeAge / life, 0.0, 1.0);
-  float fade = u_fadeMode > 0.5
-    ? min(safeAge / 0.04, 1.0) * pow(1.0 - progress, 0.78)
-    : 1.0;
-  if (!alive) {
-    position = vec2(-100000.0);
-    fade = 0.0;
-  }
-  gl_Position = u_projection * vec4((position + rotated) * u_cssScale, 0.0, 1.0);
-  v_uv = mix(a_uvRect.xy, a_uvRect.zw, unitCorner);
-  float alpha = a_color.a * fade * u_globalAlpha;
-  v_modulation = vec4(a_color.rgb * alpha, alpha);
-}
-`, vE = `#version 300 es
-precision highp float;
-
-uniform sampler2D u_atlas;
-in vec2 v_uv;
-in vec4 v_modulation;
-out vec4 outColor;
-
-void main() {
-  vec4 sampled = texture(u_atlas, v_uv);
-  outColor = vec4(sampled.rgb * v_modulation.rgb, sampled.a * v_modulation.a);
-}
+`, TE = `#version 300 es\r
+precision highp float;\r
+\r
+layout(location = 0) in vec2 a_corner;\r
+layout(location = 1) in vec4 a_birthLifePosition;\r
+layout(location = 2) in vec4 a_velocityAcceleration;\r
+layout(location = 3) in vec4 a_scaleRotation;\r
+layout(location = 4) in vec4 a_color;\r
+layout(location = 5) in vec4 a_sizeAnchor;\r
+layout(location = 6) in vec4 a_uvRect;\r
+\r
+uniform mat4 u_projection;\r
+uniform float u_time;\r
+uniform float u_globalAlpha;\r
+uniform float u_sizeEnvelope;\r
+uniform float u_fadeMode;\r
+uniform vec2 u_cssScale;\r
+\r
+out vec2 v_uv;\r
+out vec4 v_modulation;\r
+\r
+void main() {\r
+  float age = u_time - a_birthLifePosition.x;\r
+  float life = max(a_birthLifePosition.y, 0.0001);\r
+  bool alive = age >= 0.0 && age <= life;\r
+  float safeAge = max(age, 0.0);\r
+  vec2 position = a_birthLifePosition.zw\r
+    + a_velocityAcceleration.xy * safeAge\r
+    + 0.5 * a_velocityAcceleration.zw * safeAge * safeAge;\r
+  float scale = max(0.04, a_scaleRotation.x + a_scaleRotation.y * safeAge) * u_sizeEnvelope;\r
+  vec2 unitCorner = a_corner + 0.5;\r
+  vec2 local = (unitCorner - a_sizeAnchor.zw) * a_sizeAnchor.xy * scale;\r
+  float angle = a_scaleRotation.z + a_scaleRotation.w * safeAge;\r
+  float c = cos(angle);\r
+  float s = sin(angle);\r
+  vec2 rotated = vec2(c * local.x - s * local.y, s * local.x + c * local.y);\r
+  float progress = clamp(safeAge / life, 0.0, 1.0);\r
+  float fade = u_fadeMode > 0.5\r
+    ? min(safeAge / 0.04, 1.0) * pow(1.0 - progress, 0.78)\r
+    : 1.0;\r
+  if (!alive) {\r
+    position = vec2(-100000.0);\r
+    fade = 0.0;\r
+  }\r
+  gl_Position = u_projection * vec4((position + rotated) * u_cssScale, 0.0, 1.0);\r
+  v_uv = mix(a_uvRect.xy, a_uvRect.zw, unitCorner);\r
+  float alpha = a_color.a * fade * u_globalAlpha;\r
+  v_modulation = vec4(a_color.rgb * alpha, alpha);\r
+}\r
+`, vE = `#version 300 es\r
+precision highp float;\r
+\r
+uniform sampler2D u_atlas;\r
+in vec2 v_uv;\r
+in vec4 v_modulation;\r
+out vec4 outColor;\r
+\r
+void main() {\r
+  vec4 sampled = texture(u_atlas, v_uv);\r
+  outColor = vec4(sampled.rgb * v_modulation.rgb, sampled.a * v_modulation.a);\r
+}\r
 `, WE = `/** SVGA atlas variant for premultiplied RGBA atlas textures. */\r
 struct Uniforms {\r
     projection: mat4x4f,\r
@@ -1357,78 +1357,78 @@ fn fs(input: VOut) -> @location(0) vec4f {\r
     let coverage = 1.0 - smoothstep(0.45, 1.0, distanceToCenter);\r
     return input.color * coverage;\r
 }\r
-`, gi = `struct Globals {
-    projection: mat4x4f,
-}
-
-@group(0) @binding(0) var<uniform> globals: Globals;
-@group(0) @binding(1) var<storage, read> instanceData: array<f32>;
-@group(1) @binding(0) var atlasTexture: texture_2d<f32>;
-@group(1) @binding(1) var atlasSampler: sampler;
-
-struct VIn {
-    @location(0) corner: vec2f,
-}
-
-struct VOut {
-    @builtin(position) position: vec4f,
-    @location(0) uv: vec2f,
-    @location(1) modulation: vec4f,
-}
-
-@vertex
-fn vs(input: VIn, @builtin(instance_index) instance: u32) -> VOut {
-    let base = 8u + instance * 24u;
-    let birth = instanceData[base];
-    let life = max(instanceData[base + 1u], 0.0001);
-    let age = instanceData[0] - birth;
-    let safeAge = max(age, 0.0);
-    var position = vec2f(instanceData[base + 2u], instanceData[base + 3u])
-        + vec2f(instanceData[base + 4u], instanceData[base + 5u]) * safeAge
-        + 0.5 * vec2f(instanceData[base + 6u], instanceData[base + 7u]) * safeAge * safeAge;
-    let scale = max(0.04, instanceData[base + 8u] + instanceData[base + 9u] * safeAge)
-        * instanceData[2];
-    let unitCorner = input.corner + vec2f(0.5);
-    let anchor = vec2f(instanceData[base + 18u], instanceData[base + 19u]);
-    let spriteSize = vec2f(instanceData[base + 16u], instanceData[base + 17u]);
-    let local = (unitCorner - anchor) * spriteSize * scale;
-    let angle = instanceData[base + 10u] + instanceData[base + 11u] * safeAge;
-    let c = cos(angle);
-    let s = sin(angle);
-    let rotated = vec2f(c * local.x - s * local.y, s * local.x + c * local.y);
-    let progress = clamp(safeAge / life, 0.0, 1.0);
-    var fade = select(
-        1.0,
-        min(safeAge / 0.04, 1.0) * pow(1.0 - progress, 0.78),
-        instanceData[3] > 0.5,
-    );
-    if (age < 0.0 || age > life) {
-        position = vec2f(-100000.0);
-        fade = 0.0;
-    }
-    let cssScale = vec2f(instanceData[4], instanceData[5]);
-    let alpha = instanceData[base + 15u] * fade * instanceData[1];
-    var output: VOut;
-    output.position = globals.projection * vec4f((position + rotated) * cssScale, 0.0, 1.0);
-    output.uv = mix(
-        vec2f(instanceData[base + 20u], instanceData[base + 21u]),
-        vec2f(instanceData[base + 22u], instanceData[base + 23u]),
-        unitCorner,
-    );
-    output.modulation = vec4f(
-        instanceData[base + 12u] * alpha,
-        instanceData[base + 13u] * alpha,
-        instanceData[base + 14u] * alpha,
-        alpha,
-    );
-    return output;
-}
-
-@fragment
-fn fs(input: VOut) -> @location(0) vec4f {
-    let sampled = textureSample(atlasTexture, atlasSampler, input.uv);
-    return vec4f(sampled.rgb * input.modulation.rgb, sampled.a * input.modulation.a);
-}
+`, gi = `struct Globals {\r
+    projection: mat4x4f,\r
+}\r
+\r
+@group(0) @binding(0) var<uniform> globals: Globals;\r
+@group(0) @binding(1) var<storage, read> instanceData: array<f32>;\r
+@group(1) @binding(0) var atlasTexture: texture_2d<f32>;\r
+@group(1) @binding(1) var atlasSampler: sampler;\r
+\r
+struct VIn {\r
+    @location(0) corner: vec2f,\r
+}\r
+\r
+struct VOut {\r
+    @builtin(position) position: vec4f,\r
+    @location(0) uv: vec2f,\r
+    @location(1) modulation: vec4f,\r
+}\r
+\r
+@vertex\r
+fn vs(input: VIn, @builtin(instance_index) instance: u32) -> VOut {\r
+    let base = 8u + instance * 24u;\r
+    let birth = instanceData[base];\r
+    let life = max(instanceData[base + 1u], 0.0001);\r
+    let age = instanceData[0] - birth;\r
+    let safeAge = max(age, 0.0);\r
+    var position = vec2f(instanceData[base + 2u], instanceData[base + 3u])\r
+        + vec2f(instanceData[base + 4u], instanceData[base + 5u]) * safeAge\r
+        + 0.5 * vec2f(instanceData[base + 6u], instanceData[base + 7u]) * safeAge * safeAge;\r
+    let scale = max(0.04, instanceData[base + 8u] + instanceData[base + 9u] * safeAge)\r
+        * instanceData[2];\r
+    let unitCorner = input.corner + vec2f(0.5);\r
+    let anchor = vec2f(instanceData[base + 18u], instanceData[base + 19u]);\r
+    let spriteSize = vec2f(instanceData[base + 16u], instanceData[base + 17u]);\r
+    let local = (unitCorner - anchor) * spriteSize * scale;\r
+    let angle = instanceData[base + 10u] + instanceData[base + 11u] * safeAge;\r
+    let c = cos(angle);\r
+    let s = sin(angle);\r
+    let rotated = vec2f(c * local.x - s * local.y, s * local.x + c * local.y);\r
+    let progress = clamp(safeAge / life, 0.0, 1.0);\r
+    var fade = select(\r
+        1.0,\r
+        min(safeAge / 0.04, 1.0) * pow(1.0 - progress, 0.78),\r
+        instanceData[3] > 0.5,\r
+    );\r
+    if (age < 0.0 || age > life) {\r
+        position = vec2f(-100000.0);\r
+        fade = 0.0;\r
+    }\r
+    let cssScale = vec2f(instanceData[4], instanceData[5]);\r
+    let alpha = instanceData[base + 15u] * fade * instanceData[1];\r
+    var output: VOut;\r
+    output.position = globals.projection * vec4f((position + rotated) * cssScale, 0.0, 1.0);\r
+    output.uv = mix(\r
+        vec2f(instanceData[base + 20u], instanceData[base + 21u]),\r
+        vec2f(instanceData[base + 22u], instanceData[base + 23u]),\r
+        unitCorner,\r
+    );\r
+    output.modulation = vec4f(\r
+        instanceData[base + 12u] * alpha,\r
+        instanceData[base + 13u] * alpha,\r
+        instanceData[base + 14u] * alpha,\r
+        alpha,\r
+    );\r
+    return output;\r
+}\r
+\r
+@fragment\r
+fn fs(input: VOut) -> @location(0) vec4f {\r
+    let sampled = textureSample(atlasTexture, atlasSampler, input.uv);\r
+    return vec4f(sampled.rgb * input.modulation.rgb, sampled.a * input.modulation.a);\r
+}\r
 `, Ii = `struct Globals {\r
     projection: mat4x4f,\r
 }\r
@@ -1773,292 +1773,292 @@ fn applyMotionPoint(point: vec2f, center: vec2f, scale: vec2f, cosine: f32, sine
   svgaMotionInstancedPremul: Ii,
   svgaFrameTableShape: Bi,
   svgaFrameTableClipMask: Ci
-}, Qi = `/// SVGA timeline/table variant for premultiplied RGBA atlas textures.
-///
-/// The frame table and sprite metadata are resident storage buffers. A draw
-/// submits one instance per sprite. Direct draws derive the sprite index from
-/// the GPU instance index and only upload the slot/global uniform. Hybrid
-/// draws can additionally bind compact CPU-precompiled scheduling rows that
-/// omit the SVGA child matrix and alpha fetched from the frame table.
-///
-/// Frame table: three vec4 values per (sprite, frame):
-///   0: layoutW, layoutH, a, b
-///   1: c, d, tx, ty
-///   2: alpha, reserved, reserved, reserved
-///
-/// Sprite metadata: two vec4 values per draw sprite:
-///   0: atlas UV min.xy / max.xy
-///   1: source sprite index, atlas page, flags, reserved
-///
-/// Uniform layout:
-///   projection                 mat4x4f (64 bytes)
-///   parentAffine               vec4f   (a, b, c, d)
-///   translateOpacityFrame      vec4f   (tx, ty, opacity, frameIndex)
-///   clipRect                   vec4f   (top-left x0, y0, x1, y1)
-///   drawInfo                   vec4u   (metadataBase, drawSpriteCount, clipEnabled, trackIndex+1)
-///   tableInfo                  vec4u   (frameCount, spriteCount, vec4sPerFrame, 0)
-///   batchInfo                  vec4u   (spritesPerSlot, metadataVec4Stride, stateMode, 0)
-
-struct Globals {
-    projection: mat4x4f,
-    parentAffine: vec4f,
-    translateOpacityFrame: vec4f,
-    clipRect: vec4f,
-    drawInfo: vec4u,
-    tableInfo: vec4u,
-    batchInfo: vec4u,
-}
-
-struct MotionGlobals {
-    timeMs: f32,
-    sampleIntervalMs: f32,
-    sampleCount: f32,
-    cssScaleX: f32,
-    cssScaleY: f32,
-    pad0: f32,
-    pad1: f32,
-    pad2: f32,
-}
-
-@group(0) @binding(0) var<uniform> globals: Globals;
-@group(0) @binding(1) var<storage, read> frameTable: array<vec4f>;
-@group(0) @binding(2) var<storage, read> spriteMetadata: array<vec4f>;
-@group(0) @binding(3) var<storage, read> motionData: array<f32>;
-@group(0) @binding(4) var<uniform> motionGlobals: MotionGlobals;
-// Canonical four-vec4 / 16-float slot row: affine; translate+opacity+frame;
-// clip rect; clipEnabled+metadataBase+atlasPage+motionTrack+1.
-// Optional Hybrid scheduling rows use this exact schema per draw instance.
-// Direct draws bind a harmless dummy slice and leave drawInfo bit 1 clear.
-@group(0) @binding(5) var<storage, read> hybridInstances: array<vec4f>;
-@group(1) @binding(0) var atlasTex: texture_2d<f32>;
-@group(1) @binding(1) var atlasSampler: sampler;
-
-struct VIn {
-    @location(0) corner: vec2f,
-}
-
-struct VOut {
-    @builtin(position) pos: vec4f,
-    @location(0) uv: vec2f,
-    @location(1) color: vec4f,
-    @location(2) @interpolate(flat) clipRect: vec4f,
-    @location(3) @interpolate(flat) clipEnabled: f32,
-    @location(4) localPosition: vec2f,
-    @location(5) @interpolate(flat) localClipRect: vec4f,
-    @location(6) @interpolate(flat) localClipEnabled: f32,
-}
-
-fn readFrameValue(index: u32) -> vec4f {
-    return frameTable[index];
-}
-
-fn sampleMotion(track: u32, channel: u32) -> f32 {
-    let sampleCount = max(u32(motionGlobals.sampleCount), 1u);
-    let samplePosition = clamp(
-        motionGlobals.timeMs / max(motionGlobals.sampleIntervalMs, 0.001),
-        0.0,
-        f32(sampleCount - 1u),
-    );
-    let left = u32(floor(samplePosition));
-    let right = min(sampleCount - 1u, left + 1u);
-    let trackBase = track * sampleCount * 8u;
-    let leftBase = trackBase + left * 8u;
-    let rightBase = trackBase + right * 8u;
-    let interpolate = left != right && motionData[leftBase + 7u] > 0.5 && channel < 6u;
-    if (!interpolate) {
-        return motionData[leftBase + channel];
-    }
-    let progress = samplePosition - f32(left);
-    return mix(motionData[leftBase + channel], motionData[rightBase + channel], progress);
-}
-
-fn applyMotionPoint(
-    point: vec2f,
-    center: vec2f,
-    scale: vec2f,
-    cosine: f32,
-    sine: f32,
-) -> vec2f {
-    let scaled = point * scale;
-    return center + vec2f(
-        cosine * scaled.x - sine * scaled.y,
-        sine * scaled.x + cosine * scaled.y,
-    );
-}
-
-@vertex
-fn vs(input: VIn, @builtin(instance_index) instance: u32) -> VOut {
-    let safeInstance = min(instance, max(globals.drawInfo.y, 1u) - 1u);
-    let hybrid = (globals.drawInfo.z & 2u) != 0u;
-    let compactSlots = (globals.drawInfo.z & 4u) != 0u;
-    let spritesPerSlot = max(globals.batchInfo.x, 1u);
-    let slotStateIndex = select(safeInstance, safeInstance / spritesPerSlot, compactSlots);
-    let hybridBase = slotStateIndex * 4u;
-    var hybridParent = vec4f(0.0);
-    var hybridTranslateOpacityFrame = vec4f(0.0);
-    var hybridClip = vec4f(0.0);
-    var hybridInfo = vec4f(0.0);
-    if (hybrid || compactSlots) {
-        hybridParent = hybridInstances[hybridBase];
-        hybridTranslateOpacityFrame = hybridInstances[hybridBase + 1u];
-        hybridClip = hybridInstances[hybridBase + 2u];
-        hybridInfo = hybridInstances[hybridBase + 3u];
-    }
-    let spriteWithinSlot = select(safeInstance, safeInstance % spritesPerSlot, compactSlots);
-    let metadataIndex = select(
-        globals.drawInfo.x + spriteWithinSlot,
-        u32(max(hybridInfo.y, 0.0)),
-        hybrid,
-    );
-    let metadataStride = max(globals.batchInfo.y, 2u);
-    let metadataBase = metadataIndex * metadataStride;
-    let metadataUv = spriteMetadata[metadataBase];
-    let metadataSprite = spriteMetadata[metadataBase + 1u];
-    var metadataClip = vec4f(0.0);
-    if (metadataStride >= 3u) {
-        metadataClip = spriteMetadata[metadataBase + 2u];
-    }
-    let metadataPage = metadataSprite.y;
-    let metadataFlags = u32(max(metadataSprite.z, 0.0));
-    // The source sprite index is explicit so a page-specific metadata range
-    // can represent non-contiguous atlas pages without duplicating frame rows.
-    // A page mismatch is made transparent so an invalid plan cannot sample a
-    // sprite into the wrong atlas page.
-    let spriteIndex = u32(max(metadataSprite.x, 0.0));
-
-    let frameCount = max(globals.tableInfo.x, 1u);
-    let spriteCount = max(globals.tableInfo.y, 1u);
-    let safeSprite = min(spriteIndex, spriteCount - 1u);
-    let selectedFrame = select(
-        globals.translateOpacityFrame.w,
-        hybridTranslateOpacityFrame.w,
-        hybrid || compactSlots,
-    );
-    let safeFrame = min(
-        u32(max(selectedFrame, 0.0)),
-        frameCount - 1u,
-    );
-    let tableBase = (safeSprite * frameCount + safeFrame) * globals.tableInfo.z;
-    let frame0 = readFrameValue(tableBase);
-    let frame1 = readFrameValue(tableBase + 1u);
-    let frame2 = readFrameValue(tableBase + 2u);
-
-    let layoutW = frame0.x;
-    let layoutH = frame0.y;
-    let local = vec2f(
-        frame0.z * layoutW * input.corner.x + frame1.x * layoutH * input.corner.y + frame1.z,
-        frame0.w * layoutW * input.corner.x + frame1.y * layoutH * input.corner.y + frame1.w,
-    );
-
-    let instanceSlotState = hybrid || compactSlots;
-    let parent = select(globals.parentAffine, hybridParent, instanceSlotState);
-    let parentTranslate = select(
-        globals.translateOpacityFrame.xy,
-        hybridTranslateOpacityFrame.xy,
-        instanceSlotState,
-    );
-    let parentLocal = vec2f(
-        parent.x * local.x + parent.z * local.y + parentTranslate.x,
-        parent.y * local.x + parent.w * local.y + parentTranslate.y,
-    );
-    let instanceTrack = u32(max(hybridInfo.w, 0.0));
-    let selectedTrack = select(globals.drawInfo.w, instanceTrack, compactSlots);
-    let hasParentMotion = selectedTrack > 0u;
-    var world = parentLocal;
-    var outerClip = select(globals.clipRect, hybridClip, instanceSlotState);
-    let outerClipEnabled = select(
-        f32(globals.drawInfo.z & 1u),
-        hybridInfo.x,
-        instanceSlotState,
-    );
-    var parentOpacity = select(
-        globals.translateOpacityFrame.z,
-        hybridTranslateOpacityFrame.z,
-        instanceSlotState,
-    );
-    if (hasParentMotion) {
-        let track = selectedTrack - 1u;
-        let scale = vec2f(sampleMotion(track, 2u), sampleMotion(track, 3u));
-        let angle = sampleMotion(track, 4u);
-        let cosine = cos(angle);
-        let sine = sin(angle);
-        let center = vec2f(
-            sampleMotion(track, 0u) * motionGlobals.cssScaleX,
-            sampleMotion(track, 1u) * motionGlobals.cssScaleY,
-        );
-        world = applyMotionPoint(parentLocal, center, scale, cosine, sine);
-        let clip0 = applyMotionPoint(outerClip.xy, center, scale, cosine, sine);
-        let clip1 = applyMotionPoint(vec2f(outerClip.z, outerClip.y), center, scale, cosine, sine);
-        let clip2 = applyMotionPoint(outerClip.zw, center, scale, cosine, sine);
-        let clip3 = applyMotionPoint(vec2f(outerClip.x, outerClip.w), center, scale, cosine, sine);
-        outerClip = vec4f(
-            min(min(clip0.x, clip1.x), min(clip2.x, clip3.x)),
-            min(min(clip0.y, clip1.y), min(clip2.y, clip3.y)),
-            max(max(clip0.x, clip1.x), max(clip2.x, clip3.x)),
-            max(max(clip0.y, clip1.y), max(clip2.y, clip3.y)),
-        );
-        let visible = sampleMotion(track, 6u);
-        parentOpacity = sampleMotion(track, 5u) * select(0.0, 1.0, visible > 0.5);
-    }
-
-    var output: VOut;
-    output.pos = globals.projection * vec4f(world, 0.0, 1.0);
-    output.uv = mix(metadataUv.xy, metadataUv.zw, input.corner);
-    var pageMatchesValue = globals.tableInfo.w == 0xffffffffu ||
-        u32(max(metadataPage, 0.0)) == globals.tableInfo.w;
-    if (hybrid || compactSlots) {
-        pageMatchesValue = hybridInfo.z < -0.5 ||
-            i32(round(metadataPage)) == i32(round(hybridInfo.z));
-    }
-    let pageMatches = select(
-        0.0,
-        1.0,
-        pageMatchesValue,
-    );
-    let metadataPresent = select(1.0, 0.0, (metadataFlags & 1u) != 0u);
-    // Keep the table path's visibility cutoff identical to the CPU reference
-    // renderer: rows below 0.05 are culled before issuing meaningful color.
-    // Exactly 0.05 remains visible (the reference uses a strict \`< 0.05\` test).
-    let effectiveAlpha = frame2.x * parentOpacity * pageMatches * metadataPresent;
-    let visibleAlpha = select(0.0, effectiveAlpha, effectiveAlpha >= 0.05);
-    output.color = vec4f(visibleAlpha);
-    output.clipRect = outerClip;
-    output.clipEnabled = outerClipEnabled;
-    output.localPosition = vec2f(layoutW * input.corner.x, layoutH * input.corner.y);
-    output.localClipRect = metadataClip;
-    output.localClipEnabled = select(0.0, 1.0, (metadataFlags & 2u) != 0u);
-    return output;
-}
-
-@fragment
-fn fs(input: VOut) -> @location(0) vec4f {
-    if (input.color.a < 0.05) {
-        discard;
-    }
-    if (input.clipEnabled > 0.5) {
-        if (
-            input.pos.x < input.clipRect.x ||
-            input.pos.y < input.clipRect.y ||
-            input.pos.x >= input.clipRect.z ||
-            input.pos.y >= input.clipRect.w
-        ) {
-            discard;
-        }
-    }
-    if (
-        input.localClipEnabled > 0.5 &&
-        (
-            input.localPosition.x < input.localClipRect.x ||
-            input.localPosition.y < input.localClipRect.y ||
-            input.localPosition.x >= input.localClipRect.z ||
-            input.localPosition.y >= input.localClipRect.w
-        )
-    ) {
-        discard;
-    }
-    let color = textureSample(atlasTex, atlasSampler, input.uv);
-    return vec4f(color.rgb * input.color.a, color.a * input.color.a);
-}
+}, Qi = `/// SVGA timeline/table variant for premultiplied RGBA atlas textures.\r
+///\r
+/// The frame table and sprite metadata are resident storage buffers. A draw\r
+/// submits one instance per sprite. Direct draws derive the sprite index from\r
+/// the GPU instance index and only upload the slot/global uniform. Hybrid\r
+/// draws can additionally bind compact CPU-precompiled scheduling rows that\r
+/// omit the SVGA child matrix and alpha fetched from the frame table.\r
+///\r
+/// Frame table: three vec4 values per (sprite, frame):\r
+///   0: layoutW, layoutH, a, b\r
+///   1: c, d, tx, ty\r
+///   2: alpha, reserved, reserved, reserved\r
+///\r
+/// Sprite metadata: two vec4 values per draw sprite:\r
+///   0: atlas UV min.xy / max.xy\r
+///   1: source sprite index, atlas page, flags, reserved\r
+///\r
+/// Uniform layout:\r
+///   projection                 mat4x4f (64 bytes)\r
+///   parentAffine               vec4f   (a, b, c, d)\r
+///   translateOpacityFrame      vec4f   (tx, ty, opacity, frameIndex)\r
+///   clipRect                   vec4f   (top-left x0, y0, x1, y1)\r
+///   drawInfo                   vec4u   (metadataBase, drawSpriteCount, clipEnabled, trackIndex+1)\r
+///   tableInfo                  vec4u   (frameCount, spriteCount, vec4sPerFrame, 0)\r
+///   batchInfo                  vec4u   (spritesPerSlot, metadataVec4Stride, stateMode, 0)\r
+\r
+struct Globals {\r
+    projection: mat4x4f,\r
+    parentAffine: vec4f,\r
+    translateOpacityFrame: vec4f,\r
+    clipRect: vec4f,\r
+    drawInfo: vec4u,\r
+    tableInfo: vec4u,\r
+    batchInfo: vec4u,\r
+}\r
+\r
+struct MotionGlobals {\r
+    timeMs: f32,\r
+    sampleIntervalMs: f32,\r
+    sampleCount: f32,\r
+    cssScaleX: f32,\r
+    cssScaleY: f32,\r
+    pad0: f32,\r
+    pad1: f32,\r
+    pad2: f32,\r
+}\r
+\r
+@group(0) @binding(0) var<uniform> globals: Globals;\r
+@group(0) @binding(1) var<storage, read> frameTable: array<vec4f>;\r
+@group(0) @binding(2) var<storage, read> spriteMetadata: array<vec4f>;\r
+@group(0) @binding(3) var<storage, read> motionData: array<f32>;\r
+@group(0) @binding(4) var<uniform> motionGlobals: MotionGlobals;\r
+// Canonical four-vec4 / 16-float slot row: affine; translate+opacity+frame;\r
+// clip rect; clipEnabled+metadataBase+atlasPage+motionTrack+1.\r
+// Optional Hybrid scheduling rows use this exact schema per draw instance.\r
+// Direct draws bind a harmless dummy slice and leave drawInfo bit 1 clear.\r
+@group(0) @binding(5) var<storage, read> hybridInstances: array<vec4f>;\r
+@group(1) @binding(0) var atlasTex: texture_2d<f32>;\r
+@group(1) @binding(1) var atlasSampler: sampler;\r
+\r
+struct VIn {\r
+    @location(0) corner: vec2f,\r
+}\r
+\r
+struct VOut {\r
+    @builtin(position) pos: vec4f,\r
+    @location(0) uv: vec2f,\r
+    @location(1) color: vec4f,\r
+    @location(2) @interpolate(flat) clipRect: vec4f,\r
+    @location(3) @interpolate(flat) clipEnabled: f32,\r
+    @location(4) localPosition: vec2f,\r
+    @location(5) @interpolate(flat) localClipRect: vec4f,\r
+    @location(6) @interpolate(flat) localClipEnabled: f32,\r
+}\r
+\r
+fn readFrameValue(index: u32) -> vec4f {\r
+    return frameTable[index];\r
+}\r
+\r
+fn sampleMotion(track: u32, channel: u32) -> f32 {\r
+    let sampleCount = max(u32(motionGlobals.sampleCount), 1u);\r
+    let samplePosition = clamp(\r
+        motionGlobals.timeMs / max(motionGlobals.sampleIntervalMs, 0.001),\r
+        0.0,\r
+        f32(sampleCount - 1u),\r
+    );\r
+    let left = u32(floor(samplePosition));\r
+    let right = min(sampleCount - 1u, left + 1u);\r
+    let trackBase = track * sampleCount * 8u;\r
+    let leftBase = trackBase + left * 8u;\r
+    let rightBase = trackBase + right * 8u;\r
+    let interpolate = left != right && motionData[leftBase + 7u] > 0.5 && channel < 6u;\r
+    if (!interpolate) {\r
+        return motionData[leftBase + channel];\r
+    }\r
+    let progress = samplePosition - f32(left);\r
+    return mix(motionData[leftBase + channel], motionData[rightBase + channel], progress);\r
+}\r
+\r
+fn applyMotionPoint(\r
+    point: vec2f,\r
+    center: vec2f,\r
+    scale: vec2f,\r
+    cosine: f32,\r
+    sine: f32,\r
+) -> vec2f {\r
+    let scaled = point * scale;\r
+    return center + vec2f(\r
+        cosine * scaled.x - sine * scaled.y,\r
+        sine * scaled.x + cosine * scaled.y,\r
+    );\r
+}\r
+\r
+@vertex\r
+fn vs(input: VIn, @builtin(instance_index) instance: u32) -> VOut {\r
+    let safeInstance = min(instance, max(globals.drawInfo.y, 1u) - 1u);\r
+    let hybrid = (globals.drawInfo.z & 2u) != 0u;\r
+    let compactSlots = (globals.drawInfo.z & 4u) != 0u;\r
+    let spritesPerSlot = max(globals.batchInfo.x, 1u);\r
+    let slotStateIndex = select(safeInstance, safeInstance / spritesPerSlot, compactSlots);\r
+    let hybridBase = slotStateIndex * 4u;\r
+    var hybridParent = vec4f(0.0);\r
+    var hybridTranslateOpacityFrame = vec4f(0.0);\r
+    var hybridClip = vec4f(0.0);\r
+    var hybridInfo = vec4f(0.0);\r
+    if (hybrid || compactSlots) {\r
+        hybridParent = hybridInstances[hybridBase];\r
+        hybridTranslateOpacityFrame = hybridInstances[hybridBase + 1u];\r
+        hybridClip = hybridInstances[hybridBase + 2u];\r
+        hybridInfo = hybridInstances[hybridBase + 3u];\r
+    }\r
+    let spriteWithinSlot = select(safeInstance, safeInstance % spritesPerSlot, compactSlots);\r
+    let metadataIndex = select(\r
+        globals.drawInfo.x + spriteWithinSlot,\r
+        u32(max(hybridInfo.y, 0.0)),\r
+        hybrid,\r
+    );\r
+    let metadataStride = max(globals.batchInfo.y, 2u);\r
+    let metadataBase = metadataIndex * metadataStride;\r
+    let metadataUv = spriteMetadata[metadataBase];\r
+    let metadataSprite = spriteMetadata[metadataBase + 1u];\r
+    var metadataClip = vec4f(0.0);\r
+    if (metadataStride >= 3u) {\r
+        metadataClip = spriteMetadata[metadataBase + 2u];\r
+    }\r
+    let metadataPage = metadataSprite.y;\r
+    let metadataFlags = u32(max(metadataSprite.z, 0.0));\r
+    // The source sprite index is explicit so a page-specific metadata range\r
+    // can represent non-contiguous atlas pages without duplicating frame rows.\r
+    // A page mismatch is made transparent so an invalid plan cannot sample a\r
+    // sprite into the wrong atlas page.\r
+    let spriteIndex = u32(max(metadataSprite.x, 0.0));\r
+\r
+    let frameCount = max(globals.tableInfo.x, 1u);\r
+    let spriteCount = max(globals.tableInfo.y, 1u);\r
+    let safeSprite = min(spriteIndex, spriteCount - 1u);\r
+    let selectedFrame = select(\r
+        globals.translateOpacityFrame.w,\r
+        hybridTranslateOpacityFrame.w,\r
+        hybrid || compactSlots,\r
+    );\r
+    let safeFrame = min(\r
+        u32(max(selectedFrame, 0.0)),\r
+        frameCount - 1u,\r
+    );\r
+    let tableBase = (safeSprite * frameCount + safeFrame) * globals.tableInfo.z;\r
+    let frame0 = readFrameValue(tableBase);\r
+    let frame1 = readFrameValue(tableBase + 1u);\r
+    let frame2 = readFrameValue(tableBase + 2u);\r
+\r
+    let layoutW = frame0.x;\r
+    let layoutH = frame0.y;\r
+    let local = vec2f(\r
+        frame0.z * layoutW * input.corner.x + frame1.x * layoutH * input.corner.y + frame1.z,\r
+        frame0.w * layoutW * input.corner.x + frame1.y * layoutH * input.corner.y + frame1.w,\r
+    );\r
+\r
+    let instanceSlotState = hybrid || compactSlots;\r
+    let parent = select(globals.parentAffine, hybridParent, instanceSlotState);\r
+    let parentTranslate = select(\r
+        globals.translateOpacityFrame.xy,\r
+        hybridTranslateOpacityFrame.xy,\r
+        instanceSlotState,\r
+    );\r
+    let parentLocal = vec2f(\r
+        parent.x * local.x + parent.z * local.y + parentTranslate.x,\r
+        parent.y * local.x + parent.w * local.y + parentTranslate.y,\r
+    );\r
+    let instanceTrack = u32(max(hybridInfo.w, 0.0));\r
+    let selectedTrack = select(globals.drawInfo.w, instanceTrack, compactSlots);\r
+    let hasParentMotion = selectedTrack > 0u;\r
+    var world = parentLocal;\r
+    var outerClip = select(globals.clipRect, hybridClip, instanceSlotState);\r
+    let outerClipEnabled = select(\r
+        f32(globals.drawInfo.z & 1u),\r
+        hybridInfo.x,\r
+        instanceSlotState,\r
+    );\r
+    var parentOpacity = select(\r
+        globals.translateOpacityFrame.z,\r
+        hybridTranslateOpacityFrame.z,\r
+        instanceSlotState,\r
+    );\r
+    if (hasParentMotion) {\r
+        let track = selectedTrack - 1u;\r
+        let scale = vec2f(sampleMotion(track, 2u), sampleMotion(track, 3u));\r
+        let angle = sampleMotion(track, 4u);\r
+        let cosine = cos(angle);\r
+        let sine = sin(angle);\r
+        let center = vec2f(\r
+            sampleMotion(track, 0u) * motionGlobals.cssScaleX,\r
+            sampleMotion(track, 1u) * motionGlobals.cssScaleY,\r
+        );\r
+        world = applyMotionPoint(parentLocal, center, scale, cosine, sine);\r
+        let clip0 = applyMotionPoint(outerClip.xy, center, scale, cosine, sine);\r
+        let clip1 = applyMotionPoint(vec2f(outerClip.z, outerClip.y), center, scale, cosine, sine);\r
+        let clip2 = applyMotionPoint(outerClip.zw, center, scale, cosine, sine);\r
+        let clip3 = applyMotionPoint(vec2f(outerClip.x, outerClip.w), center, scale, cosine, sine);\r
+        outerClip = vec4f(\r
+            min(min(clip0.x, clip1.x), min(clip2.x, clip3.x)),\r
+            min(min(clip0.y, clip1.y), min(clip2.y, clip3.y)),\r
+            max(max(clip0.x, clip1.x), max(clip2.x, clip3.x)),\r
+            max(max(clip0.y, clip1.y), max(clip2.y, clip3.y)),\r
+        );\r
+        let visible = sampleMotion(track, 6u);\r
+        parentOpacity = sampleMotion(track, 5u) * select(0.0, 1.0, visible > 0.5);\r
+    }\r
+\r
+    var output: VOut;\r
+    output.pos = globals.projection * vec4f(world, 0.0, 1.0);\r
+    output.uv = mix(metadataUv.xy, metadataUv.zw, input.corner);\r
+    var pageMatchesValue = globals.tableInfo.w == 0xffffffffu ||\r
+        u32(max(metadataPage, 0.0)) == globals.tableInfo.w;\r
+    if (hybrid || compactSlots) {\r
+        pageMatchesValue = hybridInfo.z < -0.5 ||\r
+            i32(round(metadataPage)) == i32(round(hybridInfo.z));\r
+    }\r
+    let pageMatches = select(\r
+        0.0,\r
+        1.0,\r
+        pageMatchesValue,\r
+    );\r
+    let metadataPresent = select(1.0, 0.0, (metadataFlags & 1u) != 0u);\r
+    // Keep the table path's visibility cutoff identical to the CPU reference\r
+    // renderer: rows below 0.05 are culled before issuing meaningful color.\r
+    // Exactly 0.05 remains visible (the reference uses a strict \`< 0.05\` test).\r
+    let effectiveAlpha = frame2.x * parentOpacity * pageMatches * metadataPresent;\r
+    let visibleAlpha = select(0.0, effectiveAlpha, effectiveAlpha >= 0.05);\r
+    output.color = vec4f(visibleAlpha);\r
+    output.clipRect = outerClip;\r
+    output.clipEnabled = outerClipEnabled;\r
+    output.localPosition = vec2f(layoutW * input.corner.x, layoutH * input.corner.y);\r
+    output.localClipRect = metadataClip;\r
+    output.localClipEnabled = select(0.0, 1.0, (metadataFlags & 2u) != 0u);\r
+    return output;\r
+}\r
+\r
+@fragment\r
+fn fs(input: VOut) -> @location(0) vec4f {\r
+    if (input.color.a < 0.05) {\r
+        discard;\r
+    }\r
+    if (input.clipEnabled > 0.5) {\r
+        if (\r
+            input.pos.x < input.clipRect.x ||\r
+            input.pos.y < input.clipRect.y ||\r
+            input.pos.x >= input.clipRect.z ||\r
+            input.pos.y >= input.clipRect.w\r
+        ) {\r
+            discard;\r
+        }\r
+    }\r
+    if (\r
+        input.localClipEnabled > 0.5 &&\r
+        (\r
+            input.localPosition.x < input.localClipRect.x ||\r
+            input.localPosition.y < input.localClipRect.y ||\r
+            input.localPosition.x >= input.localClipRect.z ||\r
+            input.localPosition.y >= input.localClipRect.w\r
+        )\r
+    ) {\r
+        discard;\r
+    }\r
+    let color = textureSample(atlasTex, atlasSampler, input.uv);\r
+    return vec4f(color.rgb * input.color.a, color.a * input.color.a);\r
+}\r
 `, tg = Object.freeze({
   submitted: !0
 });
@@ -17052,18 +17052,18 @@ async function I(t, e, n, o, s) {
 }
 function v(t, e, n, o, s, i) {
   if (n.w <= 0 || n.h <= 0 || i <= 0) return;
-  const l = Math.max(1, Math.floor(i * 0.5)), a = n.x, c = n.y, h = n.w, r = n.h, f = Math.min(l, a), u = Math.min(l, c), d = Math.min(l, o - (a + h)), w = Math.min(l, s - (c + r)), H = e.imageSmoothingEnabled;
-  e.imageSmoothingEnabled = !1, f > 0 && e.drawImage(t, a, c, 1, r, a - f, c, f, r), d > 0 && e.drawImage(t, a + h - 1, c, 1, r, a + h, c, d, r), u > 0 && e.drawImage(t, a, c, h, 1, a, c - u, h, u), w > 0 && e.drawImage(t, a, c + r - 1, h, 1, a, c + r, h, w), f > 0 && u > 0 && e.drawImage(t, a, c, 1, 1, a - f, c - u, f, u), d > 0 && u > 0 && e.drawImage(t, a + h - 1, c, 1, 1, a + h, c - u, d, u), f > 0 && w > 0 && e.drawImage(t, a, c + r - 1, 1, 1, a - f, c + r, f, w), d > 0 && w > 0 && e.drawImage(t, a + h - 1, c + r - 1, 1, 1, a + h, c + r, d, w), e.imageSmoothingEnabled = H;
+  const l = Math.max(1, Math.floor(i * 0.5)), a = n.x, c = n.y, h = n.w, r = n.h, f = Math.min(l, a), u = Math.min(l, c), w = Math.min(l, o - (a + h)), d = Math.min(l, s - (c + r)), H = e.imageSmoothingEnabled;
+  e.imageSmoothingEnabled = !1, f > 0 && e.drawImage(t, a, c, 1, r, a - f, c, f, r), w > 0 && e.drawImage(t, a + h - 1, c, 1, r, a + h, c, w, r), u > 0 && e.drawImage(t, a, c, h, 1, a, c - u, h, u), d > 0 && e.drawImage(t, a, c + r - 1, h, 1, a, c + r, h, d), f > 0 && u > 0 && e.drawImage(t, a, c, 1, 1, a - f, c - u, f, u), w > 0 && u > 0 && e.drawImage(t, a + h - 1, c, 1, 1, a + h, c - u, w, u), f > 0 && d > 0 && e.drawImage(t, a, c + r - 1, 1, 1, a - f, c + r, f, d), w > 0 && d > 0 && e.drawImage(t, a + h - 1, c + r - 1, 1, 1, a + h, c + r, w, d), e.imageSmoothingEnabled = H;
 }
 var E = Object.defineProperty, C = (t, e, n) => e in t ? E(t, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[e] = n, M = (t, e, n) => C(t, typeof e != "symbol" ? e + "" : e, n);
 function g() {
   return typeof performance != "undefined" ? performance.now() : Date.now();
 }
-function S(t) {
+function A(t) {
   const e = t != null ? t : 4;
   return Number.isFinite(e) ? Math.max(1, Math.min(8, e)) : 4;
 }
-class T {
+class S {
   constructor(e = 4) {
     this.maxSliceMs = e, M(this, "sliceStartedAt", g());
   }
@@ -17071,7 +17071,7 @@ class T {
     g() - this.sliceStartedAt < this.maxSliceMs || (await new Promise((e) => setTimeout(e, 0)), this.sliceStartedAt = g());
   }
 }
-class A {
+class T {
   constructor() {
     M(this, "running", !1), M(this, "tasks", []);
   }
@@ -17090,7 +17090,7 @@ class A {
     }
   }
 }
-const m = self, Y = new A();
+const m = self, Y = new T();
 async function _(t, e, n, o) {
   const s = new OffscreenCanvas(t.atlasW, t.atlasH), i = s.getContext("2d");
   if (!i) throw new Error("Atlas worker: 2d context unavailable");
@@ -17127,7 +17127,7 @@ async function X(t, e) {
 }
 async function $(t) {
   var e;
-  const n = [], o = new T(S(t.workerTimeSliceMs));
+  const n = [], o = new S(A(t.workerTimeSliceMs));
   try {
     if (typeof OffscreenCanvas == "undefined")
       throw new Error("OffscreenCanvas unavailable in atlas worker");
@@ -17154,7 +17154,7 @@ async function $(t) {
     for (const r of l) {
       const f = await _(r, s, t.padding, o);
       t.captureEncodedPng && c.push(B(f));
-      const u = f.transferToImageBitmap();
+      const u = await createImageBitmap(f, { premultiplyAlpha: "premultiply" });
       a.push({
         width: r.atlasW,
         height: r.atlasH,
@@ -17202,7 +17202,7 @@ m.onmessage = (t) => {
   const e = t.data;
   !e || e.type !== "build-svga-atlas" || Y.push(() => $(e));
 };
-//# sourceMappingURL=svga-atlas-worker-B7n5WXUn.js.map
+//# sourceMappingURL=svga-atlas-worker-CkVFsaPa.js.map
 `, lQ = typeof self != "undefined" && self.Blob && new Blob(["URL.revokeObjectURL(import.meta.url);", sE], { type: "text/javascript;charset=utf-8" });
 function no(C) {
   let A;
@@ -17318,7 +17318,7 @@ function ho() {
   return NI;
 }
 function nE() {
-  return typeof Worker != "undefined" && UQ() && typeof OffscreenCanvas.prototype.transferToImageBitmap == "function";
+  return typeof Worker != "undefined" && UQ() && typeof createImageBitmap == "function";
 }
 async function co(C, A) {
   if (!nE())
@@ -17524,7 +17524,8 @@ async function yo(C, A, g, I, B) {
         width: o.width,
         height: o.height,
         filter: "linear",
-        premultiplyAlpha: !0
+        premultiplyAlpha: !0,
+        sourcePremultiplied: !0
       });
       try {
         o.bitmap.close();