@weasel-js/renderer 0.0.0-stage → 1.9.4

package/dist/index.js

@@ -0,0 +1,4086 @@
+export { createTilePattern } from './chunk-2VOBNWBN.js';
+import { BATCH_ATTRIBUTE_LOCATIONS, BATCH_TEXTURE_SLOTS, registerProgram, BATCH_VERT_SRC, BATCH_FRAG_SRC, BATCH_FILL_UNIFORMS, BATCH_FILL_ATTRIBUTES, GLImageCache, DrawBatch, getProgramSource, commandFill, cachedMarkerCommands, PAINT_MODE_PLAIN, PAINT_MODE_RADIAL, PAINT_MODE_CONIC, getMesh, quantizeStrokeScale, strokeMesh, axisAlignedClipRect, intersectClipRects, getPaintDrawKind, outlineMesh, outlineStrokeMesh, quantizeEmWidth } from './chunk-VHQJ56XQ.js';
+export { commandFill, commandStroke, fillInPoseFrame, fillToBoundsFrame, getImageBitmap, getPaintDrawKind, getProgramSource, imageStatus, isPaintKindKnown, isPatternSpec, isVectorImageSrc, paintDrawKindRegistry, programSourceRegistry, registerPaintDrawKind, registerPaintDrawKindLoader, registerProgram, releaseImage, releaseImageSource, resolveFillPattern, resolvePatternSpec, retryImage, subscribeImageReady, warmPaintKinds } from './chunk-VHQJ56XQ.js';
+import { textureRegistry, getTexture } from './chunk-ORBXHIRB.js';
+export { registerTexture, textureRegistry, unregisterTexture } from './chunk-ORBXHIRB.js';
+import { DEFAULT_BAKE_BUDGET, markAllFontsNotUploaded, resetBakeBudget, GLYPH_COVERAGE_GLSL, syncDynamicPageTexture, ensureFontTexture, dynamicPageTextureId, textureCacheKey, GLYPH_MODE_R8, GLYPH_MODE_MSDF, glyphFieldScale } from '@weasel-js/font';
+export { canQueryLocalFonts, cssFontFamily, cssFontFamilyLoading, enableLocalFontOutlines, fontOutlineRegistry, fontRegistry, hasFontOutlines, isCanvasFont, listFontOutlines, loadFontOutlines, outlineStatus, registerCanvasFont, registerFont, registerFontOutlines, subscribeGlyphReady, unregisterCanvasFont, unregisterFontOutlines } from '@weasel-js/font';
+import { resolveGradientStops, sampleResolvedStops, resolveScreenLength, resolveColor } from '@weasel-js/paint';
+import { mat3 } from '@weasel-js/geom';
+export { mat3, viewToMat3 } from '@weasel-js/geom';
+import { tessellate } from '@weasel-js/geom/tessellate';
+export { tessellate } from '@weasel-js/geom/tessellate';
+import { resolveStrokeWidth, markerReach, metricKeepsRects, strokeSpaceOf, resolveMarkerSize } from '@weasel-js/stroke';
+export { tessellateStroke } from '@weasel-js/stroke';
+import { resolveTextStyle, resolveRuns, textPoseLayoutInput, cachedLayoutRuns, verticalAlignOffset, SYNTHETIC_ITALIC_RADIANS } from '@weasel-js/text';
+
+// src/paintResources.ts
+function createPaintResources() {
+  let releases = [];
+  return {
+    onRelease(release) {
+      if (releases) releases.push(release);
+      else release();
+    },
+    release() {
+      const pending = releases;
+      releases = null;
+      for (const release of pending ?? []) release();
+    }
+  };
+}
+
+// src/shaders/ShaderProgram.ts
+var ShaderCompileError = class extends Error {
+  constructor(stage, log) {
+    super(`shader ${stage} failure: ${log}`);
+    this.stage = stage;
+    this.log = log;
+    this.name = "ShaderCompileError";
+  }
+  stage;
+  log;
+};
+var POSITION_ATTRIBUTE_LOCATION = 0;
+var ShaderProgram = class {
+  constructor(gl, vertSrc, fragSrc2) {
+    this.gl = gl;
+    const vs = this.compile(gl.VERTEX_SHADER, vertSrc, "vertex");
+    let fs;
+    try {
+      fs = this.compile(gl.FRAGMENT_SHADER, fragSrc2, "fragment");
+    } catch (e) {
+      gl.deleteShader(vs);
+      throw e;
+    }
+    const program = gl.createProgram();
+    if (!program) {
+      gl.deleteShader(vs);
+      gl.deleteShader(fs);
+      throw new Error("createProgram returned null");
+    }
+    gl.attachShader(program, vs);
+    gl.attachShader(program, fs);
+    gl.bindAttribLocation(program, POSITION_ATTRIBUTE_LOCATION, "a_position");
+    gl.linkProgram(program);
+    gl.deleteShader(vs);
+    gl.deleteShader(fs);
+    if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+      const log = gl.getProgramInfoLog(program) ?? "";
+      gl.deleteProgram(program);
+      throw new ShaderCompileError("link", log);
+    }
+    this.handle = program;
+  }
+  gl;
+  handle;
+  uniforms = /* @__PURE__ */ new Map();
+  arrays = /* @__PURE__ */ new Map();
+  attributes = /* @__PURE__ */ new Map();
+  compile(type, source, stage) {
+    const gl = this.gl;
+    const shader = gl.createShader(type);
+    if (!shader) throw new Error("createShader returned null");
+    gl.shaderSource(shader, source);
+    gl.compileShader(shader);
+    if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+      const log = gl.getShaderInfoLog(shader) ?? "";
+      gl.deleteShader(shader);
+      throw new ShaderCompileError(stage, log);
+    }
+    return shader;
+  }
+  lookupUniforms(names) {
+    for (const name of names) {
+      const loc = this.gl.getUniformLocation(this.handle, name);
+      if (loc !== null) this.uniforms.set(name, loc);
+    }
+  }
+  /** Record each array's slot-0 location under its bare name. An array the
+   *  driver optimized away has no location and is left out. */
+  lookupUniformArrays(decls) {
+    for (const [name, { type, size }] of decls) {
+      const base = `${name}[0]`;
+      const location = this.uniforms.get(base) ?? this.gl.getUniformLocation(this.handle, base);
+      if (location !== null) this.arrays.set(name, { type, size, location });
+    }
+  }
+  lookupAttributes(names) {
+    for (const name of names) {
+      const loc = this.gl.getAttribLocation(this.handle, name);
+      if (loc >= 0) this.attributes.set(name, loc);
+    }
+  }
+  uniform(name) {
+    return this.uniforms.get(name);
+  }
+  uniformArray(name) {
+    return this.arrays.get(name);
+  }
+  attribute(name) {
+    return this.attributes.get(name);
+  }
+};
+
+// src/shaders/pathFill.ts
+var VERT_SRC = (
+  /* glsl */
+  `#version 300 es
+in vec2 a_position;
+uniform mat3 u_proj;
+uniform mat3 u_model;
+uniform vec2 u_origin;
+void main() {
+  vec3 screen = u_model * vec3(a_position - u_origin, 1.0);
+  vec3 clip = u_proj * vec3(screen.xy, 1.0);
+  gl_Position = vec4(clip.xy, 0.0, 1.0);
+}
+`
+);
+var FRAG_SRC = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+uniform vec4 u_color;
+uniform float u_alpha;
+uniform mat4 u_colorMatrix;
+uniform vec4 u_colorBias;
+out vec4 outColor;
+void main() {
+  vec4 mapped = clamp(u_colorMatrix * u_color + u_colorBias, 0.0, 1.0);
+  float a = mapped.a * u_alpha;
+  outColor = vec4(mapped.rgb * a, a);
+}
+`
+);
+var VCOLOR_VERT_SRC = (
+  /* glsl */
+  `#version 300 es
+in vec2 a_position;
+in vec4 a_vertexColor;
+uniform mat3 u_proj;
+uniform mat3 u_model;
+uniform vec2 u_origin;
+out vec4 v_vertexColor;
+void main() {
+  vec3 screen = u_model * vec3(a_position - u_origin, 1.0);
+  vec3 clip = u_proj * vec3(screen.xy, 1.0);
+  gl_Position = vec4(clip.xy, 0.0, 1.0);
+  v_vertexColor = a_vertexColor;
+}
+`
+);
+var VCOLOR_FRAG_SRC = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+in vec4 v_vertexColor;
+uniform vec4 u_color;
+uniform float u_alpha;
+uniform mat4 u_colorMatrix;
+uniform vec4 u_colorBias;
+out vec4 outColor;
+void main() {
+  vec4 src = u_color * v_vertexColor;
+  vec4 mapped = clamp(u_colorMatrix * src + u_colorBias, 0.0, 1.0);
+  float a = mapped.a * u_alpha;
+  outColor = vec4(mapped.rgb * a, a);
+}
+`
+);
+var PATH_FILL_UNIFORMS = [
+  "u_proj",
+  "u_model",
+  "u_origin",
+  "u_color",
+  "u_alpha",
+  "u_colorMatrix",
+  "u_colorBias"
+];
+var PATH_FILL_ATTRIBUTES = ["a_position"];
+var PATH_FILL_VCOLOR_ATTRIBUTES = ["a_position", "a_vertexColor"];
+
+// src/shaders/gradFill.ts
+var GRAD_VERT_SRC = (
+  /* glsl */
+  `#version 300 es
+in vec2 a_position;
+uniform mat3 u_proj;
+uniform mat3 u_model;
+uniform vec2 u_origin;
+uniform mat3 u_worldInv;
+out vec2 v_world;
+void main() {
+  vec3 screen = u_model * vec3(a_position - u_origin, 1.0);
+  vec3 clip   = u_proj  * vec3(screen.xy, 1.0);
+  gl_Position = vec4(clip.xy, 0.0, 1.0);
+  vec3 world = u_worldInv * vec3(screen.xy, 1.0);
+  v_world = world.xy;
+}
+`
+);
+var GRAD_PAINT_GLSL = (
+  /* glsl */
+  `
+uniform sampler2D u_ramp;
+uniform float u_rampV;
+uniform float u_alpha;
+uniform mat4  u_colorMatrix;
+uniform vec4  u_colorBias;
+uniform float u_opacity;
+uniform int   u_gradKind;
+uniform vec2  u_gradP0;
+uniform vec2  u_gradDir;
+uniform float u_gradLen;
+uniform float u_gradRadius;
+uniform float u_gradAngle;
+
+const float PI = 3.14159265358979323846;
+
+vec4 shadePaint(vec2 world) {
+  float t;
+  if (u_gradKind == 0) {
+    vec2 d = world - u_gradP0;
+    t = dot(d, u_gradDir) / max(u_gradLen, 0.0001);
+  } else if (u_gradKind == 1) {
+    t = length(world - u_gradP0) / max(u_gradRadius, 0.0001);
+  } else {
+    float a = atan(world.y - u_gradP0.y, world.x - u_gradP0.x) - u_gradAngle;
+    t = fract(a / (2.0 * PI));
+  }
+  t = clamp(t, 0.0, 1.0);
+  vec4 rampColor = texture(u_ramp, vec2(t, u_rampV));
+  // Fill opacity into the alpha channel before the matrix, which is where the
+  // batch program's vertex alpha sits. The two have to agree, since a linear
+  // gradient goes through that one and a radial through this.
+  vec4 src = vec4(rampColor.rgb, rampColor.a * u_opacity);
+  vec4 mapped = clamp(u_colorMatrix * src + u_colorBias, 0.0, 1.0);
+  float a = mapped.a * u_alpha;
+  return vec4(mapped.rgb * a, a);
+}
+`
+);
+var GRAD_FRAG_SRC = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+in vec2 v_world;
+${GRAD_PAINT_GLSL}
+out vec4 outColor;
+void main() {
+  outColor = shadePaint(v_world);
+}
+`
+);
+var GRAD_FILL_UNIFORMS = [
+  "u_proj",
+  "u_model",
+  "u_origin",
+  "u_worldInv",
+  "u_ramp",
+  "u_rampV",
+  "u_alpha",
+  "u_opacity",
+  "u_colorMatrix",
+  "u_colorBias",
+  "u_gradKind",
+  "u_gradP0",
+  "u_gradDir",
+  "u_gradLen",
+  "u_gradRadius",
+  "u_gradAngle"
+];
+var GRAD_FILL_ATTRIBUTES = ["a_position"];
+
+// src/shaders/patternFill.ts
+var PATTERN_VERT_SRC = (
+  /* glsl */
+  `#version 300 es
+in vec2 a_position;
+uniform mat3 u_proj;
+uniform mat3 u_model;
+uniform vec2 u_origin;
+uniform mat3 u_worldInv;
+out vec2 v_world;
+void main() {
+  vec3 screen = u_model * vec3(a_position - u_origin, 1.0);
+  vec3 clip   = u_proj  * vec3(screen.xy, 1.0);
+  gl_Position = vec4(clip.xy, 0.0, 1.0);
+  vec3 world = u_worldInv * vec3(screen.xy, 1.0);
+  v_world = world.xy;
+}
+`
+);
+var PATTERN_PAINT_GLSL = (
+  /* glsl */
+  `
+uniform sampler2D u_sampler;
+uniform vec2  u_tileSize;
+uniform float u_opacity;
+uniform float u_alpha;
+uniform mat4  u_colorMatrix;
+uniform vec4  u_colorBias;
+vec4 shadePaint(vec2 world) {
+  vec2 uv = world / max(u_tileSize, vec2(0.0001));
+  vec4 texel = texture(u_sampler, uv);
+  vec4 mapped = clamp(u_colorMatrix * texel + u_colorBias, 0.0, 1.0);
+  float a = mapped.a * u_opacity * u_alpha;
+  return vec4(mapped.rgb * a, a);
+}
+`
+);
+var PATTERN_FRAG_SRC = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+in vec2 v_world;
+${PATTERN_PAINT_GLSL}
+out vec4 outColor;
+void main() {
+  outColor = shadePaint(v_world);
+}
+`
+);
+var PATTERN_FILL_UNIFORMS = [
+  "u_proj",
+  "u_model",
+  "u_origin",
+  "u_worldInv",
+  "u_sampler",
+  "u_tileSize",
+  "u_opacity",
+  "u_alpha",
+  "u_colorMatrix",
+  "u_colorBias"
+];
+var PATTERN_FILL_ATTRIBUTES = ["a_position"];
+var L = BATCH_ATTRIBUTE_LOCATIONS;
+var GLYPH_PAINT_VERT_SRC = (
+  /* glsl */
+  `#version 300 es
+layout(location = ${L.a_position}) in vec2 a_position;
+layout(location = ${L.a_uv}) in vec2 a_uv;
+layout(location = ${L.a_texSlot}) in float a_texSlot;
+uniform mat3 u_proj;
+uniform mat3 u_model;
+uniform mat3 u_worldInv;
+out vec2 v_world;
+out vec2 v_uv;
+flat out float v_glyphMode;
+void main() {
+  vec3 screen = u_model * vec3(a_position, 1.0);
+  vec3 clip = u_proj * vec3(screen.xy, 1.0);
+  gl_Position = vec4(clip.xy, 0.0, 1.0);
+  v_world = (u_worldInv * vec3(screen.xy, 1.0)).xy;
+  v_uv = a_uv;
+  v_glyphMode = float(int(a_texSlot + 0.5) / ${BATCH_TEXTURE_SLOTS});
+}
+`
+);
+function fragSrc(paintGlsl) {
+  return (
+    /* glsl */
+    `#version 300 es
+precision highp float;
+in vec2 v_world;
+in vec2 v_uv;
+flat in float v_glyphMode;
+uniform sampler2D u_atlas;
+uniform float u_synthBold;
+uniform vec2 u_fieldScale;
+${paintGlsl}
+${GLYPH_COVERAGE_GLSL}
+out vec4 outColor;
+void main() {
+  float coverage = glyphCoverage(texture(u_atlas, v_uv), v_glyphMode, u_synthBold, v_uv, u_fieldScale);
+  outColor = shadePaint(v_world) * coverage;
+}
+`
+  );
+}
+var TEXTURE_PAINT_GLSL = (
+  /* glsl */
+  `
+uniform sampler2D u_sampler;
+vec4 shadePaint(vec2 uv) {
+  return texture(u_sampler, uv);
+}
+`
+);
+var GLYPH_PATTERN_FRAG_SRC = fragSrc(PATTERN_PAINT_GLSL);
+var GLYPH_GRAD_FRAG_SRC = fragSrc(GRAD_PAINT_GLSL);
+var GLYPH_TEXTURE_FRAG_SRC = fragSrc(TEXTURE_PAINT_GLSL);
+var GLYPH_UNIFORMS = ["u_atlas", "u_synthBold", "u_fieldScale"];
+var notOrigin = (name) => name !== "u_origin";
+var GLYPH_PATTERN_UNIFORMS = [
+  ...PATTERN_FILL_UNIFORMS.filter(notOrigin),
+  ...GLYPH_UNIFORMS
+];
+var GLYPH_GRAD_UNIFORMS = [
+  ...GRAD_FILL_UNIFORMS.filter(notOrigin),
+  ...GLYPH_UNIFORMS
+];
+var GLYPH_TEXTURE_UNIFORMS = [
+  "u_proj",
+  "u_model",
+  "u_worldInv",
+  "u_sampler",
+  ...GLYPH_UNIFORMS
+];
+var GLYPH_PAINT_ATTRIBUTES = ["a_position", "a_uv", "a_texSlot"];
+
+// src/paintScratch.ts
+var MIN_SIDE = 64;
+var PaintScratch = class {
+  gl;
+  target = null;
+  constructor(gl) {
+    this.gl = gl;
+  }
+  /** A buffer at least `width` × `height` device pixels. Its contents are
+   *  whatever the last user left; the caller clears the region it uses. */
+  acquire(width, height) {
+    const have = this.target;
+    if (have && have.width >= width && have.height >= height) return have;
+    const w = Math.max(have?.width ?? 0, pow2(width));
+    const h = Math.max(have?.height ?? 0, pow2(height));
+    this.release();
+    this.target = this.create(w, h);
+    return this.target;
+  }
+  /** Drop the buffer. Called on dispose and on context restore, where the
+   *  handles are already dead and only the bookkeeping has to go. */
+  release() {
+    if (!this.target) return;
+    this.gl.deleteFramebuffer(this.target.fbo);
+    this.gl.deleteTexture(this.target.texture);
+    this.target = null;
+  }
+  create(width, height) {
+    const gl = this.gl;
+    const texture = gl.createTexture();
+    gl.bindTexture(gl.TEXTURE_2D, texture);
+    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA8, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    gl.bindTexture(gl.TEXTURE_2D, null);
+    const fbo = gl.createFramebuffer();
+    gl.bindFramebuffer(gl.FRAMEBUFFER, fbo);
+    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);
+    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+    return { fbo, texture, width, height };
+  }
+};
+function pow2(n) {
+  let side = MIN_SIDE;
+  while (side < n) side *= 2;
+  return side;
+}
+
+// src/cache/GLMeshCache.ts
+var GLMeshCache = class {
+  constructor(gl) {
+    this.gl = gl;
+    this.finalizer = new FinalizationRegistry((resources) => {
+      if (!this.persistent.delete(resources)) return;
+      this.pendingDeletes.push(resources);
+    });
+  }
+  gl;
+  map = /* @__PURE__ */ new WeakMap();
+  /** Meshes this context has drawn at least once; see `uploadRecurring`. */
+  seen = /* @__PURE__ */ new WeakSet();
+  finalizer;
+  /** Every persistent upload not yet freed, so `dispose` can reach them. */
+  persistent = /* @__PURE__ */ new Set();
+  pendingDeletes = [];
+  disposed = false;
+  /** Transient resources allocated this frame; freed at end of render(). */
+  transientThisFrame = [];
+  handleFor(mesh) {
+    const cached = this.map.get(mesh);
+    if (cached) return cached;
+    const { handle, vbo, ibo } = this.upload(mesh);
+    this.map.set(mesh, handle);
+    const resources = { vao: handle.vao, vbo, ibo };
+    this.persistent.add(resources);
+    this.finalizer.register(mesh, resources, mesh);
+    return handle;
+  }
+  /**
+   * Upload a Mesh that the caller knows is single-use (e.g. the per-frame
+   * stroke ribbon from `tessellateStroke`). Returns a handle backed by fresh
+   * GL resources that the renderer will free deterministically at the end
+   * of the current frame via `freeTransient()`. Bypasses the WeakMap cache
+   * and the FinalizationRegistry, so transient meshes never wait on GC.
+   */
+  uploadTransient(mesh) {
+    const { handle, vbo, ibo } = this.upload(mesh);
+    this.transientThisFrame.push({ vao: handle.vao, vbo, ibo });
+    return handle;
+  }
+  /**
+   * Upload a Mesh that may or may not recur across frames. Its first sight in
+   * *this* context takes `uploadTransient`; every later one takes the
+   * persistent handle. One transient upload to find out is cheaper than
+   * stranding a persistent VAO on a mesh that never returns, whose release
+   * would wait on GC. The transient upload does not populate the persistent
+   * map, so steady-state reuse begins on the third frame.
+   */
+  uploadRecurring(mesh) {
+    if (this.seen.has(mesh)) return this.handleFor(mesh);
+    this.seen.add(mesh);
+    return this.uploadTransient(mesh);
+  }
+  /**
+   * Free all transient resources allocated since the last call. Called by
+   * the renderer at the end of each `render()`. Safe under context loss.
+   */
+  freeTransient() {
+    if (this.transientThisFrame.length === 0) return;
+    const gl = this.gl;
+    if (gl.isContextLost()) {
+      this.transientThisFrame.length = 0;
+      return;
+    }
+    for (const r of this.transientThisFrame) {
+      gl.deleteVertexArray(r.vao);
+      gl.deleteBuffer(r.vbo);
+      gl.deleteBuffer(r.ibo);
+    }
+    this.transientThisFrame.length = 0;
+  }
+  /** @internal — for tests asserting the transient-list size. */
+  _transientCount() {
+    return this.transientThisFrame.length;
+  }
+  /**
+   * Free GL resources whose Mesh has been GC'd since the last drain.
+   * Called by the renderer at the top of each `render()`, before any draws.
+   */
+  drainPendingDeletes() {
+    if (this.pendingDeletes.length === 0) return;
+    const gl = this.gl;
+    if (gl.isContextLost()) {
+      this.pendingDeletes.length = 0;
+      return;
+    }
+    for (const r of this.pendingDeletes) {
+      gl.deleteVertexArray(r.vao);
+      gl.deleteBuffer(r.vbo);
+      gl.deleteBuffer(r.ibo);
+    }
+    this.pendingDeletes.length = 0;
+  }
+  /**
+   * Free every GL resource this cache holds — persistent, pending and
+   * transient — and ignore finalizers from here on. Idempotent. Unlike the
+   * other paths this does not wait on GC, which is what lets a renderer on a
+   * context it does not own give back everything it uploaded.
+   */
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.freeTransient();
+    for (const r of this.persistent) this.pendingDeletes.push(r);
+    this.persistent.clear();
+    this.drainPendingDeletes();
+  }
+  /** @internal — for tests asserting the queue size. */
+  _pendingDeleteCount() {
+    return this.pendingDeletes.length;
+  }
+  /** @internal — for tests that need to simulate the finalizer firing. */
+  _enqueueDeleteForTest(resources) {
+    this.pendingDeletes.push(resources);
+  }
+  upload(mesh) {
+    const gl = this.gl;
+    const vao = gl.createVertexArray();
+    if (!vao) throw new Error("createVertexArray returned null");
+    gl.bindVertexArray(vao);
+    const vbo = gl.createBuffer();
+    if (!vbo) throw new Error("createBuffer (VBO) returned null");
+    gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
+    gl.bufferData(gl.ARRAY_BUFFER, mesh.vertices, gl.STATIC_DRAW);
+    gl.enableVertexAttribArray(POSITION_ATTRIBUTE_LOCATION);
+    gl.vertexAttribPointer(POSITION_ATTRIBUTE_LOCATION, 2, gl.FLOAT, false, 0, 0);
+    const ibo = gl.createBuffer();
+    if (!ibo) throw new Error("createBuffer (IBO) returned null");
+    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ibo);
+    gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, mesh.indices, gl.STATIC_DRAW);
+    gl.bindVertexArray(null);
+    return {
+      handle: {
+        vao,
+        indexCount: mesh.indices.length,
+        requiresStencil: mesh.requiresStencil ?? false,
+        anchorA: mesh.anchorA,
+        anchorB: mesh.anchorB,
+        anchorT: mesh.anchorT
+      },
+      vbo,
+      ibo
+    };
+  }
+};
+
+// src/cache/GLTextureCache.ts
+var GLTextureCache = class {
+  constructor(gl) {
+    this.gl = gl;
+  }
+  gl;
+  map = /* @__PURE__ */ new Map();
+  wraps = /* @__PURE__ */ new Map();
+  /** The source each registry-backed id was last uploaded from. */
+  registered = /* @__PURE__ */ new Map();
+  sweptVersion = -1;
+  has(id) {
+    return this.map.has(id);
+  }
+  /** Uploads the pixels once per id. `wrap` is re-applied whenever it differs
+   *  from what the id was last uploaded under: the same registered image can
+   *  be a clamped shader texture in one draw and a repeating pattern tile in
+   *  the next, and first-upload-wins gave the second one the first one's mode. */
+  upload(id, source, wrap = "clamp") {
+    const cached = this.map.get(id);
+    if (cached) {
+      if (this.wraps.get(id) !== wrap) this.applyWrap(id, cached, wrap);
+      return id;
+    }
+    const gl = this.gl;
+    const tex = gl.createTexture();
+    if (!tex) throw new Error(`GLTextureCache: createTexture failed for id="${id}"`);
+    const wrapMode = wrap === "repeat" ? gl.REPEAT : gl.CLAMP_TO_EDGE;
+    gl.bindTexture(gl.TEXTURE_2D, tex);
+    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, source);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, wrapMode);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, wrapMode);
+    gl.bindTexture(gl.TEXTURE_2D, null);
+    this.map.set(id, tex);
+    this.wraps.set(id, wrap);
+    return id;
+  }
+  /** `upload` for an id from the texture registry, whose image can be replaced
+   *  under the same id: a changed source sends its pixels again. */
+  uploadRegistered(id, source, wrap = "clamp") {
+    const cached = this.map.get(id);
+    if (cached && this.registered.get(id) !== source) {
+      const gl = this.gl;
+      gl.bindTexture(gl.TEXTURE_2D, cached);
+      gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, source);
+      gl.bindTexture(gl.TEXTURE_2D, null);
+    }
+    this.registered.set(id, source);
+    return this.upload(id, source, wrap);
+  }
+  /**
+   * Delete the texture of every registry-backed id the registry has dropped.
+   * The renderer calls this at the top of `render()`, before any draw, so a
+   * texture is never deleted under a draw that has it bound.
+   */
+  sweep(registry) {
+    const version = registry.getVersion();
+    if (version === this.sweptVersion) return;
+    this.sweptVersion = version;
+    for (const id of this.registered.keys()) {
+      if (registry.has(id)) continue;
+      this.gl.deleteTexture(this.map.get(id) ?? null);
+      this.map.delete(id);
+      this.wraps.delete(id);
+      this.registered.delete(id);
+    }
+  }
+  applyWrap(id, tex, wrap) {
+    const gl = this.gl;
+    const mode = wrap === "repeat" ? gl.REPEAT : gl.CLAMP_TO_EDGE;
+    gl.bindTexture(gl.TEXTURE_2D, tex);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, mode);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, mode);
+    gl.bindTexture(gl.TEXTURE_2D, null);
+    this.wraps.set(id, wrap);
+  }
+  /** Create a single-channel R8 texture from raw bytes (full upload).
+   *  No-op if `id` already exists. Same LINEAR/CLAMP params as `upload`;
+   *  UNPACK_ALIGNMENT dropped to 1 for non-4-aligned row widths. */
+  uploadR8(id, width, height, data) {
+    if (this.map.has(id)) return;
+    const gl = this.gl;
+    const tex = gl.createTexture();
+    if (!tex) throw new Error(`GLTextureCache: createTexture failed for id="${id}"`);
+    gl.bindTexture(gl.TEXTURE_2D, tex);
+    gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);
+    gl.texImage2D(gl.TEXTURE_2D, 0, gl.R8, width, height, 0, gl.RED, gl.UNSIGNED_BYTE, data);
+    gl.pixelStorei(gl.UNPACK_ALIGNMENT, 4);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    gl.bindTexture(gl.TEXTURE_2D, null);
+    this.map.set(id, tex);
+    this.wraps.set(id, "clamp");
+  }
+  /** Patch a rect of an existing R8 texture with tightly-packed w×h bytes. */
+  subImageR8(id, x, y, w, h, data) {
+    const tex = this.map.get(id);
+    if (!tex) throw new Error(`GLTextureCache: texture "${id}" not uploaded`);
+    const gl = this.gl;
+    gl.bindTexture(gl.TEXTURE_2D, tex);
+    gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);
+    gl.texSubImage2D(gl.TEXTURE_2D, 0, x, y, w, h, gl.RED, gl.UNSIGNED_BYTE, data);
+    gl.pixelStorei(gl.UNPACK_ALIGNMENT, 4);
+    gl.bindTexture(gl.TEXTURE_2D, null);
+  }
+  bind(id, unit) {
+    const tex = this.map.get(id);
+    if (!tex) throw new Error(`GLTextureCache: texture "${id}" not uploaded`);
+    const gl = this.gl;
+    gl.activeTexture(gl.TEXTURE0 + unit);
+    gl.bindTexture(gl.TEXTURE_2D, tex);
+  }
+  /**
+   * Delete every uploaded GL texture and clear the map. Called by
+   * `WeaselRenderer.dispose()`. The cache is unusable but refillable
+   * afterward — a subsequent `upload()` for a previously-seen id re-creates
+   * the texture rather than restoring the deleted one.
+   */
+  free() {
+    const gl = this.gl;
+    for (const tex of this.map.values()) {
+      gl.deleteTexture(tex);
+    }
+    this.map.clear();
+    this.wraps.clear();
+    this.registered.clear();
+  }
+};
+var RAMP_WIDTH = 256;
+var INITIAL_ROWS = 16;
+var RAMP_ATLAS_MAX_ROWS = 1024;
+function buildGradientRamp(stops, space = "rgb") {
+  const data = new Uint8ClampedArray(RAMP_WIDTH * 4);
+  if (stops.length === 0) return data;
+  const resolved = resolveGradientStops(stops);
+  for (let i = 0; i < RAMP_WIDTH; i++) {
+    const [r, g, b, a] = sampleResolvedStops(resolved, i / (RAMP_WIDTH - 1), space);
+    data[i * 4] = r * 255;
+    data[i * 4 + 1] = g * 255;
+    data[i * 4 + 2] = b * 255;
+    data[i * 4 + 3] = a * 255;
+  }
+  return data;
+}
+function rampKey(stops, space) {
+  return `${space}|${JSON.stringify(stops)}`;
+}
+var GradientRampAtlas = class {
+  constructor(gl) {
+    this.gl = gl;
+  }
+  gl;
+  /** Row per stop list, in least-recently-used order: a hit re-inserts, so the
+   *  first entry is the row a full atlas recycles. */
+  rowByKey = /* @__PURE__ */ new Map();
+  texture = null;
+  rows = 0;
+  /** Mirror of the texture, so growth can respecify it without re-baking every
+   *  ramp it already holds. */
+  pixels = new Uint8ClampedArray(0);
+  totalQueries = 0;
+  cacheHits = 0;
+  /** Rows the atlas currently holds — its texture height. */
+  get height() {
+    return this.rows;
+  }
+  /**
+   * Bake `stops` into a row and return it, reusing the row an identical stop
+   * list already holds.
+   *
+   * **A returned row outlives the frame only while the atlas has room.** Past
+   * `RAMP_ATLAS_MAX_ROWS` an upload recycles the least recently used row, which
+   * rewrites texels a row handed out earlier still names. Nothing that defers
+   * its draw past this call may hold a row across another `upload` without
+   * arranging to be flushed first.
+   */
+  upload(stops, space = "rgb") {
+    const key = rampKey(stops, space);
+    this.totalQueries++;
+    const existing = this.rowByKey.get(key);
+    if (existing !== void 0) {
+      this.cacheHits++;
+      this.rowByKey.delete(key);
+      this.rowByKey.set(key, existing);
+      return existing;
+    }
+    const row = this.claimRow();
+    this.writeRow(row, buildGradientRamp(stops, space));
+    this.rowByKey.set(key, row);
+    return row;
+  }
+  /**
+   * Whether uploading `stops` would move where existing rows sit — by growing
+   * the atlas, which changes every row's `v`, or by recycling one, which
+   * rewrites its texels.
+   *
+   * Anything holding a row past this call asks first and gets itself out of
+   * the way, because neither can be undone once it has happened.
+   */
+  wouldReshape(stops, space = "rgb") {
+    if (this.rowByKey.size === 0) return false;
+    return !this.rowByKey.has(rampKey(stops, space)) && this.rowByKey.size >= this.rows;
+  }
+  /**
+   * The `v` a row is sampled at — its center.
+   *
+   * The center is load-bearing: the atlas filters LINEAR, so a `v` anywhere
+   * else blends the ramp beside it into this one. At the center the neighbor's
+   * weight is exactly zero.
+   */
+  rowV(row) {
+    return (row + 0.5) / (this.rows || 1);
+  }
+  bind(unit) {
+    const gl = this.gl;
+    gl.activeTexture(gl.TEXTURE0 + unit);
+    gl.bindTexture(gl.TEXTURE_2D, this.texture);
+  }
+  hitRate() {
+    if (this.totalQueries === 0) return 0;
+    return this.cacheHits / this.totalQueries;
+  }
+  resetStats() {
+    this.totalQueries = 0;
+    this.cacheHits = 0;
+  }
+  /**
+   * Delete the atlas texture and forget every row in it. Called by
+   * `WeaselRenderer.dispose()`. The CPU mirror goes with it, so the atlas is
+   * unusable but refillable afterward (stats are left as-is; call
+   * `resetStats()` separately if desired).
+   */
+  free() {
+    if (this.texture) this.gl.deleteTexture(this.texture);
+    this.texture = null;
+    this.rows = 0;
+    this.pixels = new Uint8ClampedArray(0);
+    this.rowByKey.clear();
+  }
+  /** The row the next ramp is written to: a free one, a taller atlas, or the
+   *  least recently used row of a full one. */
+  claimRow() {
+    if (this.rowByKey.size < this.rows) return this.rowByKey.size;
+    if (this.rows < RAMP_ATLAS_MAX_ROWS) {
+      this.resize(this.rows === 0 ? INITIAL_ROWS : this.rows * 2);
+      return this.rowByKey.size;
+    }
+    const [lruKey, lruRow] = this.rowByKey.entries().next().value;
+    this.rowByKey.delete(lruKey);
+    return lruRow;
+  }
+  /** Grow to `rows`, keeping every row at the index it already had — a row
+   *  index is a stable name, and callers hold them. */
+  resize(rows) {
+    const gl = this.gl;
+    const next = new Uint8ClampedArray(RAMP_WIDTH * rows * 4);
+    next.set(this.pixels);
+    this.pixels = next;
+    this.rows = rows;
+    if (!this.texture) {
+      const tex = gl.createTexture();
+      if (!tex) throw new Error("GradientRampAtlas: createTexture failed");
+      this.texture = tex;
+      gl.bindTexture(gl.TEXTURE_2D, tex);
+      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    } else {
+      gl.bindTexture(gl.TEXTURE_2D, this.texture);
+    }
+    gl.texImage2D(
+      gl.TEXTURE_2D,
+      0,
+      gl.RGBA,
+      RAMP_WIDTH,
+      rows,
+      0,
+      gl.RGBA,
+      gl.UNSIGNED_BYTE,
+      this.pixels
+    );
+    gl.bindTexture(gl.TEXTURE_2D, null);
+  }
+  writeRow(row, ramp2) {
+    const gl = this.gl;
+    this.pixels.set(ramp2, row * RAMP_WIDTH * 4);
+    gl.bindTexture(gl.TEXTURE_2D, this.texture);
+    gl.texSubImage2D(
+      gl.TEXTURE_2D,
+      0,
+      0,
+      row,
+      RAMP_WIDTH,
+      1,
+      gl.RGBA,
+      gl.UNSIGNED_BYTE,
+      ramp2
+    );
+    gl.bindTexture(gl.TEXTURE_2D, null);
+  }
+};
+var IDENTITY_COLOR_MATRIX = new Float32Array([
+  1,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  0
+]);
+function compose4x5(outer, inner) {
+  const result = new Float32Array(20);
+  for (let row = 0; row < 4; row++) {
+    for (let col = 0; col < 4; col++) {
+      let sum = 0;
+      for (let k = 0; k < 4; k++) {
+        sum += outer[row * 5 + k] * inner[k * 5 + col];
+      }
+      result[row * 5 + col] = sum;
+    }
+    let biasSum = outer[row * 5 + 4];
+    for (let k = 0; k < 4; k++) {
+      biasSum += outer[row * 5 + k] * inner[k * 5 + 4];
+    }
+    result[row * 5 + 4] = biasSum;
+  }
+  return result;
+}
+var GroupState = class {
+  transformStack = [mat3.identity()];
+  alphaStack = [1];
+  colorMatrixStack = [IDENTITY_COLOR_MATRIX];
+  get transform() {
+    return this.transformStack[this.transformStack.length - 1];
+  }
+  get alpha() {
+    return this.alphaStack[this.alphaStack.length - 1];
+  }
+  get colorMatrix() {
+    return this.colorMatrixStack[this.colorMatrixStack.length - 1];
+  }
+  push(frame) {
+    const current = this.transform;
+    const nextTransform = frame.transform ? mat3.multiply(current, frame.transform) : current;
+    const nextAlpha = frame.alpha !== void 0 ? this.alpha * frame.alpha : this.alpha;
+    const nextCM = frame.colorMatrix ? compose4x5(
+      this.colorMatrix,
+      frame.colorMatrix instanceof Float32Array ? frame.colorMatrix : new Float32Array(frame.colorMatrix)
+    ) : this.colorMatrix;
+    this.transformStack.push(nextTransform);
+    this.alphaStack.push(nextAlpha);
+    this.colorMatrixStack.push(nextCM);
+  }
+  /**
+   * Push a frame whose children paint into a surface of their own.
+   *
+   * The transform still accumulates — the children draw where they would have
+   * drawn. Alpha and colour do not: they describe how the finished surface
+   * joins the frame, and applying them on the way in as well would fade the
+   * pixels an effect is about to read, then fade them again on the way out.
+   *
+   * Returns the pair the caller must apply at composite time — what `push`
+   * would have left on the stack — so the composition rules live here and not
+   * in the dispatcher.
+   */
+  pushIsolated(frame) {
+    this.push(frame);
+    const composited = { alpha: this.alpha, colorMatrix: this.colorMatrix };
+    this.pop();
+    const current = this.transform;
+    this.transformStack.push(frame.transform ? mat3.multiply(current, frame.transform) : current);
+    this.alphaStack.push(1);
+    this.colorMatrixStack.push(IDENTITY_COLOR_MATRIX);
+    return composited;
+  }
+  /** Drop every pushed frame, leaving the root. A frame that throws part-way
+   *  down the tree never pops, and the next frame would draw under leftovers. */
+  reset() {
+    this.transformStack.length = 1;
+    this.alphaStack.length = 1;
+    this.colorMatrixStack.length = 1;
+  }
+  pop() {
+    if (this.transformStack.length <= 1) {
+      throw new Error("GroupState.pop: cannot pop root frame");
+    }
+    this.transformStack.pop();
+    this.alphaStack.pop();
+    this.colorMatrixStack.pop();
+  }
+};
+
+// src/effects/effectPrelude.ts
+var EFFECT_VERT_SRC = (
+  /* glsl */
+  `#version 300 es
+in vec2 a_position;
+in vec2 a_uv;
+out vec2 v_uv;
+
+void main() {
+  v_uv = a_uv;
+  gl_Position = vec4(a_position, 0.0, 1.0);
+}
+`
+);
+var EFFECT_KIT_UNIFORMS = ["u_source", "u_resolution", "u_texel"];
+var COMPOSITE_FRAG_SRC = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+in vec2 v_uv;
+uniform sampler2D u_source;
+uniform float u_alpha;
+uniform mat4 u_colorMatrix;
+uniform vec4 u_colorBias;
+out vec4 outColor;
+
+void main() {
+  vec4 src = texture(u_source, v_uv);
+  // Undo premultiplication before the colour matrix, which is defined on
+  // straight alpha, then put it back for the blend.
+  float a = src.a;
+  vec3 rgb = a > 0.0 ? src.rgb / a : vec3(0.0);
+  vec4 c = u_colorMatrix * vec4(rgb, a) + u_colorBias;
+  c.a *= u_alpha;
+  outColor = vec4(clamp(c.rgb, 0.0, 1.0) * c.a, c.a);
+}
+`
+);
+
+// src/effects/composite.ts
+var COMPOSITE_PROGRAM_ID = "weasel:effect-composite";
+function compositeProgramId() {
+  if (!getProgramSource(COMPOSITE_PROGRAM_ID)) {
+    registerProgram(COMPOSITE_PROGRAM_ID, EFFECT_VERT_SRC, COMPOSITE_FRAG_SRC);
+  }
+  return COMPOSITE_PROGRAM_ID;
+}
+
+// src/draw/drawTriangles.ts
+function drawTriangles(ctx, count, type) {
+  ctx.gl.drawElements(ctx.gl.TRIANGLES, count, type, 0);
+  if (ctx.stats) ctx.stats.drawCalls++;
+}
+
+// src/draw/stencil.ts
+function applyClipTest(ctx, depth = ctx.clipDepth) {
+  const gl = ctx.gl;
+  if (depth === 0) {
+    gl.disable(gl.STENCIL_TEST);
+    return;
+  }
+  const mask = ancestorMask(depth);
+  gl.enable(gl.STENCIL_TEST);
+  gl.stencilFunc(gl.EQUAL, mask, mask);
+  gl.stencilOp(gl.KEEP, gl.KEEP, gl.KEEP);
+}
+function ancestorMask(depth) {
+  return depth === 0 ? 0 : (1 << depth + 1) - 1 & 254;
+}
+function beginParityMask(ctx, indexCount) {
+  const gl = ctx.gl;
+  gl.enable(gl.STENCIL_TEST);
+  gl.colorMask(false, false, false, false);
+  gl.stencilMask(1);
+  gl.stencilFunc(gl.ALWAYS, 0, 1);
+  gl.stencilOp(gl.KEEP, gl.KEEP, gl.INVERT);
+  drawTriangles(ctx, indexCount, ctx.gl.UNSIGNED_INT);
+  const clipMask = ancestorMask(ctx.clipDepth);
+  gl.colorMask(true, true, true, true);
+  gl.stencilFunc(gl.EQUAL, clipMask | 1, clipMask | 1);
+  gl.stencilOp(gl.KEEP, gl.KEEP, gl.KEEP);
+}
+function endParityMask(ctx) {
+  const gl = ctx.gl;
+  gl.stencilMask(1);
+  gl.clear(gl.STENCIL_BUFFER_BIT);
+  gl.disable(gl.STENCIL_TEST);
+}
+
+// src/draw/customShader.ts
+var warnedUniforms = /* @__PURE__ */ new Set();
+function warnOnceUniform(programId, name) {
+  const key = `${programId}:${name}`;
+  if (warnedUniforms.has(key)) return;
+  warnedUniforms.add(key);
+  const isDev = typeof process !== "undefined" ? process.env.NODE_ENV !== "production" : true;
+  if (isDev) {
+    console.warn(`weasel drawShader: uniform "${name}" not found in program "${programId}". Check spelling, ensure it's used in the shader (unused uniforms are optimized away by the driver).`);
+  }
+}
+function setUniform(gl, loc, value, textureCache, nextTexUnit) {
+  if (value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Float32Array) && "id" in value && typeof value.id === "string") {
+    const handle = value;
+    const entry = getTexture(handle.id);
+    if (!entry) {
+      const isDev = typeof process !== "undefined" ? process.env.NODE_ENV !== "production" : true;
+      if (isDev) console.warn(`weasel setUniform: TextureHandle "${handle.id}" not registered`);
+      return;
+    }
+    const unit = nextTexUnit.value++;
+    gl.activeTexture(gl.TEXTURE0 + unit);
+    textureCache.uploadRegistered(handle.id, entry.source);
+    textureCache.bind(handle.id, unit);
+    gl.uniform1i(loc, unit);
+    return;
+  }
+  if (value instanceof Float64Array) value = Float32Array.from(value);
+  if (value instanceof Float32Array) {
+    if (value.length === 9) {
+      gl.uniformMatrix3fv(loc, false, value);
+    } else if (value.length === 16) {
+      gl.uniformMatrix4fv(loc, false, value);
+    } else {
+      const isDev = typeof process !== "undefined" ? process.env.NODE_ENV !== "production" : true;
+      if (isDev) throw new TypeError(`weasel setUniform: Float32Array must be length 9 (mat3) or 16 (mat4), got ${value.length}`);
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    const arr = value;
+    switch (arr.length) {
+      case 2:
+        gl.uniform2fv(loc, arr);
+        break;
+      case 3:
+        gl.uniform3fv(loc, arr);
+        break;
+      case 4:
+        gl.uniform4fv(loc, arr);
+        break;
+      default: {
+        const isDev = typeof process !== "undefined" ? process.env.NODE_ENV !== "production" : true;
+        if (isDev) throw new TypeError(`weasel setUniform: array length ${arr.length} not supported`);
+      }
+    }
+    return;
+  }
+  if (typeof value === "number") {
+    gl.uniform1f(loc, value);
+    return;
+  }
+}
+var ARRAY_UPLOADS = {
+  float: { fn: "uniform1fv", n: 1 },
+  vec2: { fn: "uniform2fv", n: 2 },
+  vec3: { fn: "uniform3fv", n: 3 },
+  vec4: { fn: "uniform4fv", n: 4 },
+  int: { fn: "uniform1iv", n: 1 },
+  ivec2: { fn: "uniform2iv", n: 2 },
+  ivec3: { fn: "uniform3iv", n: 3 },
+  ivec4: { fn: "uniform4iv", n: 4 },
+  bool: { fn: "uniform1iv", n: 1 },
+  bvec2: { fn: "uniform2iv", n: 2 },
+  bvec3: { fn: "uniform3iv", n: 3 },
+  bvec4: { fn: "uniform4iv", n: 4 },
+  uint: { fn: "uniform1uiv", n: 1 },
+  uvec2: { fn: "uniform2uiv", n: 2 },
+  uvec3: { fn: "uniform3uiv", n: 3 },
+  uvec4: { fn: "uniform4uiv", n: 4 },
+  mat2: { fn: "uniformMatrix2fv", n: 4, matrix: true },
+  mat3: { fn: "uniformMatrix3fv", n: 9, matrix: true },
+  mat4: { fn: "uniformMatrix4fv", n: 16, matrix: true },
+  mat2x2: { fn: "uniformMatrix2fv", n: 4, matrix: true },
+  mat3x3: { fn: "uniformMatrix3fv", n: 9, matrix: true },
+  mat4x4: { fn: "uniformMatrix4fv", n: 16, matrix: true },
+  mat2x3: { fn: "uniformMatrix2x3fv", n: 6, matrix: true },
+  mat2x4: { fn: "uniformMatrix2x4fv", n: 8, matrix: true },
+  mat3x2: { fn: "uniformMatrix3x2fv", n: 6, matrix: true },
+  mat3x4: { fn: "uniformMatrix3x4fv", n: 12, matrix: true },
+  mat4x2: { fn: "uniformMatrix4x2fv", n: 8, matrix: true },
+  mat4x3: { fn: "uniformMatrix4x3fv", n: 12, matrix: true }
+};
+function isArrayValue(value) {
+  return Array.isArray(value) || value instanceof Float32Array || value instanceof Int32Array || value instanceof Uint32Array;
+}
+function setUniformArray(gl, name, arr, value) {
+  const isDev = typeof process !== "undefined" ? process.env.NODE_ENV !== "production" : true;
+  const upload = ARRAY_UPLOADS[arr.type];
+  if (!upload) {
+    if (isDev) console.warn(`weasel setUniform: array uniform "${name}" has type ${arr.type}, which cannot be written as a whole`);
+    return;
+  }
+  if (value.length % upload.n !== 0 || value.length > upload.n * arr.size) {
+    if (isDev) {
+      throw new TypeError(
+        `weasel setUniform: "${name}" is ${arr.type}[${arr.size}], so its value must hold a multiple of ${upload.n} numbers, at most ${upload.n * arr.size}; got ${value.length}`
+      );
+    }
+    return;
+  }
+  if (value.length === 0) return;
+  const fn = gl[upload.fn];
+  if (upload.matrix) fn.call(gl, arr.location, false, value);
+  else fn.call(gl, arr.location, value);
+}
+function setUniforms(gl, program, programId, uniforms, textureCache, nextTexUnit) {
+  for (const [name, value] of Object.entries(uniforms)) {
+    const arr = program.uniformArray(name);
+    if (arr && isArrayValue(value)) {
+      setUniformArray(gl, name, arr, value);
+      continue;
+    }
+    const loc = program.uniform(name);
+    if (loc === void 0) {
+      warnOnceUniform(programId, name);
+      continue;
+    }
+    setUniform(gl, loc, value, textureCache, nextTexUnit);
+  }
+}
+function drawShader(ctx, cmd) {
+  const { gl, programRegistry, quadVbo, quadIbo, textureCache } = ctx;
+  const program = programRegistry.get(cmd.program.id);
+  if (!program) {
+    console.warn(
+      `weasel drawShader: program "${cmd.program.id}" not compiled on this renderer. Call renderer.registerProgram(handle) after the module-level registerProgram().`
+    );
+    return;
+  }
+  if (!quadVbo || !quadIbo) {
+    console.warn("weasel drawShader: quad geometry not initialized");
+    return;
+  }
+  gl.useProgram(program.handle);
+  const aPosLoc = program.attribute("a_position");
+  const aUvLoc = program.attribute("a_uv");
+  gl.bindBuffer(gl.ARRAY_BUFFER, quadVbo);
+  if (aPosLoc !== void 0) {
+    gl.enableVertexAttribArray(aPosLoc);
+    gl.vertexAttribPointer(aPosLoc, 2, gl.FLOAT, false, 16, 0);
+  }
+  if (aUvLoc !== void 0) {
+    gl.enableVertexAttribArray(aUvLoc);
+    gl.vertexAttribPointer(aUvLoc, 2, gl.FLOAT, false, 16, 8);
+  }
+  gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, quadIbo);
+  const proj = mat3.screenToClip(ctx.widthCss, ctx.heightCss);
+  const uProj = program.uniform("u_proj");
+  if (uProj !== void 0) gl.uniformMatrix3fv(uProj, false, mat3.toUniform(proj));
+  const uBounds = program.uniform("u_bounds");
+  if (uBounds !== void 0) {
+    gl.uniform4f(uBounds, cmd.bounds.x, cmd.bounds.y, cmd.bounds.w, cmd.bounds.h);
+  }
+  const uView = program.uniform("u_view");
+  if (uView !== void 0) gl.uniformMatrix3fv(uView, false, mat3.toUniform(ctx.state.transform));
+  setUniforms(gl, program, cmd.program.id, cmd.uniforms, textureCache, { value: 1 });
+  applyClipTest(ctx);
+  drawTriangles(ctx, 6, ctx.gl.UNSIGNED_SHORT);
+  if (aPosLoc !== void 0) gl.disableVertexAttribArray(aPosLoc);
+  if (aUvLoc !== void 0) gl.disableVertexAttribArray(aUvLoc);
+  gl.bindBuffer(gl.ARRAY_BUFFER, null);
+  gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
+}
+var FRAME_UPLOADS = /* @__PURE__ */ new WeakMap();
+var FRAME_PROJ = /* @__PURE__ */ new WeakMap();
+function uploadedFor(ctx, prog) {
+  let byProgram = FRAME_UPLOADS.get(ctx);
+  if (!byProgram) {
+    byProgram = /* @__PURE__ */ new WeakMap();
+    FRAME_UPLOADS.set(ctx, byProgram);
+  }
+  let uploaded = byProgram.get(prog);
+  if (!uploaded) {
+    uploaded = {};
+    byProgram.set(prog, uploaded);
+  }
+  return uploaded;
+}
+function sameValues(prev, next) {
+  if (prev === void 0 || prev.length !== next.length) return false;
+  for (let i = 0; i < prev.length; i++) if (prev[i] !== next[i]) return false;
+  return true;
+}
+function setColorUniform(ctx, prog, r, g, b, a) {
+  const loc = prog.uniform("u_color");
+  if (loc === void 0) return;
+  const uploaded = uploadedFor(ctx, prog);
+  const prev = uploaded.color;
+  if (prev !== void 0 && prev[0] === r && prev[1] === g && prev[2] === b && prev[3] === a) {
+    return;
+  }
+  ctx.gl.uniform4f(loc, r, g, b, a);
+  uploaded.color = [r, g, b, a];
+}
+function setAlphaUniform(ctx, prog, alpha) {
+  const loc = prog.uniform("u_alpha");
+  if (loc === void 0) return;
+  const uploaded = uploadedFor(ctx, prog);
+  if (uploaded.alpha === alpha) return;
+  ctx.gl.uniform1f(loc, alpha);
+  uploaded.alpha = alpha;
+}
+function projFor(ctx) {
+  let proj = FRAME_PROJ.get(ctx);
+  if (!proj) {
+    proj = mat3.toUniform(mat3.screenToClip(ctx.widthCss, ctx.heightCss));
+    FRAME_PROJ.set(ctx, proj);
+  }
+  return proj;
+}
+var COLOR_MATRIX_SCRATCH = new Float32Array(16);
+function setColorMatrixUniforms(ctx, prog, cm = ctx.state.colorMatrix) {
+  const gl = ctx.gl;
+  const uploaded = uploadedFor(ctx, prog);
+  const mLoc = prog.uniform("u_colorMatrix");
+  if (mLoc !== void 0) {
+    for (let row = 0; row < 4; row++) {
+      for (let col = 0; col < 4; col++) {
+        COLOR_MATRIX_SCRATCH[col * 4 + row] = cm[row * 5 + col];
+      }
+    }
+    if (!sameValues(uploaded.colorMatrix, COLOR_MATRIX_SCRATCH)) {
+      gl.uniformMatrix4fv(mLoc, false, COLOR_MATRIX_SCRATCH);
+      uploaded.colorMatrix = Float32Array.from(COLOR_MATRIX_SCRATCH);
+    }
+  }
+  const bLoc = prog.uniform("u_colorBias");
+  if (bLoc !== void 0) {
+    const bias = [cm[4], cm[9], cm[14], cm[19]];
+    if (!sameValues(uploaded.colorBias, bias)) {
+      gl.uniform4f(bLoc, bias[0], bias[1], bias[2], bias[3]);
+      uploaded.colorBias = Float32Array.from(bias);
+    }
+  }
+}
+var REBASE_TRANSLATION_PX = 65536;
+var MODEL_SCRATCH = new Float32Array(9);
+var PROJ_SCRATCH = new Float32Array(9);
+function setProjAndModel(ctx, prog, model = ctx.state.transform, proj = projFor(ctx)) {
+  const gl = ctx.gl;
+  const uploaded = uploadedFor(ctx, prog);
+  PROJ_SCRATCH.set(proj);
+  if (!sameValues(uploaded.proj, PROJ_SCRATCH)) {
+    gl.uniformMatrix3fv(prog.uniform("u_proj"), false, PROJ_SCRATCH);
+    uploaded.proj = Float32Array.from(PROJ_SCRATCH);
+  }
+  MODEL_SCRATCH.set(model);
+  const originLoc = prog.uniform("u_origin");
+  if (originLoc !== void 0) {
+    let ox = 0;
+    let oy = 0;
+    const tx = model[6], ty = model[7];
+    if (Math.abs(tx) >= REBASE_TRANSLATION_PX || Math.abs(ty) >= REBASE_TRANSLATION_PX) {
+      const a = model[0], b = model[1], c = model[3], d = model[4];
+      const det = a * d - b * c;
+      const lx = Math.fround((c * ty - d * tx) / det);
+      const ly = Math.fround((b * tx - a * ty) / det);
+      if (Number.isFinite(lx) && Number.isFinite(ly)) {
+        ox = lx;
+        oy = ly;
+        MODEL_SCRATCH[6] = a * ox + c * oy + tx;
+        MODEL_SCRATCH[7] = b * ox + d * oy + ty;
+      }
+    }
+    if (uploaded.originX !== ox || uploaded.originY !== oy) {
+      gl.uniform2f(originLoc, ox, oy);
+      uploaded.originX = ox;
+      uploaded.originY = oy;
+    }
+  }
+  if (!sameValues(uploaded.model, MODEL_SCRATCH)) {
+    gl.uniformMatrix3fv(prog.uniform("u_model"), false, MODEL_SCRATCH);
+    uploaded.model = Float32Array.from(MODEL_SCRATCH);
+  }
+}
+function setSolidPaintUniforms(ctx, prog, color, opacity) {
+  const [r, g, b, a] = resolveColor(color);
+  setColorUniform(ctx, prog, r, g, b, a * (opacity ?? 1));
+  setAlphaUniform(ctx, prog, ctx.state.alpha);
+}
+
+// src/draw/effects.ts
+function returnToRenderTarget(ctx, width, height, scissorWasOn) {
+  const gl = ctx.gl;
+  const target = ctx.renderTarget ?? null;
+  gl.bindFramebuffer(gl.FRAMEBUFFER, target ? target.fbo : null);
+  if (target) {
+    gl.viewport(0, 0, width, height);
+  } else {
+    ctx.restoreTargetRect?.();
+    if (scissorWasOn) gl.enable(gl.SCISSOR_TEST);
+  }
+}
+function drawFullscreenQuad(ctx, program, texture, width, height, uniforms, composite, programId) {
+  const gl = ctx.gl;
+  gl.useProgram(program.handle);
+  const aPos = program.attribute("a_position");
+  const aUv = program.attribute("a_uv");
+  gl.bindBuffer(gl.ARRAY_BUFFER, ctx.quadVbo);
+  gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, ctx.quadIbo);
+  if (aPos !== void 0 && aPos >= 0) {
+    gl.enableVertexAttribArray(aPos);
+    gl.vertexAttribPointer(aPos, 2, gl.FLOAT, false, 16, 0);
+  }
+  if (aUv !== void 0 && aUv >= 0) {
+    gl.enableVertexAttribArray(aUv);
+    gl.vertexAttribPointer(aUv, 2, gl.FLOAT, false, 16, 8);
+  }
+  gl.activeTexture(gl.TEXTURE0);
+  gl.bindTexture(gl.TEXTURE_2D, texture);
+  const source = program.uniform("u_source");
+  if (source !== void 0) gl.uniform1i(source, 0);
+  const resolution = program.uniform("u_resolution");
+  if (resolution !== void 0) gl.uniform2f(resolution, width, height);
+  const texel = program.uniform("u_texel");
+  if (texel !== void 0) gl.uniform2f(texel, 1 / width, 1 / height);
+  if (composite) {
+    const alpha = program.uniform("u_alpha");
+    if (alpha !== void 0) gl.uniform1f(alpha, composite.alpha);
+    setColorMatrixUniforms(ctx, program, composite.colorMatrix);
+  }
+  if (uniforms) setUniforms(gl, program, programId ?? "effect", uniforms, ctx.textureCache, { value: 1 });
+  drawTriangles(ctx, 6, ctx.gl.UNSIGNED_SHORT);
+  if (aPos !== void 0 && aPos >= 0) gl.disableVertexAttribArray(aPos);
+  if (aUv !== void 0 && aUv >= 0) gl.disableVertexAttribArray(aUv);
+  gl.bindBuffer(gl.ARRAY_BUFFER, null);
+  gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
+}
+function fillMesh(ctx, path) {
+  if (ctx.flattenTolerance !== void 0) {
+    return tessellate(path, { flattenTolerance: ctx.flattenTolerance });
+  }
+  return getMesh(path);
+}
+function meshHandle(ctx, mesh) {
+  if (ctx.flattenTolerance !== void 0) return ctx.meshCache.uploadTransient(mesh);
+  return ctx.meshCache.handleFor(mesh);
+}
+function fillMeshHandle(ctx, path) {
+  return meshHandle(ctx, fillMesh(ctx, path));
+}
+var BATCH_MODEL = mat3.identity();
+var SAMPLER_UNITS = new Int32Array(
+  Array.from({ length: BATCH_TEXTURE_SLOTS }, (_, i) => i)
+);
+var FIELD_SCALES = new Float32Array(2 * BATCH_TEXTURE_SLOTS);
+function flushBatch(ctx) {
+  const batch = ctx.drawBatch;
+  const staged = ctx.batchState;
+  if (batch.length === 0 || staged === void 0) {
+    ctx.batchState = void 0;
+    return;
+  }
+  const gl = ctx.gl;
+  const prog = ctx.batchFill;
+  gl.useProgram(prog.handle);
+  const indexCount = batch.uploadAndBind();
+  setProjAndModel(ctx, prog, BATCH_MODEL);
+  setColorUniform(ctx, prog, 1, 1, 1, 1);
+  setAlphaUniform(ctx, prog, staged.alpha);
+  gl.uniform1f(prog.uniform("u_synthBold"), staged.synthBold);
+  setColorMatrixUniforms(ctx, prog, staged.colorMatrix);
+  gl.activeTexture(gl.TEXTURE0);
+  gl.bindTexture(gl.TEXTURE_2D, ctx.whiteTexture);
+  for (let i = 0; i < staged.textures.length; i++) {
+    const entry = staged.textures[i];
+    if (entry.kind === "atlas") {
+      ctx.textureCache.bind(entry.id, i + 1);
+      FIELD_SCALES[2 * (i + 1)] = entry.fieldScale[0];
+      FIELD_SCALES[2 * (i + 1) + 1] = entry.fieldScale[1];
+      continue;
+    }
+    if (entry.kind === "ramps") {
+      ctx.gradRamps.bind(i + 1);
+      continue;
+    }
+    ctx.imageCache.bind(entry.image, i + 1);
+    ctx.imageCache.setMagFilter(
+      entry.image,
+      entry.sampling === "nearest" ? gl.NEAREST : gl.LINEAR
+    );
+  }
+  gl.uniform1iv(prog.uniform("u_samplers"), SAMPLER_UNITS);
+  gl.uniform2fv(prog.uniform("u_fieldScale"), FIELD_SCALES);
+  applyClipTest(ctx, staged.clipDepth);
+  drawTriangles(ctx, indexCount, ctx.gl.UNSIGNED_INT);
+  gl.activeTexture(gl.TEXTURE0);
+  gl.bindVertexArray(null);
+  batch.reset();
+  ctx.batchState = void 0;
+}
+
+// src/draw/clip.ts
+function enterGroupClip(ctx, clip) {
+  const pending = ctx.clipStack.reduce((n, e) => n + (e.depth === 0 ? 1 : 0), 0);
+  if (ctx.clipDepth + pending + 1 > 7) {
+    throw new Error(
+      "weasel: clip nesting depth exceeded (max 7). You can't nest more than 7 levels of clipped containers in a single draw tree. Flatten the hierarchy or compose poses outside the scene graph."
+    );
+  }
+  enterClip(ctx, clip);
+}
+function enterClip(ctx, path) {
+  const transform = ctx.state.transform;
+  const rect = axisAlignedClipRect(path, transform);
+  if (rect === null) {
+    materializeClips(ctx);
+    const depth = ctx.clipDepth + 1;
+    pushClip(ctx, path, depth);
+    ctx.clipDepth = depth;
+    ctx.clipStack.push({ path, transform, rect: null, depth });
+  } else {
+    ctx.clipStack.push({ path, transform, rect, depth: 0 });
+  }
+  syncBatchClip(ctx);
+}
+function leaveClip(ctx) {
+  const entry = ctx.clipStack.pop();
+  if (entry.depth > 0) {
+    popClip(ctx, entry.path, entry.depth - 1, entry.transform);
+    ctx.clipDepth = entry.depth - 1;
+  }
+  syncBatchClip(ctx);
+}
+function materializeClips(ctx) {
+  for (const entry of ctx.clipStack) {
+    if (entry.depth !== 0) continue;
+    const depth = ctx.clipDepth + 1;
+    pushClip(ctx, entry.path, depth, entry.transform);
+    entry.depth = depth;
+    ctx.clipDepth = depth;
+  }
+}
+function syncBatchClip(ctx) {
+  let rect = null;
+  for (const entry of ctx.clipStack) {
+    if (entry.rect) rect = rect ? intersectClipRects(rect, entry.rect) : entry.rect;
+  }
+  ctx.drawBatch.clip = rect;
+}
+function runClipDepth(ctx) {
+  const stack = ctx.clipStack;
+  if (stack.length === 0 || ctx.uncut) return ctx.clipDepth;
+  for (let i = stack.length - 1; i >= 0; i--) {
+    if (stack[i].rect === null) return stack[i].depth;
+  }
+  for (const entry of stack) if (entry.depth > 0) return entry.depth - 1;
+  return ctx.clipDepth;
+}
+function enterUncut(ctx) {
+  materializeClips(ctx);
+  const cut = ctx.drawBatch.clip;
+  ctx.drawBatch.clip = null;
+  ctx.uncut = true;
+  return cut;
+}
+function leaveUncut(ctx, cut) {
+  ctx.drawBatch.clip = cut;
+  ctx.uncut = false;
+}
+function retryUncut(ctx, a, b, fn) {
+  const cut = enterUncut(ctx);
+  fn(ctx, a, b);
+  leaveUncut(ctx, cut);
+}
+function flushForOwnDraw(ctx) {
+  flushBatch(ctx);
+  if (ctx.clipStack.length > 0) materializeClips(ctx);
+}
+function rasterizePathToStencil(ctx, path, model) {
+  const gl = ctx.gl;
+  const handle = fillMeshHandle(ctx, path);
+  gl.useProgram(ctx.pathFill.handle);
+  gl.bindVertexArray(handle.vao);
+  setProjAndModel(ctx, ctx.pathFill, model);
+  drawTriangles(ctx, handle.indexCount, ctx.gl.UNSIGNED_INT);
+  gl.bindVertexArray(null);
+}
+function pushClip(ctx, path, newDepth, model = ctx.state.transform) {
+  flushBatch(ctx);
+  const gl = ctx.gl;
+  const ancestors = ancestorMask(newDepth - 1);
+  const newBit = 1 << newDepth;
+  const ref = ancestors | newBit;
+  gl.enable(gl.STENCIL_TEST);
+  gl.colorMask(false, false, false, false);
+  if (fillMeshHandle(ctx, path).requiresStencil) {
+    gl.stencilMask(1);
+    gl.stencilFunc(gl.ALWAYS, 0, 1);
+    gl.stencilOp(gl.KEEP, gl.KEEP, gl.INVERT);
+    rasterizePathToStencil(ctx, path, model);
+    gl.stencilMask(newBit);
+    gl.stencilFunc(gl.EQUAL, ref | 1, ancestors | 1);
+    gl.stencilOp(gl.KEEP, gl.KEEP, gl.REPLACE);
+    rasterizePathToStencil(ctx, path, model);
+    gl.stencilMask(1);
+    gl.stencilFunc(gl.ALWAYS, 0, 1);
+    gl.stencilOp(gl.KEEP, gl.KEEP, gl.INVERT);
+    rasterizePathToStencil(ctx, path, model);
+  } else {
+    gl.stencilMask(newBit);
+    gl.stencilFunc(gl.EQUAL, ref, ancestors);
+    gl.stencilOp(gl.KEEP, gl.KEEP, gl.REPLACE);
+    rasterizePathToStencil(ctx, path, model);
+  }
+  gl.colorMask(true, true, true, true);
+  gl.stencilMask(255);
+}
+function popClip(ctx, path, oldDepth, model = ctx.state.transform) {
+  if (ctx.batchState !== void 0 && ctx.batchState.clipDepth > oldDepth) flushBatch(ctx);
+  const gl = ctx.gl;
+  gl.enable(gl.STENCIL_TEST);
+  const oldBit = 1 << oldDepth + 1;
+  const ref = ancestorMask(oldDepth) | oldBit;
+  gl.colorMask(false, false, false, false);
+  gl.stencilMask(oldBit);
+  gl.stencilFunc(gl.EQUAL, ref, ref);
+  gl.stencilOp(gl.KEEP, gl.KEEP, gl.ZERO);
+  rasterizePathToStencil(ctx, path, model);
+  gl.colorMask(true, true, true, true);
+  gl.stencilMask(255);
+}
+var WORLD = {};
+function resolveStrokeLengths(transform, cmd) {
+  const stroke = cmd.stroke;
+  const { markerStart, markerMid, markerEnd } = stroke;
+  if (typeof stroke.width !== "object" && !isPxMarker(markerStart) && !isPxMarker(markerMid) && !isPxMarker(markerEnd)) {
+    return { cmd, spaces: WORLD };
+  }
+  const resolved = { ...stroke };
+  const { scale, metric } = strokeSpaceOf(transform[0], transform[1], transform[3], transform[4]);
+  const screen = (pxPerUnit) => metric === null ? void 0 : { metric, pxPerUnit };
+  let ribbon;
+  if (typeof stroke.width === "object") {
+    const pxPerUnit = quantizeStrokeScale(stroke.width.px, scale);
+    resolved.width = resolveStrokeWidth(stroke.width, pxPerUnit);
+    if (stroke.dash && pxPerUnit > 0) resolved.dash = stroke.dash.map((d) => d / pxPerUnit);
+    ribbon = screen(pxPerUnit);
+  }
+  const head = (ref) => {
+    if (ref === void 0 || typeof ref === "string" || ref.size === void 0) return ribbon;
+    if (typeof ref.size === "number") return void 0;
+    return screen(quantizeStrokeScale(ref.size.px, scale));
+  };
+  const spaces = { ribbon, start: head(markerStart), mid: head(markerMid), end: head(markerEnd) };
+  if (isPxMarker(markerStart)) resolved.markerStart = resolvedMarker(markerStart, scale);
+  if (isPxMarker(markerMid)) resolved.markerMid = resolvedMarker(markerMid, scale);
+  if (isPxMarker(markerEnd)) resolved.markerEnd = resolvedMarker(markerEnd, scale);
+  return { cmd: { ...cmd, stroke: resolved }, spaces };
+}
+function isPxMarker(ref) {
+  return typeof ref === "object" && typeof ref.size === "object";
+}
+function resolvedMarker(ref, scale) {
+  return { ...ref, size: resolveMarkerSize(ref, 0, quantizeStrokeScale(ref.size.px, scale)) };
+}
+function batchPaint(ctx, fill, hasVColors) {
+  if (hasVColors) return void 0;
+  const kind = fill.fill ?? "solid";
+  if (kind === "solid") {
+    const solid = fill;
+    return { kind: "solid", color: solid.color, opacity: solid.opacity };
+  }
+  if (kind !== "linear-gradient" && kind !== "radial-gradient" && kind !== "conic-gradient") {
+    return void 0;
+  }
+  const grad = fill;
+  const g = gradientMap(ctx, grad.units);
+  if (!g) return null;
+  if (grad.fill === "linear-gradient") return ramp(grad, PAINT_MODE_PLAIN, linearRampUV(g, grad));
+  if (grad.fill === "radial-gradient") return ramp(grad, PAINT_MODE_RADIAL, radialRampUV(g, grad));
+  return ramp(grad, PAINT_MODE_CONIC, conicRampUV(g, grad));
+}
+function ramp(fill, mode, uv) {
+  return {
+    kind: "ramp",
+    stops: fill.stops,
+    space: fill.interpolate ?? "rgb",
+    opacity: fill.opacity,
+    mode,
+    uv
+  };
+}
+function gradientMap(ctx, units) {
+  const inverse = gradientSpaceInverse(ctx, units);
+  return inverse && mat3.multiply(inverse, ctx.state.transform);
+}
+function linearRampUV(g, fill) {
+  const dx = fill.to.x - fill.from.x;
+  const dy = fill.to.y - fill.from.y;
+  const len = Math.hypot(dx, dy) || 1;
+  const k = 1 / (len * len);
+  return {
+    ux: (g[0] * dx + g[1] * dy) * k,
+    uy: (g[3] * dx + g[4] * dy) * k,
+    u0: ((g[6] - fill.from.x) * dx + (g[7] - fill.from.y) * dy) * k,
+    vx: 0,
+    vy: 0,
+    v0: 0
+  };
+}
+function radialRampUV(g, fill) {
+  const k = 1 / Math.max(fill.radius, 1e-4);
+  return {
+    ux: g[0] * k,
+    uy: g[3] * k,
+    u0: (g[6] - fill.center.x) * k,
+    vx: g[1] * k,
+    vy: g[4] * k,
+    v0: (g[7] - fill.center.y) * k
+  };
+}
+function conicRampUV(g, fill) {
+  const cos = Math.cos(fill.angle);
+  const sin = Math.sin(fill.angle);
+  const dx0 = g[6] - fill.center.x;
+  const dy0 = g[7] - fill.center.y;
+  return {
+    ux: cos * g[0] + sin * g[1],
+    uy: cos * g[3] + sin * g[4],
+    u0: cos * dx0 + sin * dy0,
+    vx: cos * g[1] - sin * g[0],
+    vy: cos * g[4] - sin * g[3],
+    v0: cos * dy0 - sin * dx0
+  };
+}
+function rampVertices(paint, rowV) {
+  return paint.mode === PAINT_MODE_PLAIN ? { uv: { ...paint.uv, v0: rowV }, post: 1 } : { uv: paint.uv, post: rowV };
+}
+function gradientSpaceInverse(ctx, units) {
+  if (units === "local") return mat3.invert(ctx.state.transform);
+  if (units === "world" && ctx.viewMatrix) return mat3.invert(ctx.viewMatrix);
+  return mat3.identity();
+}
+function spaceToDevice(ctx, units) {
+  const inverse = gradientSpaceInverse(ctx, units);
+  const toScreen = inverse && mat3.invert(inverse);
+  if (!toScreen) return null;
+  const ratio = ctx.deviceWidth && ctx.widthCss > 0 ? ctx.deviceWidth / ctx.widthCss : 1;
+  return mat3.multiply(mat3.scaled(mat3.identity(), ratio, ratio), toScreen);
+}
+
+// src/draw/batch.ts
+function isIdentityColorMatrix(cm) {
+  return cm === IDENTITY_COLOR_MATRIX || sameValues(IDENTITY_COLOR_MATRIX, cm);
+}
+function stagedStateIsLive(ctx, staged, image, sampling, synthBold = 0) {
+  if (staged.clipDepth !== (ctx.clipStack.length === 0 ? ctx.clipDepth : runClipDepth(ctx))) return false;
+  if (staged.synthBold !== synthBold) return false;
+  if (!staged.foldsAlpha && staged.alpha !== ctx.state.alpha) return false;
+  if (image !== void 0 && slotForBitmap(staged, image, sampling) < 0) return false;
+  const colorMatrix = ctx.state.colorMatrix;
+  return staged.colorMatrix === colorMatrix || sameValues(staged.colorMatrix, colorMatrix);
+}
+function slotForBitmap(staged, image, sampling) {
+  for (let i = 0; i < staged.textures.length; i++) {
+    const entry = staged.textures[i];
+    if (entry.kind !== "bitmap" || entry.image !== image) continue;
+    return entry.sampling === sampling ? i + 1 : -1;
+  }
+  return nextFreeSlot(staged);
+}
+function slotForRamps(staged) {
+  for (let i = 0; i < staged.textures.length; i++) {
+    if (staged.textures[i].kind === "ramps") return i + 1;
+  }
+  return nextFreeSlot(staged);
+}
+function slotForAtlas(staged, id) {
+  for (let i = 0; i < staged.textures.length; i++) {
+    const entry = staged.textures[i];
+    if (entry.kind === "atlas" && entry.id === id) return i + 1;
+  }
+  return nextFreeSlot(staged);
+}
+function nextFreeSlot(staged) {
+  return staged.textures.length + 1 < BATCH_TEXTURE_SLOTS ? staged.textures.length + 1 : -1;
+}
+var MAX_BATCHED_MESH_VERTICES = 96;
+var MAX_BATCHED_MESH_VERTICES_IN_RUN = 1024;
+var meshBatching = {
+  maxVertices: MAX_BATCHED_MESH_VERTICES,
+  maxVerticesInRun: MAX_BATCHED_MESH_VERTICES_IN_RUN
+};
+function canBatchMesh(ctx, mesh) {
+  if (mesh.requiresStencil) return false;
+  const cap = ctx.drawBatch.length > 0 ? meshBatching.maxVerticesInRun : meshBatching.maxVertices;
+  return mesh.vertices.length >> 1 <= cap;
+}
+function stageSolid(ctx, vertices) {
+  if (ctx.batchState !== void 0 && !stagedStateIsLive(ctx, ctx.batchState)) flushBatch(ctx);
+  if (ctx.drawBatch.wouldOverflow(vertices)) flushBatch(ctx);
+  return openRun(ctx);
+}
+function openRun(ctx) {
+  if (ctx.batchState === void 0) {
+    const colorMatrix = ctx.state.colorMatrix;
+    const foldsAlpha = isIdentityColorMatrix(colorMatrix);
+    ctx.batchState = {
+      alpha: foldsAlpha ? 1 : ctx.state.alpha,
+      colorMatrix,
+      clipDepth: runClipDepth(ctx),
+      synthBold: 0,
+      foldsAlpha,
+      textures: []
+    };
+  }
+  return ctx.batchState;
+}
+function stageImage(ctx, image, sampling) {
+  if (ctx.batchState !== void 0 && !stagedStateIsLive(ctx, ctx.batchState, image, sampling)) {
+    flushBatch(ctx);
+  }
+  if (ctx.drawBatch.wouldOverflow(4)) flushBatch(ctx);
+  const staged = openRun(ctx);
+  let slot = slotForBitmap(staged, image, sampling);
+  if (slot > staged.textures.length) {
+    staged.textures.push({ kind: "bitmap", image, sampling });
+    slot = staged.textures.length;
+  }
+  return { staged, slot };
+}
+function stageGlyphs(ctx, atlasId, fieldScale, synthBold) {
+  if (ctx.batchState !== void 0 && (!stagedStateIsLive(ctx, ctx.batchState, void 0, void 0, synthBold) || slotForAtlas(ctx.batchState, atlasId) < 0)) {
+    flushBatch(ctx);
+  }
+  if (ctx.drawBatch.wouldOverflow(4)) flushBatch(ctx);
+  const staged = openRun(ctx);
+  staged.synthBold = synthBold;
+  let slot = slotForAtlas(staged, atlasId);
+  if (slot > staged.textures.length) {
+    staged.textures.push({ kind: "atlas", id: atlasId, fieldScale });
+    slot = staged.textures.length;
+  }
+  return { staged, slot };
+}
+function stageRamps(ctx, stops, space, vertices) {
+  if (ctx.gradRamps.wouldReshape(stops, space)) flushBatch(ctx);
+  if (ctx.batchState !== void 0 && (!stagedStateIsLive(ctx, ctx.batchState) || slotForRamps(ctx.batchState) < 0)) {
+    flushBatch(ctx);
+  }
+  if (ctx.drawBatch.wouldOverflow(vertices)) flushBatch(ctx);
+  const staged = openRun(ctx);
+  let slot = slotForRamps(staged);
+  if (slot > staged.textures.length) {
+    staged.textures.push({ kind: "ramps" });
+    slot = staged.textures.length;
+  }
+  return { staged, slot, rowV: ctx.gradRamps.rowV(ctx.gradRamps.upload(stops, space)) };
+}
+function stagedAlpha(ctx, staged, opacity) {
+  return (opacity ?? 1) * (staged.foldsAlpha ? ctx.state.alpha : 1);
+}
+function stagedColor(ctx, staged, paint) {
+  const [r, g, b, a] = resolveColor(paint.color);
+  return [r, g, b, a * stagedAlpha(ctx, staged, paint.opacity)];
+}
+function pushRect(ctx, rect, fill) {
+  const staged = stageSolid(ctx, 4);
+  const [r, g, b, a] = stagedColor(ctx, staged, fill);
+  if (!ctx.drawBatch.pushRect(
+    rect.x,
+    rect.y,
+    rect.width,
+    rect.height,
+    ctx.state.transform,
+    r,
+    g,
+    b,
+    a
+  )) retryUncut(ctx, rect, fill, pushRect);
+}
+function pushMesh(ctx, mesh, paint) {
+  const staged = stageSolid(ctx, mesh.vertices.length >> 1);
+  const [r, g, b, a] = stagedColor(ctx, staged, paint);
+  if (!ctx.drawBatch.pushMesh(mesh, ctx.state.transform, r, g, b, a)) {
+    retryUncut(ctx, mesh, paint, pushMesh);
+  }
+}
+function pushRampRect(ctx, rect, paint) {
+  const { staged, slot, rowV } = stageRamps(ctx, paint.stops, paint.space, 4);
+  const { uv, post } = rampVertices(paint, rowV);
+  if (!ctx.drawBatch.pushGradientRect(
+    rect.x,
+    rect.y,
+    rect.width,
+    rect.height,
+    ctx.state.transform,
+    uv,
+    post,
+    slot,
+    paint.mode,
+    1,
+    1,
+    1,
+    stagedAlpha(ctx, staged, paint.opacity)
+  )) retryUncut(ctx, rect, paint, pushRampRect);
+}
+function pushRampMesh(ctx, mesh, paint) {
+  const { staged, slot, rowV } = stageRamps(ctx, paint.stops, paint.space, mesh.vertices.length >> 1);
+  const { uv, post } = rampVertices(paint, rowV);
+  if (!ctx.drawBatch.pushGradientMesh(
+    mesh,
+    ctx.state.transform,
+    uv,
+    post,
+    slot,
+    paint.mode,
+    1,
+    1,
+    1,
+    stagedAlpha(ctx, staged, paint.opacity)
+  )) retryUncut(ctx, mesh, paint, pushRampMesh);
+}
+function tryStageFill(ctx, mesh, paint) {
+  if (paint !== void 0 && canBatchMesh(ctx, mesh)) {
+    if (paint.kind === "ramp") pushRampMesh(ctx, mesh, paint);
+    else pushMesh(ctx, mesh, paint);
+    return true;
+  }
+  flushForOwnDraw(ctx);
+  return false;
+}
+function patternTileSpace(spaceInverse, origin, transform) {
+  const [a, b, c, d] = transform ?? [1, 0, 0, 1];
+  const placement = mat3.fromAffine([a, b, c, d, origin.x, origin.y]);
+  const unplace = mat3.invert(placement);
+  return unplace && mat3.multiply(unplace, spaceInverse);
+}
+
+// src/draw/paintBind.ts
+function paintBindContext(ctx) {
+  const cached = BIND_CONTEXTS.get(ctx);
+  if (cached) return cached;
+  const made = {
+    gl: ctx.gl,
+    get alpha() {
+      return ctx.state.alpha;
+    },
+    program: (id) => ctx.ensureProgram?.(id) ?? ctx.programRegistry.get(id) ?? null,
+    setProjAndModel: (prog) => setProjAndModel(ctx, prog),
+    spaceInverse: (units) => gradientSpaceInverse(ctx, units),
+    spaceToDevice: (units) => spaceToDevice(ctx, units),
+    get maxTextureSize() {
+      return ctx.imageCache.maxTextureSide;
+    },
+    resources: ctx.paintResources ?? unownedPaintResources(ctx.gl),
+    bindRamp: (stops, unit, space) => {
+      const row = ctx.gradRamps.upload(stops, space);
+      ctx.gradRamps.bind(unit);
+      return ctx.gradRamps.rowV(row);
+    }
+  };
+  BIND_CONTEXTS.set(ctx, made);
+  return made;
+}
+var BIND_CONTEXTS = /* @__PURE__ */ new WeakMap();
+var UNOWNED_RESOURCES = /* @__PURE__ */ new WeakMap();
+function unownedPaintResources(gl) {
+  let made = UNOWNED_RESOURCES.get(gl);
+  if (!made) {
+    made = createPaintResources();
+    UNOWNED_RESOURCES.set(gl, made);
+  }
+  return made;
+}
+function bindPattern(ctx, prog, fill, model) {
+  const tex = fill.pattern;
+  const entry = getTexture(tex.id);
+  if (!entry) {
+    const isDev = typeof process !== "undefined" ? process.env.NODE_ENV !== "production" : true;
+    if (isDev) console.warn(`weasel: pattern TextureHandle "${tex.id}" not registered`);
+    return null;
+  }
+  const inverse = gradientSpaceInverse(ctx, fill.units);
+  if (!inverse) return null;
+  const tileSpace = patternTileSpace(inverse, fill.origin ?? { x: 0, y: 0 }, fill.transform);
+  if (!tileSpace) return null;
+  ctx.textureCache.uploadRegistered(tex.id, entry.source, "repeat");
+  const gl = ctx.gl;
+  gl.useProgram(prog.handle);
+  setProjAndModel(ctx, prog, model);
+  setColorMatrixUniforms(ctx, prog);
+  gl.uniformMatrix3fv(prog.uniform("u_worldInv"), false, mat3.toUniform(tileSpace));
+  const [tw, th] = textureSize(entry.source);
+  gl.uniform2f(prog.uniform("u_tileSize"), tw, th);
+  ctx.textureCache.bind(tex.id, 0);
+  gl.uniform1i(prog.uniform("u_sampler"), 0);
+  gl.uniform1f(prog.uniform("u_opacity"), fill.opacity ?? 1);
+  setAlphaUniform(ctx, prog, ctx.state.alpha);
+  return prog;
+}
+function textureSize(source) {
+  const w = "naturalWidth" in source ? source.naturalWidth : source.width;
+  const h = "naturalHeight" in source ? source.naturalHeight : source.height;
+  return [w || 1, h || 1];
+}
+function bindGradient(ctx, prog, fill, model) {
+  const inverse = gradientSpaceInverse(ctx, fill.units);
+  if (!inverse) return null;
+  const gl = ctx.gl;
+  const row = ctx.gradRamps.upload(fill.stops, fill.interpolate ?? "rgb");
+  gl.useProgram(prog.handle);
+  setProjAndModel(ctx, prog, model);
+  gl.uniformMatrix3fv(prog.uniform("u_worldInv"), false, mat3.toUniform(inverse));
+  setColorMatrixUniforms(ctx, prog);
+  ctx.gradRamps.bind(0);
+  gl.uniform1i(prog.uniform("u_ramp"), 0);
+  gl.uniform1f(prog.uniform("u_rampV"), ctx.gradRamps.rowV(row));
+  setAlphaUniform(ctx, prog, ctx.state.alpha);
+  gl.uniform1f(prog.uniform("u_opacity"), fill.opacity ?? 1);
+  if (fill.fill === "linear-gradient") {
+    gl.uniform1i(prog.uniform("u_gradKind"), 0);
+    const dx = fill.to.x - fill.from.x;
+    const dy = fill.to.y - fill.from.y;
+    const len = Math.hypot(dx, dy) || 1;
+    gl.uniform2f(prog.uniform("u_gradP0"), fill.from.x, fill.from.y);
+    gl.uniform2f(prog.uniform("u_gradDir"), dx / len, dy / len);
+    gl.uniform1f(prog.uniform("u_gradLen"), len);
+    gl.uniform1f(prog.uniform("u_gradRadius"), 0);
+    gl.uniform1f(prog.uniform("u_gradAngle"), 0);
+  } else if (fill.fill === "radial-gradient") {
+    gl.uniform1i(prog.uniform("u_gradKind"), 1);
+    gl.uniform2f(prog.uniform("u_gradP0"), fill.center.x, fill.center.y);
+    gl.uniform2f(prog.uniform("u_gradDir"), 0, 0);
+    gl.uniform1f(prog.uniform("u_gradLen"), 0);
+    gl.uniform1f(prog.uniform("u_gradRadius"), fill.radius);
+    gl.uniform1f(prog.uniform("u_gradAngle"), 0);
+  } else {
+    gl.uniform1i(prog.uniform("u_gradKind"), 2);
+    gl.uniform2f(prog.uniform("u_gradP0"), fill.center.x, fill.center.y);
+    gl.uniform2f(prog.uniform("u_gradDir"), 0, 0);
+    gl.uniform1f(prog.uniform("u_gradLen"), 0);
+    gl.uniform1f(prog.uniform("u_gradRadius"), 0);
+    gl.uniform1f(prog.uniform("u_gradAngle"), fill.angle);
+  }
+  return prog;
+}
+
+// src/draw/pathPaint.ts
+function drawPath(ctx, cmd) {
+  if (cmd.fill) drawPathFill(ctx, cmd);
+  if (cmd.stroke?.paint) drawPathStroke(ctx, cmd);
+}
+function drawPathFill(ctx, cmd) {
+  const fill = cmd.fill;
+  const isSolid2 = fill.fill === void 0 || fill.fill === "solid";
+  const hasVColors = !!(cmd.vertexColors && cmd.vertexColors.length > 0);
+  const solid = fill;
+  const paint = batchPaint(ctx, fill, hasVColors);
+  if (paint === null) return;
+  if (paint !== void 0 && cmd.path.kind === "rect") {
+    if (paint.kind === "ramp") pushRampRect(ctx, cmd.path, paint);
+    else pushRect(ctx, cmd.path, paint);
+    return;
+  }
+  const mesh = fillMesh(ctx, cmd.path);
+  if (tryStageFill(ctx, mesh, paint)) return;
+  const handle = meshHandle(ctx, mesh);
+  if (isSolid2 && hasVColors) {
+    drawPathFillVColor(ctx, cmd, solid, handle);
+  } else if (handle.requiresStencil) {
+    drawPathFillStencil(ctx, fill, handle);
+  } else {
+    drawPathFillByKind(ctx, fill, handle);
+  }
+}
+function attachVertexColors(gl, prog, perAnchor, handle) {
+  const vbo = gl.createBuffer();
+  if (!vbo) throw new Error("attachVertexColors: createBuffer returned null");
+  gl.bindBuffer(gl.ARRAY_BUFFER, vbo);
+  gl.bufferData(gl.ARRAY_BUFFER, expandAnchorColors(perAnchor, handle), gl.DYNAMIC_DRAW);
+  const location = prog.attribute("a_vertexColor");
+  if (location !== void 0) {
+    gl.enableVertexAttribArray(location);
+    gl.vertexAttribPointer(location, 4, gl.FLOAT, false, 0, 0);
+  }
+  return { vbo, location };
+}
+function detachVertexColors(gl, { vbo, location }) {
+  if (location !== void 0) gl.disableVertexAttribArray(location);
+  gl.deleteBuffer(vbo);
+}
+function expandAnchorColors(perAnchor, handle) {
+  const aA = handle.anchorA;
+  const aB = handle.anchorB;
+  const aT = handle.anchorT;
+  if (!aA || !aB || !aT) {
+    return new Float32Array(perAnchor);
+  }
+  const n = aA.length;
+  const out = new Float32Array(n * 4);
+  for (let i = 0; i < n; i++) {
+    const a4 = aA[i] * 4;
+    const b4 = aB[i] * 4;
+    const t = aT[i];
+    out[i * 4 + 0] = perAnchor[a4 + 0] + (perAnchor[b4 + 0] - perAnchor[a4 + 0]) * t;
+    out[i * 4 + 1] = perAnchor[a4 + 1] + (perAnchor[b4 + 1] - perAnchor[a4 + 1]) * t;
+    out[i * 4 + 2] = perAnchor[a4 + 2] + (perAnchor[b4 + 2] - perAnchor[a4 + 2]) * t;
+    out[i * 4 + 3] = perAnchor[a4 + 3] + (perAnchor[b4 + 3] - perAnchor[a4 + 3]) * t;
+  }
+  return out;
+}
+function drawPathFillVColor(ctx, cmd, fill, handle) {
+  const gl = ctx.gl;
+  const prog = ctx.pathFillVColor;
+  gl.useProgram(prog.handle);
+  gl.bindVertexArray(handle.vao);
+  setProjAndModel(ctx, prog);
+  setSolidPaintUniforms(ctx, prog, fill.color, fill.opacity);
+  setColorMatrixUniforms(ctx, prog);
+  const colors = attachVertexColors(gl, prog, cmd.vertexColors, handle);
+  if (handle.requiresStencil) {
+    beginParityMask(ctx, handle.indexCount);
+    drawTriangles(ctx, handle.indexCount, ctx.gl.UNSIGNED_INT);
+    endParityMask(ctx);
+  } else {
+    applyClipTest(ctx);
+    drawTriangles(ctx, handle.indexCount, ctx.gl.UNSIGNED_INT);
+  }
+  detachVertexColors(gl, colors);
+  gl.bindVertexArray(null);
+}
+function bindPathFillByKind(ctx, fill) {
+  const kind = fill.fill ?? "solid";
+  if (kind === "solid") return bindPathFillSolid(ctx, fill);
+  if (kind === "pattern") return bindPathFillPattern(ctx, fill);
+  if (kind === "linear-gradient" || kind === "radial-gradient" || kind === "conic-gradient") {
+    return bindPathFillGradient(ctx, fill);
+  }
+  const bind = getPaintDrawKind(kind)?.bind;
+  return bind ? bind(paintBindContext(ctx), fill) : null;
+}
+function drawPathFillByKind(ctx, fill, handle) {
+  const prog = bindPathFillByKind(ctx, fill);
+  if (!prog) return;
+  const gl = ctx.gl;
+  gl.bindVertexArray(handle.vao);
+  applyClipTest(ctx);
+  drawTriangles(ctx, handle.indexCount, ctx.gl.UNSIGNED_INT);
+  gl.bindVertexArray(null);
+}
+function bindPathFillSolid(ctx, fill) {
+  const prog = ctx.pathFill;
+  ctx.gl.useProgram(prog.handle);
+  setProjAndModel(ctx, prog);
+  setSolidPaintUniforms(ctx, prog, fill.color, fill.opacity);
+  setColorMatrixUniforms(ctx, prog);
+  return prog;
+}
+function bindPathFillPattern(ctx, fill) {
+  return bindPattern(ctx, ctx.patternFill, fill, ctx.state.transform);
+}
+function bindPathFillGradient(ctx, fill) {
+  return bindGradient(ctx, ctx.gradFill, fill, ctx.state.transform);
+}
+function drawPathFillStencil(ctx, fill, handle) {
+  const gl = ctx.gl;
+  gl.useProgram(ctx.pathFill.handle);
+  gl.bindVertexArray(handle.vao);
+  setProjAndModel(ctx, ctx.pathFill);
+  beginParityMask(ctx, handle.indexCount);
+  if (bindPathFillByKind(ctx, fill)) {
+    drawTriangles(ctx, handle.indexCount, ctx.gl.UNSIGNED_INT);
+  }
+  endParityMask(ctx);
+  gl.bindVertexArray(null);
+}
+function drawPathStroke(ctx, rawCmd) {
+  const { cmd, spaces } = resolveStrokeLengths(ctx.state.transform, rawCmd);
+  const stroke = cmd.stroke;
+  const align = stroke.align ?? "center";
+  const metric = spaces.ribbon?.metric;
+  const stenciled = cmd.path.kind === "polygon" || metric !== void 0 && !metricKeepsRects(metric);
+  if (stenciled && align !== "center") {
+    flushForOwnDraw(ctx);
+    drawPathStrokeStenciled(ctx, cmd, align, spaces);
+  } else {
+    drawPathStrokeUnclipped(ctx, cmd, spaces);
+  }
+  const width = resolveStrokeWidth(stroke.width ?? 1, 1);
+  const heads = cachedMarkerCommands(cmd.path, rawCmd.stroke, stroke, width, ctx.flattenTolerance, spaces);
+  for (const marker of heads) drawPath(ctx, marker);
+}
+function drawPathStrokeUnclipped(ctx, cmd, spaces) {
+  const stroke = cmd.stroke;
+  const paint = stroke.paint;
+  const isSolid2 = paint.fill === void 0 || paint.fill === "solid";
+  const solid = paint;
+  const mesh = strokeMesh(cmd.path, stroke, ctx.flattenTolerance, spaces);
+  if (mesh.indices.length === 0) return;
+  const hasVColors = !!(stroke.vertexColors && stroke.vertexColors.length > 0);
+  const batched = batchPaint(ctx, paint, hasVColors);
+  if (batched === null) return;
+  if (tryStageFill(ctx, mesh, batched)) return;
+  const handle = hasVColors ? ctx.meshCache.uploadTransient(mesh) : ctx.meshCache.uploadRecurring(mesh);
+  if (!isSolid2 && !hasVColors) {
+    drawPathFillByKind(ctx, paint, handle);
+    return;
+  }
+  const gl = ctx.gl;
+  if (hasVColors) {
+    const prog = ctx.pathFillVColor;
+    gl.useProgram(prog.handle);
+    gl.bindVertexArray(handle.vao);
+    setProjAndModel(ctx, prog);
+    setSolidPaintUniforms(ctx, prog, isSolid2 ? solid.color : "#ffffff", paint.opacity);
+    setColorMatrixUniforms(ctx, prog);
+    const colors = attachVertexColors(gl, prog, stroke.vertexColors, handle);
+    applyClipTest(ctx);
+    drawTriangles(ctx, handle.indexCount, ctx.gl.UNSIGNED_INT);
+    detachVertexColors(gl, colors);
+    gl.bindVertexArray(null);
+    return;
+  }
+  gl.useProgram(ctx.pathFill.handle);
+  gl.bindVertexArray(handle.vao);
+  setProjAndModel(ctx, ctx.pathFill);
+  setSolidPaintUniforms(ctx, ctx.pathFill, solid.color, solid.opacity);
+  setColorMatrixUniforms(ctx, ctx.pathFill);
+  applyClipTest(ctx);
+  drawTriangles(ctx, handle.indexCount, ctx.gl.UNSIGNED_INT);
+  gl.bindVertexArray(null);
+}
+var DOUBLED_VERTEX_WIDTHS = /* @__PURE__ */ new WeakMap();
+function doubledVertexWidths(widths) {
+  let doubled = DOUBLED_VERTEX_WIDTHS.get(widths);
+  if (doubled === void 0) {
+    doubled = widths.map((w) => w * 2);
+    DOUBLED_VERTEX_WIDTHS.set(widths, doubled);
+  }
+  return doubled;
+}
+function drawPathStrokeStenciled(ctx, cmd, align, spaces) {
+  const stroke = cmd.stroke;
+  const paint = stroke.paint;
+  const isSolid2 = paint.fill === void 0 || paint.fill === "solid";
+  const solid = paint;
+  const widerStroke = {
+    ...stroke,
+    width: resolveStrokeWidth(stroke.width ?? 1, 1) * 2,
+    ...stroke.vertexWidths ? { vertexWidths: doubledVertexWidths(stroke.vertexWidths) } : {},
+    align: "center"
+  };
+  const useVColor = !!(stroke.vertexColors && stroke.vertexColors.length > 0);
+  const fillHandle = fillMeshHandle(ctx, cmd.path);
+  const ribbonMesh = strokeMesh(cmd.path, widerStroke, ctx.flattenTolerance, spaces);
+  if (ribbonMesh.indices.length === 0) return;
+  const ribbonHandle = useVColor ? ctx.meshCache.uploadTransient(ribbonMesh) : ctx.meshCache.uploadRecurring(ribbonMesh);
+  const gl = ctx.gl;
+  const prog = useVColor ? ctx.pathFillVColor : ctx.pathFill;
+  gl.useProgram(prog.handle);
+  setProjAndModel(ctx, prog);
+  gl.enable(gl.STENCIL_TEST);
+  gl.colorMask(false, false, false, false);
+  gl.stencilMask(1);
+  gl.stencilFunc(gl.ALWAYS, 1, 1);
+  gl.stencilOp(gl.KEEP, gl.KEEP, fillHandle.requiresStencil ? gl.INVERT : gl.REPLACE);
+  gl.bindVertexArray(fillHandle.vao);
+  drawTriangles(ctx, fillHandle.indexCount, ctx.gl.UNSIGNED_INT);
+  const clipMask = ancestorMask(ctx.clipDepth);
+  gl.colorMask(true, true, true, true);
+  if (align === "inner") {
+    gl.stencilFunc(gl.EQUAL, clipMask | 1, clipMask | 1);
+  } else {
+    gl.stencilFunc(gl.EQUAL, clipMask, clipMask | 1);
+  }
+  gl.stencilOp(gl.KEEP, gl.KEEP, gl.KEEP);
+  let ribbonProg = prog;
+  if (useVColor) {
+    setSolidPaintUniforms(ctx, prog, isSolid2 ? solid.color : "#ffffff", paint.opacity);
+    setColorMatrixUniforms(ctx, prog);
+  } else {
+    ribbonProg = bindPathFillByKind(ctx, paint);
+  }
+  if (!ribbonProg) {
+    gl.stencilMask(1);
+    gl.clear(gl.STENCIL_BUFFER_BIT);
+    gl.disable(gl.STENCIL_TEST);
+    gl.bindVertexArray(null);
+    return;
+  }
+  gl.bindVertexArray(ribbonHandle.vao);
+  const colors = useVColor ? attachVertexColors(gl, ribbonProg, stroke.vertexColors, ribbonHandle) : null;
+  drawTriangles(ctx, ribbonHandle.indexCount, ctx.gl.UNSIGNED_INT);
+  gl.stencilMask(1);
+  gl.clear(gl.STENCIL_BUFFER_BIT);
+  gl.disable(gl.STENCIL_TEST);
+  if (colors) detachVertexColors(gl, colors);
+  gl.bindVertexArray(null);
+}
+function outlineGroupMesh(group, dx, dy) {
+  return mergeGlyphMeshes(group, dx, dy, (glyph) => outlineMesh(glyph.key, glyph.d));
+}
+function outlineGroupStrokeMesh(group, dx, dy, transform) {
+  const stroke = group.stroke;
+  if (!stroke) return null;
+  const width = stroke.width ?? 1;
+  if (typeof width === "object") {
+    if (!(width.px > 0)) return null;
+    const shear = shearOf(group);
+    const [a, b, c, d] = [transform[0], transform[1], transform[3], transform[4]];
+    return mergeGlyphMeshes(group, dx, dy, (glyph) => {
+      if (!(glyph.scale > 0)) return null;
+      const s = glyph.scale;
+      const space = strokeSpaceOf(s * a, s * b, s * (c - a * shear), s * (d - b * shear));
+      const pxPerEm = quantizeStrokeScale(width.px, space.scale);
+      if (!(pxPerEm > 0)) return null;
+      const dash = stroke.dash?.map((v) => v / pxPerEm);
+      return outlineStrokeMesh(
+        glyph.key,
+        glyph.d,
+        width.px / pxPerEm,
+        { ...stroke, dash },
+        space.metric ?? void 0
+      );
+    });
+  }
+  if (!(width > 0)) return null;
+  return mergeGlyphMeshes(group, dx, dy, (glyph) => glyph.scale > 0 ? outlineStrokeMesh(
+    glyph.key,
+    glyph.d,
+    quantizeEmWidth(width / glyph.scale),
+    { ...stroke, dash: stroke.dash?.map((v) => v / glyph.scale) }
+  ) : null);
+}
+var shearOf = (group) => group.synthetic.italic ? Math.tan(SYNTHETIC_ITALIC_RADIANS) : 0;
+function mergeGlyphMeshes(group, dx, dy, meshFor) {
+  const parts = [];
+  let vertexFloats = 0;
+  let indexCount = 0;
+  for (const glyph of group.glyphs) {
+    const mesh = meshFor(glyph);
+    if (!mesh || mesh.indices.length === 0) continue;
+    parts.push({ mesh, glyph });
+    vertexFloats += mesh.vertices.length;
+    indexCount += mesh.indices.length;
+  }
+  if (parts.length === 0) return null;
+  const shear = shearOf(group);
+  const vertices = new Float32Array(vertexFloats);
+  const indices = new Uint32Array(indexCount);
+  let vi = 0;
+  let ii = 0;
+  let base = 0;
+  for (const { mesh, glyph } of parts) {
+    const { x, baselineY, scale } = glyph;
+    for (let k = 0; k < mesh.vertices.length; k += 2) {
+      const ex = mesh.vertices[k];
+      const ey = mesh.vertices[k + 1];
+      vertices[vi++] = x + dx + (ex - ey * shear) * scale;
+      vertices[vi++] = baselineY + dy + ey * scale;
+    }
+    for (let k = 0; k < mesh.indices.length; k++) indices[ii++] = base + mesh.indices[k];
+    base += mesh.vertices.length / 2;
+  }
+  return { vertices, indices };
+}
+
+// src/draw/scratchPass.ts
+var UNIT_QUAD = {
+  vertices: new Float32Array([0, 0, 1, 0, 1, 1, 0, 1]),
+  indices: new Uint32Array([0, 1, 2, 0, 2, 3])
+};
+function renderPaintToScratch(ctx, fill, rect) {
+  const scratch = ctx.paintScratch;
+  const bind = getPaintDrawKind(fill.fill)?.bind;
+  if (!scratch || !bind) return null;
+  const ratio = ctx.deviceWidth && ctx.widthCss > 0 ? ctx.deviceWidth / ctx.widthCss : 1;
+  const deviceW = ctx.deviceWidth ?? Math.round(ctx.widthCss);
+  const deviceH = ctx.deviceHeight ?? Math.round(ctx.heightCss);
+  const px0 = Math.max(0, Math.floor(rect.x0 * ratio));
+  const py0 = Math.max(0, Math.floor(rect.y0 * ratio));
+  const maxSide = ctx.imageCache.maxTextureSide;
+  const pw = Math.min(maxSide, Math.min(deviceW, Math.ceil(rect.x1 * ratio)) - px0);
+  const ph = Math.min(maxSide, Math.min(deviceH, Math.ceil(rect.y1 * ratio)) - py0);
+  if (!(pw > 0 && ph > 0)) return null;
+  const x0 = px0 / ratio, y0 = py0 / ratio, w = pw / ratio, h = ph / ratio;
+  const model = new Float32Array([w, 0, 0, 0, h, 0, x0, y0, 1]);
+  const proj = new Float32Array([2 / w, 0, 0, 0, 2 / h, 0, -1 - 2 * x0 / w, -1 - 2 * y0 / h, 1]);
+  const base = paintBindContext(ctx);
+  const bindCtx = {
+    ...base,
+    alpha: ctx.state.alpha,
+    maxTextureSize: base.maxTextureSize,
+    setProjAndModel: (prog2) => setProjAndModel(ctx, prog2, model, proj)
+  };
+  const gl = ctx.gl;
+  const target = scratch.acquire(pw, ph);
+  const scissorWasOn = gl.isEnabled(gl.SCISSOR_TEST);
+  gl.activeTexture(gl.TEXTURE0);
+  gl.bindTexture(gl.TEXTURE_2D, null);
+  gl.bindFramebuffer(gl.FRAMEBUFFER, target.fbo);
+  gl.viewport(0, 0, pw, ph);
+  gl.disable(gl.SCISSOR_TEST);
+  gl.disable(gl.STENCIL_TEST);
+  gl.clear(gl.COLOR_BUFFER_BIT);
+  gl.disable(gl.BLEND);
+  const prog = bind(bindCtx, fill);
+  if (prog) {
+    gl.bindVertexArray(ctx.meshCache.uploadRecurring(UNIT_QUAD).vao);
+    drawTriangles(ctx, UNIT_QUAD.indices.length, gl.UNSIGNED_INT);
+    gl.bindVertexArray(null);
+  }
+  gl.enable(gl.BLEND);
+  returnToRenderTarget(ctx, deviceW, deviceH, scissorWasOn);
+  if (!prog) return null;
+  return {
+    texture: target.texture,
+    uvFromScreen: new Float32Array([
+      ratio / target.width,
+      0,
+      0,
+      0,
+      ratio / target.height,
+      0,
+      -px0 / target.width,
+      -py0 / target.height,
+      1
+    ])
+  };
+}
+function bindScratchPaint(ctx, prog, painted) {
+  const gl = ctx.gl;
+  gl.useProgram(prog.handle);
+  setProjAndModel(ctx, prog, BATCH_MODEL);
+  gl.uniformMatrix3fv(prog.uniform("u_worldInv"), false, painted.uvFromScreen);
+  gl.activeTexture(gl.TEXTURE0);
+  gl.bindTexture(gl.TEXTURE_2D, painted.texture);
+  gl.uniform1i(prog.uniform("u_sampler"), 0);
+  return prog;
+}
+
+// src/draw/text.ts
+var OUTLINE_MIN_SCREEN_PX = 48;
+function modelScale(m) {
+  const sx = Math.hypot(m[0], m[1]);
+  const sy = Math.hypot(m[3], m[4]);
+  return Math.sqrt(sx * sy) || 1;
+}
+function drawText(ctx, cmd) {
+  const style = resolveTextStyle(cmd.style);
+  const lineHeight = style.lineHeight;
+  const align = cmd.align ?? style.align;
+  const direction = cmd.direction ?? style.direction;
+  const maxWidth = cmd.maxWidth ?? Infinity;
+  const minScreen = ctx.textOutlineMinScreenSize ?? OUTLINE_MIN_SCREEN_PX;
+  const outlineMinSize = Number.isFinite(minScreen) ? minScreen / modelScale(ctx.state.transform) : void 0;
+  const laid = cachedLayoutRuns(cmd.runs, {
+    maxWidth,
+    alignWidth: cmd.width,
+    lineHeight,
+    align,
+    direction,
+    tabSize: style.tabSize,
+    justify: cmd.justify,
+    outlineMinSize
+  });
+  if (laid.groups.length === 0 && laid.decorations.length === 0) return;
+  const dx = cmd.x;
+  const dy = cmd.y + verticalAlignOffset(cmd.verticalAlign, cmd.height, laid.bounds.height);
+  for (const group of laid.groups) {
+    if (group.source === "outline") drawTextOutlineGroup(ctx, group, dx, dy);
+    else drawTextGroup(ctx, group, dx, dy);
+  }
+  drawTextDecorations(ctx, laid.decorations, dx, dy);
+}
+function drawTextOutlineGroup(ctx, group, dx, dy) {
+  const fill = group.fill;
+  if (fill !== null) {
+    const mesh = outlineGroupMesh(group, dx, dy);
+    if (mesh) drawOutlineMesh(ctx, fill, mesh);
+  }
+  const strokePaint = group.stroke?.paint;
+  if (!strokePaint) return;
+  const ribbon = outlineGroupStrokeMesh(group, dx, dy, ctx.state.transform);
+  if (ribbon) drawOutlineMesh(ctx, strokePaint, ribbon);
+}
+function drawOutlineMesh(ctx, fill, mesh) {
+  const paint = batchPaint(ctx, fill, false);
+  if (paint === null) return;
+  if (tryStageFill(ctx, mesh, paint)) return;
+  drawPathFillByKind(ctx, fill, ctx.meshCache.uploadTransient(mesh));
+}
+function drawTextDecorations(ctx, decorations, dx, dy) {
+  for (const d of decorations) {
+    if (glyphPaintKindOf(d.fill) !== null) {
+      drawOutlineMesh(ctx, d.fill, ruleMesh(d.x0 + dx, d.y0 + dy, d.x1 + dx, d.y1 + dy));
+      continue;
+    }
+    const [r, g, b, a] = "color" in d.fill ? resolveColor(d.fill.color) : [0, 0, 0, 1];
+    let cut;
+    for (; ; ) {
+      const staged = stageSolid(ctx, 4);
+      if (ctx.drawBatch.pushRect(
+        d.x0 + dx,
+        d.y0 + dy,
+        d.x1 - d.x0,
+        d.y1 - d.y0,
+        ctx.state.transform,
+        r,
+        g,
+        b,
+        a * (staged.foldsAlpha ? ctx.state.alpha : 1)
+      )) break;
+      cut = enterUncut(ctx);
+    }
+    if (cut !== void 0) leaveUncut(ctx, cut);
+  }
+}
+function ruleMesh(x0, y0, x1, y1) {
+  return {
+    vertices: new Float32Array([x0, y0, x1, y0, x1, y1, x0, y1]),
+    indices: new Uint32Array([0, 1, 2, 0, 2, 3])
+  };
+}
+var SYNTH_BOLD_AMOUNT = 0.08;
+function drawTextGroup(ctx, group, dx, dy) {
+  if (group.source === "canvas") {
+    if (!syncDynamicPageTexture(ctx.textureCache, group.page)) return;
+  } else {
+    if (!ensureFontTexture(group.family, group.weight, group.style, ctx.textureCache)) return;
+  }
+  if (group.quads.length === 0) return;
+  const atlasId = group.source === "canvas" ? dynamicPageTextureId(group.page) : textureCacheKey(group.family, group.weight, group.style);
+  const mode = group.source === "canvas" ? GLYPH_MODE_R8 : GLYPH_MODE_MSDF;
+  const fieldScale = glyphFieldScale(
+    group.source === "canvas" ? "canvas" : "atlas",
+    group.family,
+    group.weight,
+    group.style
+  );
+  if (!fieldScale) return;
+  const bold = group.synthetic.bold ? SYNTH_BOLD_AMOUNT : 0;
+  const tanItalic = group.synthetic.italic ? Math.tan(SYNTHETIC_ITALIC_RADIANS) : 0;
+  const paintKind = glyphPaintKindOf(group.fill);
+  if (paintKind !== null) {
+    drawPaintedGlyphs(ctx, group, dx, dy, paintKind, atlasId, mode, bold, tanItalic, fieldScale);
+    return;
+  }
+  const color = group.fill !== null && "color" in group.fill ? resolveColor(group.fill.color) : [0, 0, 0, 1];
+  const batch = ctx.drawBatch;
+  const m = ctx.state.transform;
+  let { staged, slot } = stageGlyphs(ctx, atlasId, fieldScale, bold);
+  let alpha = color[3] * (staged.foldsAlpha ? ctx.state.alpha : 1);
+  for (const q of group.quads) {
+    if (batch.wouldOverflow(4)) {
+      flushBatch(ctx);
+      ({ staged, slot } = stageGlyphs(ctx, atlasId, fieldScale, bold));
+      alpha = color[3] * (staged.foldsAlpha ? ctx.state.alpha : 1);
+    }
+    let cut;
+    while (!batch.pushGlyph(
+      q.x0 + dx,
+      q.y0 + dy,
+      q.x1 + dx,
+      q.y1 + dy,
+      q.baselineY + dy,
+      tanItalic,
+      m,
+      q.u0,
+      q.v0,
+      q.u1,
+      q.v1,
+      color[0],
+      color[1],
+      color[2],
+      alpha,
+      slot,
+      mode
+    )) {
+      cut = enterUncut(ctx);
+      ({ staged, slot } = stageGlyphs(ctx, atlasId, fieldScale, bold));
+      alpha = color[3] * (staged.foldsAlpha ? ctx.state.alpha : 1);
+    }
+    if (cut !== void 0) {
+      leaveUncut(ctx, cut);
+      ({ staged, slot } = stageGlyphs(ctx, atlasId, fieldScale, bold));
+      alpha = color[3] * (staged.foldsAlpha ? ctx.state.alpha : 1);
+    }
+  }
+}
+function glyphPaintKindOf(fill) {
+  const kind = fill?.fill ?? "solid";
+  if (kind === "pattern") return "pattern";
+  if (kind === "linear-gradient" || kind === "radial-gradient" || kind === "conic-gradient") {
+    return "gradient";
+  }
+  return kind === "solid" ? null : "texture";
+}
+var GLYPH_PAINT_ATLAS_UNIT = 1;
+function drawPaintedGlyphs(ctx, group, dx, dy, kind, atlasId, mode, bold, tanItalic, fieldScale) {
+  const prog = ctx.glyphPaintProgram?.(kind);
+  if (!prog) return;
+  flushForOwnDraw(ctx);
+  const fill = group.fill;
+  const m = ctx.state.transform;
+  let bound;
+  if (kind === "pattern") {
+    bound = bindPattern(ctx, prog, fill, BATCH_MODEL);
+  } else if (kind === "gradient") {
+    bound = bindGradient(ctx, prog, fill, BATCH_MODEL);
+  } else {
+    const painted = renderPaintToScratch(ctx, fill, glyphScreenBounds(group, dx, dy, tanItalic, m));
+    bound = painted && bindScratchPaint(ctx, prog, painted);
+  }
+  if (!bound) return;
+  const gl = ctx.gl;
+  ctx.textureCache.bind(atlasId, GLYPH_PAINT_ATLAS_UNIT);
+  gl.uniform1i(prog.uniform("u_atlas"), GLYPH_PAINT_ATLAS_UNIT);
+  gl.uniform1f(prog.uniform("u_synthBold"), bold);
+  gl.uniform2f(prog.uniform("u_fieldScale"), fieldScale[0], fieldScale[1]);
+  applyClipTest(ctx);
+  const batch = ctx.drawBatch;
+  const cut = batch.clip;
+  batch.clip = null;
+  for (const q of group.quads) {
+    if (batch.wouldOverflow(4)) drawStagedGlyphs(ctx);
+    batch.pushGlyph(
+      q.x0 + dx,
+      q.y0 + dy,
+      q.x1 + dx,
+      q.y1 + dy,
+      q.baselineY + dy,
+      tanItalic,
+      m,
+      q.u0,
+      q.v0,
+      q.u1,
+      q.v1,
+      1,
+      1,
+      1,
+      1,
+      GLYPH_PAINT_ATLAS_UNIT,
+      mode
+    );
+  }
+  drawStagedGlyphs(ctx);
+  batch.clip = cut;
+  gl.activeTexture(gl.TEXTURE0);
+  gl.bindVertexArray(null);
+}
+function drawStagedGlyphs(ctx) {
+  const batch = ctx.drawBatch;
+  if (batch.length === 0) return;
+  drawTriangles(ctx, batch.uploadAndBind(), ctx.gl.UNSIGNED_INT);
+  batch.reset();
+}
+function glyphScreenBounds(group, dx, dy, tanItalic, m) {
+  const b = { x0: Infinity, y0: Infinity, x1: -Infinity, y1: -Infinity };
+  const add = (x, y) => {
+    const sx = m[0] * x + m[3] * y + m[6];
+    const sy = m[1] * x + m[4] * y + m[7];
+    if (sx < b.x0) b.x0 = sx;
+    if (sx > b.x1) b.x1 = sx;
+    if (sy < b.y0) b.y0 = sy;
+    if (sy > b.y1) b.y1 = sy;
+  };
+  for (const q of group.quads) {
+    const x0 = q.x0 + dx, x1 = q.x1 + dx, y0 = q.y0 + dy, y1 = q.y1 + dy;
+    const base = q.baselineY + dy;
+    const top = (base - y0) * tanItalic;
+    const bottom = (base - y1) * tanItalic;
+    add(x0 + top, y0);
+    add(x1 + top, y0);
+    add(x1 + bottom, y1);
+    add(x0 + bottom, y1);
+  }
+  return b;
+}
+
+// src/DrawCommand.ts
+var SPRITE_STRIDE = 9;
+
+// src/draw/image.ts
+function drawImage(ctx, cmd) {
+  ctx.imageCache.upload(cmd.image, cmd.image);
+  const { staged, slot } = stageImage(ctx, cmd.image, cmd.sampling ?? "linear");
+  const src = cmd.source;
+  let u0 = 0, v0 = 0, u1 = 1, v1 = 1;
+  if (src) {
+    const tw = cmd.image.width, th = cmd.image.height;
+    u0 = src.x / tw;
+    u1 = (src.x + src.w) / tw;
+    v0 = src.y / th;
+    v1 = (src.y + src.h) / th;
+  }
+  if (cmd.flipX) {
+    const t = u0;
+    u0 = u1;
+    u1 = t;
+  }
+  if (cmd.flipY) {
+    const t = v0;
+    v0 = v1;
+    v1 = t;
+  }
+  if (!ctx.drawBatch.pushQuad(
+    cmd.x,
+    cmd.y,
+    cmd.w,
+    cmd.h,
+    ctx.state.transform,
+    u0,
+    v0,
+    u1,
+    v1,
+    // Group alpha rides the vertices only where it rode the solid colors too:
+    // with a real color matrix in the run it is `u_alpha`, and folding it here
+    // as well would apply it twice.
+    (cmd.opacity ?? 1) * (staged.foldsAlpha ? ctx.state.alpha : 1),
+    slot
+  )) retryUncut(ctx, cmd, void 0, drawImage);
+}
+function drawSprites(ctx, cmd) {
+  const data = cmd.sprites;
+  const count = Math.floor(data.length / SPRITE_STRIDE);
+  if (count === 0) return;
+  ctx.imageCache.upload(cmd.image, cmd.image);
+  const sampling = cmd.sampling ?? "linear";
+  let { staged, slot } = stageImage(ctx, cmd.image, sampling);
+  const batch = ctx.drawBatch;
+  const m = ctx.state.transform;
+  let groupAlpha = staged.foldsAlpha ? ctx.state.alpha : 1;
+  const tw = cmd.image.width;
+  const th = cmd.image.height;
+  for (let s = 0, i = 0; s < count; s++, i += SPRITE_STRIDE) {
+    if (batch.wouldOverflow(4)) {
+      flushBatch(ctx);
+      ({ staged, slot } = stageImage(ctx, cmd.image, sampling));
+      groupAlpha = staged.foldsAlpha ? ctx.state.alpha : 1;
+    }
+    const sx = data[i + 4], sy = data[i + 5], sw = data[i + 6], sh = data[i + 7];
+    let cut;
+    while (!batch.pushQuad(
+      data[i],
+      data[i + 1],
+      data[i + 2],
+      data[i + 3],
+      m,
+      sx / tw,
+      sy / th,
+      (sx + sw) / tw,
+      (sy + sh) / th,
+      data[i + 8] * groupAlpha,
+      slot
+    )) {
+      cut = enterUncut(ctx);
+      ({ staged, slot } = stageImage(ctx, cmd.image, sampling));
+      groupAlpha = staged.foldsAlpha ? ctx.state.alpha : 1;
+    }
+    if (cut !== void 0) {
+      leaveUncut(ctx, cut);
+      ({ staged, slot } = stageImage(ctx, cmd.image, sampling));
+      groupAlpha = staged.foldsAlpha ? ctx.state.alpha : 1;
+    }
+  }
+}
+
+// src/draw.ts
+function dispatch(ctx, cmd) {
+  switch (cmd.kind) {
+    case "group":
+      return drawGroup(ctx, cmd);
+    case "path":
+      return drawPath(ctx, cmd);
+    case "text":
+      return drawText(ctx, cmd);
+    case "image":
+      return drawImage(ctx, cmd);
+    case "sprites":
+      return drawSprites(ctx, cmd);
+    case "shader":
+      flushForOwnDraw(ctx);
+      return drawShader(ctx, cmd);
+  }
+}
+function drawGroupWithEffects(ctx, cmd, targets, width, height) {
+  const gl = ctx.gl;
+  flushForOwnDraw(ctx);
+  const parentTarget = ctx.renderTarget ?? null;
+  const parentClipDepth = ctx.clipDepth;
+  const parentClipStack = ctx.clipStack;
+  const parentBatchClip = ctx.drawBatch.clip;
+  const scissorWasOn = gl.isEnabled(gl.SCISSOR_TEST);
+  let front = targets.acquire(width, height);
+  const composited = ctx.state.pushIsolated({
+    transform: cmd.transform,
+    alpha: cmd.alpha,
+    colorMatrix: cmd.colorMatrix
+  });
+  ctx.clipDepth = 0;
+  ctx.clipStack = [];
+  ctx.drawBatch.clip = null;
+  gl.bindFramebuffer(gl.FRAMEBUFFER, front.fbo);
+  ctx.renderTarget = front;
+  gl.viewport(0, 0, width, height);
+  gl.disable(gl.SCISSOR_TEST);
+  gl.stencilMask(255);
+  gl.clear(gl.COLOR_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);
+  for (const child of cmd.children) dispatch(ctx, child);
+  flushBatch(ctx);
+  gl.disable(gl.BLEND);
+  gl.disable(gl.STENCIL_TEST);
+  for (const effect of cmd.effects) {
+    const program = ctx.ensureProgram?.(effect.program.id) ?? null;
+    if (!program) {
+      warnOnceUniform(effect.program.id, "(program)");
+      continue;
+    }
+    const back = targets.acquire(width, height);
+    gl.bindFramebuffer(gl.FRAMEBUFFER, back.fbo);
+    gl.viewport(0, 0, width, height);
+    gl.clear(gl.COLOR_BUFFER_BIT);
+    drawFullscreenQuad(
+      ctx,
+      program,
+      front.texture,
+      width,
+      height,
+      effect.uniforms,
+      void 0,
+      effect.program.id
+    );
+    targets.release(front);
+    front = back;
+  }
+  gl.enable(gl.BLEND);
+  ctx.state.pop();
+  ctx.clipDepth = parentClipDepth;
+  ctx.clipStack = parentClipStack;
+  ctx.drawBatch.clip = parentBatchClip;
+  ctx.renderTarget = parentTarget;
+  returnToRenderTarget(ctx, width, height, scissorWasOn);
+  const composite = ctx.ensureProgram?.(compositeProgramId()) ?? null;
+  if (composite) {
+    applyClipTest(ctx);
+    drawFullscreenQuad(ctx, composite, front.texture, width, height, void 0, {
+      alpha: composited.alpha,
+      colorMatrix: composited.colorMatrix
+    });
+  }
+  targets.release(front);
+}
+function drawGroup(ctx, cmd) {
+  if (cmd.effects && cmd.effects.length > 0 && ctx.effectTargets && ctx.deviceWidth && ctx.deviceHeight) {
+    if (cmd.clip) {
+      ctx.state.push({ transform: cmd.transform });
+      try {
+        enterGroupClip(ctx, cmd.clip);
+      } finally {
+        ctx.state.pop();
+      }
+    }
+    drawGroupWithEffects(ctx, cmd, ctx.effectTargets, ctx.deviceWidth, ctx.deviceHeight);
+    if (cmd.clip) leaveClip(ctx);
+    return;
+  }
+  ctx.state.push({
+    transform: cmd.transform,
+    alpha: cmd.alpha,
+    colorMatrix: cmd.colorMatrix
+  });
+  if (cmd.clip) {
+    try {
+      enterGroupClip(ctx, cmd.clip);
+    } catch (err) {
+      ctx.state.pop();
+      throw err;
+    }
+  }
+  for (const child of cmd.children) dispatch(ctx, child);
+  if (cmd.clip) leaveClip(ctx);
+  ctx.state.pop();
+}
+
+// src/shaders/customPrelude.ts
+var CUSTOM_VERT_SRC = (
+  /* glsl */
+  `#version 300 es
+in vec2 a_position;
+in vec2 a_uv;
+uniform vec4 u_bounds;
+uniform mat3 u_view;
+uniform mat3 u_proj;
+out vec2 v_uv;
+out vec2 v_screen;
+out vec2 v_world;
+
+void main() {
+  float sx = u_bounds.x + a_uv.x * u_bounds.z;
+  float sy = u_bounds.y + a_uv.y * u_bounds.w;
+  v_screen = vec2(sx, sy);
+  v_uv = a_uv;
+
+  float det = u_view[0][0] * u_view[1][1] - u_view[0][1] * u_view[1][0];
+  // A flat view has no inverse: every fragment reads the world origin, not a plausible wrong mapping.
+  float invDet = det != 0.0 ? 1.0 / det : 0.0;
+  v_world = vec2(
+    ((sx - u_view[2][0]) *  u_view[1][1] + (sy - u_view[2][1]) * -u_view[0][1]) * invDet,
+    ((sx - u_view[2][0]) * -u_view[1][0] + (sy - u_view[2][1]) *  u_view[0][0]) * invDet
+  );
+
+  vec3 clip = u_proj * vec3(sx, sy, 1.0);
+  gl_Position = vec4(clip.xy, 0.0, 1.0);
+}
+`
+);
+var CUSTOM_ATTRIBUTES = ["a_position", "a_uv"];
+var CUSTOM_KIT_UNIFORMS = ["u_bounds", "u_view", "u_proj"];
+var QUAD_VERTICES = new Float32Array([
+  -1,
+  -1,
+  0,
+  0,
+  1,
+  -1,
+  1,
+  0,
+  1,
+  1,
+  1,
+  1,
+  -1,
+  1,
+  0,
+  1
+]);
+var QUAD_INDICES = new Uint16Array([0, 1, 2, 0, 2, 3]);
+
+// src/effects/EffectTargets.ts
+var EffectTargets = class {
+  gl;
+  all = [];
+  free = [];
+  width = 0;
+  height = 0;
+  constructor(gl) {
+    this.gl = gl;
+  }
+  /** True once anything has been allocated — what a test asks instead of
+   *  reaching for the private arrays. */
+  get allocated() {
+    return this.all.length > 0;
+  }
+  /**
+   * Borrow a target sized `width` × `height` device pixels. A size change
+   * drops every pooled buffer rather than resizing in place: a borrowed one
+   * cannot be resized under its holder, and a resize is not a per-frame event.
+   */
+  acquire(width, height) {
+    if (width !== this.width || height !== this.height) {
+      this.free = [];
+      this.releaseAll();
+      this.width = width;
+      this.height = height;
+    }
+    const pooled = this.free.pop();
+    if (pooled) return pooled;
+    const made = this.create(width, height);
+    this.all.push(made);
+    return made;
+  }
+  /** Hand one back. Order does not matter — every target is interchangeable. */
+  release(target) {
+    this.free.push(target);
+  }
+  /** Take back every target still out on loan. A frame that threw inside a
+   *  group with effects never released the one it was drawing into. */
+  reclaim() {
+    if (this.free.length !== this.all.length) this.free = [...this.all];
+  }
+  /** Drop every buffer. Called on dispose and on context loss, where the
+   *  handles are already invalid and only the bookkeeping has to go. */
+  releaseAll() {
+    const gl = this.gl;
+    for (const t of this.all) {
+      gl.deleteFramebuffer(t.fbo);
+      gl.deleteTexture(t.texture);
+      gl.deleteRenderbuffer(t.stencil);
+    }
+    this.all.length = 0;
+    this.free = [];
+    this.width = 0;
+    this.height = 0;
+  }
+  create(width, height) {
+    const gl = this.gl;
+    const texture = gl.createTexture();
+    gl.bindTexture(gl.TEXTURE_2D, texture);
+    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA8, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    gl.bindTexture(gl.TEXTURE_2D, null);
+    const stencil = gl.createRenderbuffer();
+    gl.bindRenderbuffer(gl.RENDERBUFFER, stencil);
+    gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH24_STENCIL8, width, height);
+    gl.bindRenderbuffer(gl.RENDERBUFFER, null);
+    const fbo = gl.createFramebuffer();
+    gl.bindFramebuffer(gl.FRAMEBUFFER, fbo);
+    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);
+    gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_STENCIL_ATTACHMENT, gl.RENDERBUFFER, stencil);
+    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+    return { fbo, texture, stencil };
+  }
+};
+
+// src/shaders/extractUniformNames.ts
+var QUALIFIERS = /* @__PURE__ */ new Set([
+  "lowp",
+  "mediump",
+  "highp",
+  "precise",
+  "invariant",
+  "centroid",
+  "flat",
+  "smooth",
+  "noperspective"
+]);
+var IDENT = /^[A-Za-z_]\w*$/;
+var MAX_DEPTH = 16;
+function extractUniformNames(glsl) {
+  return [...scanUniforms(glsl).names];
+}
+function extractUniformArrays(glsl) {
+  return scanUniforms(glsl).arrays;
+}
+function scanUniforms(glsl) {
+  const { code, defines } = preprocess(glsl);
+  const toks = tokenize(code);
+  const consts = /* @__PURE__ */ new Map();
+  const structs = /* @__PURE__ */ new Map();
+  const out = /* @__PURE__ */ new Set();
+  const arrays = /* @__PURE__ */ new Map();
+  const resolveName = (name, depth2) => {
+    if (depth2 > MAX_DEPTH) return null;
+    let best = null;
+    for (const body of defines.get(name) ?? []) {
+      const v = evalInt(tokenize(body), (n) => resolveName(n, depth2 + 1));
+      if (v !== null && (best === null || v > best)) best = v;
+    }
+    return best ?? consts.get(name) ?? null;
+  };
+  const evalSize = (from, to) => evalInt(toks.slice(from, to), (n) => resolveName(n, 0));
+  const closer = (open) => {
+    let depth2 = 0;
+    for (let k = open; k < toks.length; k++) {
+      if (toks[k] === "(" || toks[k] === "[" || toks[k] === "{") depth2++;
+      else if (toks[k] === ")" || toks[k] === "]" || toks[k] === "}") {
+        if (--depth2 === 0) return k;
+      }
+    }
+    return toks.length;
+  };
+  const arraySuffix = (j) => {
+    if (toks[j] !== "[") return [void 0, j];
+    const end = closer(j);
+    return [evalSize(j + 1, end), end + 1];
+  };
+  const declarators = (j, typeSize) => {
+    const found = [];
+    while (j < toks.length && toks[j] !== ";" && toks[j] !== "}") {
+      const name = toks[j];
+      const [size, next] = arraySuffix(j + 1);
+      j = next;
+      if (IDENT.test(name)) found.push({ name, size: size === void 0 ? typeSize : size });
+      while (j < toks.length && toks[j] !== "," && toks[j] !== ";" && toks[j] !== "}") {
+        j = toks[j] === "(" || toks[j] === "[" || toks[j] === "{" ? closer(j) + 1 : j + 1;
+      }
+      if (toks[j] === ",") j++;
+    }
+    return [found, j];
+  };
+  const structSpecifier = (i) => {
+    let j = i + 1;
+    const name = toks[j] !== "{" ? toks[j++] : void 0;
+    const members = [];
+    if (toks[j] !== "{") return [members, j];
+    const end = closer(j);
+    j++;
+    while (j < end) {
+      while (QUALIFIERS.has(toks[j])) j++;
+      let type;
+      if (toks[j] === "struct") [type, j] = structSpecifier(j);
+      else type = toks[j++];
+      const [typeSize, afterType] = arraySuffix(j);
+      const [decls, term] = declarators(afterType, typeSize);
+      for (const d of decls) if (d.size !== null) members.push({ type, name: d.name, size: d.size ?? null });
+      j = term + 1;
+    }
+    if (name) {
+      const prior = structs.get(name) ?? [];
+      for (const m of members) if (!prior.some((p) => p.name === m.name)) prior.push(m);
+      structs.set(name, prior);
+    }
+    return [members, end + 1];
+  };
+  const expand = (name, type, size, depth2) => {
+    if (depth2 > MAX_DEPTH) return;
+    if (size !== null) {
+      if (typeof type === "string" && !structs.has(type)) {
+        const prior = arrays.get(name);
+        if (!prior || size > prior.size) arrays.set(name, { type, size });
+      }
+      for (let k = 0; k < size; k++) expand(`${name}[${k}]`, type, null, depth2 + 1);
+      return;
+    }
+    const members = typeof type === "string" ? structs.get(type) : type;
+    if (!members) {
+      out.add(name);
+      return;
+    }
+    for (const m of members) expand(`${name}.${m.name}`, m.type, m.size, depth2 + 1);
+  };
+  let depth = 0;
+  for (let i = 0; i < toks.length; i++) {
+    const t = toks[i];
+    if (t === "{") depth++;
+    else if (t === "}") depth--;
+    else if (t === "struct") i = structSpecifier(i)[1] - 1;
+    else if (depth === 0 && t === "const") {
+      let j = i + 1;
+      while (QUALIFIERS.has(toks[j])) j++;
+      if ((toks[j] === "int" || toks[j] === "uint") && IDENT.test(toks[j + 1] ?? "") && toks[j + 2] === "=") {
+        let end = j + 3;
+        while (end < toks.length && toks[end] !== ";") end++;
+        const v = evalSize(j + 3, end);
+        const prior = consts.get(toks[j + 1]);
+        if (v !== null && (prior === void 0 || v > prior)) consts.set(toks[j + 1], v);
+      }
+    } else if (depth === 0 && t === "uniform") {
+      let j = i + 1;
+      while (QUALIFIERS.has(toks[j])) j++;
+      let type;
+      if (toks[j] === "struct") {
+        [type, j] = structSpecifier(j);
+      } else if (toks[j + 1] === "{") {
+        j = closer(j + 1) + 1;
+        while (j < toks.length && toks[j] !== ";") j++;
+        i = j;
+        continue;
+      } else {
+        type = toks[j++];
+      }
+      const [typeSize, afterType] = arraySuffix(j);
+      const [decls, term] = declarators(afterType, typeSize);
+      for (const d of decls) if (d.size !== null) expand(d.name, type, d.size ?? null, 0);
+      i = term;
+    }
+  }
+  return { names: out, arrays };
+}
+function preprocess(glsl) {
+  const spliced = glsl.replace(/\\\r?\n/g, "");
+  let stripped = "";
+  for (let k = 0; k < spliced.length; k++) {
+    if (spliced[k] === "/" && spliced[k + 1] === "/") {
+      while (k < spliced.length && spliced[k] !== "\n") k++;
+      stripped += "\n";
+    } else if (spliced[k] === "/" && spliced[k + 1] === "*") {
+      const end = spliced.indexOf("*/", k + 2);
+      k = end < 0 ? spliced.length : end + 1;
+      stripped += " ";
+    } else {
+      stripped += spliced[k];
+    }
+  }
+  const defines = /* @__PURE__ */ new Map();
+  const lines = stripped.split("\n").map((line) => {
+    if (!/^\s*#/.test(line)) return line;
+    const def = /^\s*#\s*define\s+([A-Za-z_]\w*)(\(?)(.*)$/.exec(line);
+    if (def && !def[2]) defines.set(def[1], [...defines.get(def[1]) ?? [], def[3].trim()]);
+    return "";
+  });
+  return { code: lines.join("\n"), defines };
+}
+function tokenize(src) {
+  return src.match(/[A-Za-z_]\w*|\d[\w.]*|\S/g) ?? [];
+}
+function intLiteral(tok) {
+  const m = /^(?:0[xX]([0-9a-fA-F]+)|(0[0-7]*)|([1-9]\d*))[uU]?$/.exec(tok);
+  if (!m) return null;
+  if (m[1] !== void 0) return parseInt(m[1], 16);
+  if (m[2] !== void 0) return parseInt(m[2], 8);
+  return parseInt(m[3], 10);
+}
+function evalInt(toks, lookup) {
+  let p = 0;
+  const primary = () => {
+    const t = toks[p++];
+    if (t === "(") {
+      const v2 = sum();
+      return toks[p++] === ")" ? v2 : null;
+    }
+    if (t === "-") {
+      const v2 = primary();
+      return v2 === null ? null : -v2;
+    }
+    if (t === "+") return primary();
+    if (t === void 0) return null;
+    return intLiteral(t) ?? (IDENT.test(t) ? lookup(t) : null);
+  };
+  const product = () => {
+    let v2 = primary();
+    while (v2 !== null && (toks[p] === "*" || toks[p] === "/" || toks[p] === "%")) {
+      const op = toks[p++];
+      const r = primary();
+      if (r === null || op !== "*" && r === 0) return null;
+      v2 = op === "*" ? v2 * r : op === "/" ? Math.trunc(v2 / r) : v2 % r;
+    }
+    return v2;
+  };
+  const sum = () => {
+    let v2 = product();
+    while (v2 !== null && (toks[p] === "+" || toks[p] === "-")) {
+      const op = toks[p++];
+      const r = product();
+      if (r === null) return null;
+      v2 = op === "+" ? v2 + r : v2 - r;
+    }
+    return v2;
+  };
+  const v = sum();
+  return p === toks.length && v !== null && v >= 0 ? v : null;
+}
+
+// src/WeaselRenderer.ts
+function customUniformNames(vertSrc, fragSrc2) {
+  return [...CUSTOM_KIT_UNIFORMS, ...extractUniformNames(vertSrc), ...extractUniformNames(fragSrc2)];
+}
+function compileCustomProgram(gl, src) {
+  const vertSrc = src.vert === "" ? CUSTOM_VERT_SRC : src.vert;
+  const program = new ShaderProgram(gl, vertSrc, src.frag);
+  program.lookupUniforms(customUniformNames(vertSrc, src.frag));
+  program.lookupUniformArrays(new Map([...extractUniformArrays(vertSrc), ...extractUniformArrays(src.frag)]));
+  program.lookupAttributes(CUSTOM_ATTRIBUTES);
+  return program;
+}
+function now() {
+  return typeof performance !== "undefined" ? performance.now() : Date.now();
+}
+var GLYPH_PAINT_SOURCES = {
+  pattern: [GLYPH_PATTERN_FRAG_SRC, GLYPH_PATTERN_UNIFORMS],
+  gradient: [GLYPH_GRAD_FRAG_SRC, GLYPH_GRAD_UNIFORMS],
+  texture: [GLYPH_TEXTURE_FRAG_SRC, GLYPH_TEXTURE_UNIFORMS]
+};
+var WeaselRenderer = class {
+  gl;
+  stats = { drawCalls: 0, ms: 0, spans: [] };
+  pathFill;
+  pathFillVColor;
+  batchFill;
+  gradFill;
+  patternFill;
+  /** Compiled on first use: only atlas text under a texture paint needs one. */
+  glyphPaintPrograms = /* @__PURE__ */ new Map();
+  meshCache;
+  textureCache;
+  imageCache;
+  gradRamps;
+  programRegistry = /* @__PURE__ */ new Map();
+  /** The source each compiled custom program was built from — or, after a
+   *  failed recompile, the source that failed, so it is not retried every frame. */
+  programSources = /* @__PURE__ */ new Map();
+  quadVbo = null;
+  quadIbo = null;
+  drawBatch;
+  /** 1x1 white, so a batch flush sampling no image still samples something —
+   *  see `shaders/batchFill.ts`. */
+  whiteTexture = null;
+  groupState = new GroupState();
+  widthCss;
+  heightCss;
+  dpr;
+  canvas = null;
+  /** Where context loss is announced: the context's own canvas, which the
+   *  renderer need not own the size of. */
+  lossTarget = null;
+  target = null;
+  /** Offscreen buffers for group effects. Allocates nothing until a group
+   *  with effects asks, so a canvas without them pays no memory. */
+  effectTargets;
+  paintScratch;
+  imageMinification;
+  flattenTolerance;
+  bakeBudget;
+  textOutlineMinScreenSize;
+  contextLost = false;
+  boundOnLost = (e) => this.onContextLost(e);
+  boundOnRestored = () => this.onContextRestored();
+  /** True after `dispose()`. A disposed renderer ignores further `render()`
+   *  calls and `registerProgram()` calls. */
+  disposed = false;
+  /** What registered paint kinds hang their GPU state on. One per context
+   *  generation: a restore releases it and opens the next. */
+  paintResources = createPaintResources();
+  constructor(opts) {
+    if (!opts.gl && !opts.canvas) {
+      throw new Error("WeaselRenderer requires either gl or canvas");
+    }
+    const gl = opts.gl ?? opts.canvas.getContext("webgl2", { stencil: true });
+    if (!gl) throw new Error("WeaselRenderer: WebGL2 not available");
+    this.gl = gl;
+    this.effectTargets = new EffectTargets(this.gl);
+    this.paintScratch = new PaintScratch(this.gl);
+    const attrs = typeof this.gl.getContextAttributes === "function" ? this.gl.getContextAttributes() : null;
+    if (attrs && attrs.stencil === false) {
+      throw new Error(
+        "WeaselRenderer: the supplied WebGL2 context has no stencil buffer. Create it with { stencil: true } \u2014 clips and even-odd fills need one."
+      );
+    }
+    this.widthCss = opts.width;
+    this.heightCss = opts.height;
+    this.dpr = opts.dpr;
+    this.imageMinification = opts.imageMinification ?? "linear";
+    this.flattenTolerance = opts.flattenTolerance;
+    this.bakeBudget = opts.bakeBudget ?? DEFAULT_BAKE_BUDGET;
+    this.textOutlineMinScreenSize = opts.textOutlineMinScreenSize ?? OUTLINE_MIN_SCREEN_PX;
+    this.canvas = opts.canvas ?? null;
+    if (this.canvas) {
+      this.canvas.width = Math.round(opts.width * opts.dpr);
+      this.canvas.height = Math.round(opts.height * opts.dpr);
+      if (this.canvas.style) {
+        this.canvas.style.width = `${opts.width}px`;
+        this.canvas.style.height = `${opts.height}px`;
+      }
+    }
+    const lossTarget = this.canvas ?? this.gl.canvas ?? null;
+    if (lossTarget && typeof lossTarget.addEventListener === "function") {
+      this.lossTarget = lossTarget;
+      this.lossTarget.addEventListener("webglcontextlost", this.boundOnLost);
+      this.lossTarget.addEventListener("webglcontextrestored", this.boundOnRestored);
+    }
+    this.applyGlState();
+    this.applyTarget();
+    this.pathFill = new ShaderProgram(this.gl, VERT_SRC, FRAG_SRC);
+    this.pathFill.lookupUniforms(PATH_FILL_UNIFORMS);
+    this.pathFill.lookupAttributes(PATH_FILL_ATTRIBUTES);
+    this.pathFillVColor = new ShaderProgram(this.gl, VCOLOR_VERT_SRC, VCOLOR_FRAG_SRC);
+    this.pathFillVColor.lookupUniforms(PATH_FILL_UNIFORMS);
+    this.pathFillVColor.lookupAttributes(PATH_FILL_VCOLOR_ATTRIBUTES);
+    this.batchFill = new ShaderProgram(this.gl, BATCH_VERT_SRC, BATCH_FRAG_SRC);
+    this.batchFill.lookupUniforms(BATCH_FILL_UNIFORMS);
+    this.batchFill.lookupAttributes(BATCH_FILL_ATTRIBUTES);
+    this.gradFill = new ShaderProgram(this.gl, GRAD_VERT_SRC, GRAD_FRAG_SRC);
+    this.gradFill.lookupUniforms(GRAD_FILL_UNIFORMS);
+    this.gradFill.lookupAttributes(GRAD_FILL_ATTRIBUTES);
+    this.patternFill = new ShaderProgram(this.gl, PATTERN_VERT_SRC, PATTERN_FRAG_SRC);
+    this.patternFill.lookupUniforms(PATTERN_FILL_UNIFORMS);
+    this.patternFill.lookupAttributes(PATTERN_FILL_ATTRIBUTES);
+    this.meshCache = new GLMeshCache(this.gl);
+    this.textureCache = new GLTextureCache(this.gl);
+    this.imageCache = new GLImageCache(this.gl, this.imageMinification);
+    this.gradRamps = new GradientRampAtlas(this.gl);
+    this.uploadQuadGeometry();
+    this.drawBatch = new DrawBatch(this.gl, this.batchFill);
+    this.whiteTexture = createWhiteTexture(this.gl);
+  }
+  uploadQuadGeometry() {
+    const gl = this.gl;
+    this.quadVbo = gl.createBuffer();
+    this.quadIbo = gl.createBuffer();
+    if (!this.quadVbo || !this.quadIbo) {
+      throw new Error("WeaselRenderer: failed to create quad geometry buffers");
+    }
+    gl.bindBuffer(gl.ARRAY_BUFFER, this.quadVbo);
+    gl.bufferData(gl.ARRAY_BUFFER, QUAD_VERTICES, gl.STATIC_DRAW);
+    gl.bindBuffer(gl.ARRAY_BUFFER, null);
+    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.quadIbo);
+    gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, QUAD_INDICES, gl.STATIC_DRAW);
+    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
+  }
+  /**
+   * Compile a consumer-registered shader program against this renderer's GL context.
+   *
+   * Call once per renderer after the module-level `registerProgram()`.
+   * Throws `ShaderCompileError` if compilation fails.
+   *
+   * In dev mode, calling again with the same handle replaces the compiled program.
+   *
+   * @experimental
+   */
+  registerProgram(handle) {
+    if (this.disposed) return;
+    const src = getProgramSource(handle.id);
+    if (!src) {
+      throw new Error(
+        `WeaselRenderer.registerProgram: program "${handle.id}" not found in source registry. Call the module-level registerProgram() first.`
+      );
+    }
+    this.installProgram(handle.id, src, compileCustomProgram(this.gl, src));
+  }
+  installProgram(id, src, program) {
+    const previous = this.programRegistry.get(id);
+    if (previous) this.gl.deleteProgram(previous.handle);
+    this.programRegistry.set(id, program);
+    this.programSources.set(id, src);
+  }
+  /** Recompile every program whose module-level source was re-registered
+   *  since it was compiled. A source that fails keeps the old program drawing. */
+  refreshPrograms() {
+    for (const [id, compiled] of this.programSources) {
+      const src = getProgramSource(id);
+      if (!src || src === compiled) continue;
+      if (src.vert === compiled.vert && src.frag === compiled.frag) {
+        this.programSources.set(id, src);
+        continue;
+      }
+      try {
+        this.installProgram(id, src, compileCustomProgram(this.gl, src));
+      } catch (e) {
+        this.programSources.set(id, src);
+        console.error(`weasel: failed to recompile re-registered program "${id}"; still drawing the previous one:`, e);
+      }
+    }
+  }
+  /**
+   * The compiled program for `id`, compiling it against this context on first
+   * use. Unlike {@link registerProgram} this neither throws on a missing
+   * source nor on a compile failure: a paint kind asking for a program it
+   * never registered must decline the paint, not take down the frame.
+   */
+  ensureProgram(id) {
+    const existing = this.programRegistry.get(id);
+    if (existing) return existing;
+    if (this.disposed || !getProgramSource(id)) return null;
+    try {
+      this.registerProgram({ id });
+    } catch (e) {
+      console.error(`weasel: failed to compile paint program "${id}":`, e);
+      return null;
+    }
+    return this.programRegistry.get(id) ?? null;
+  }
+  glyphPaintProgram(kind) {
+    const existing = this.glyphPaintPrograms.get(kind);
+    if (existing) return existing;
+    const [frag, uniforms] = GLYPH_PAINT_SOURCES[kind];
+    const program = new ShaderProgram(this.gl, GLYPH_PAINT_VERT_SRC, frag);
+    program.lookupUniforms(uniforms);
+    program.lookupAttributes(GLYPH_PAINT_ATTRIBUTES);
+    this.glyphPaintPrograms.set(kind, program);
+    return program;
+  }
+  /** The blend, depth, cull, clear-color, color-mask, VAO, and unpack-flip
+   *  state every frame assumes.
+   *  Applied per `render()` rather than once at construction because a
+   *  co-tenant sharing this context moves all of it between our frames. */
+  applyGlState() {
+    const gl = this.gl;
+    gl.enable(gl.BLEND);
+    gl.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
+    gl.disable(gl.DEPTH_TEST);
+    gl.disable(gl.CULL_FACE);
+    gl.clearColor(0, 0, 0, 0);
+    gl.colorMask(true, true, true, true);
+    gl.bindVertexArray(null);
+    gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
+  }
+  /** Viewport and scissor for this frame. Re-applied inside `render()` because
+   *  a co-tenant on the same context moves both between our frames. */
+  /** This renderer's rect in device pixels, top-left origin. A tile rounds its
+   *  edges rather than its size, so two that share a CSS edge share a device one. */
+  deviceRect() {
+    const ox = this.target?.origin.x ?? 0;
+    const oy = this.target?.origin.y ?? 0;
+    const x = Math.round(ox * this.dpr);
+    const y = Math.round(oy * this.dpr);
+    return {
+      x,
+      y,
+      width: Math.round((ox + this.widthCss) * this.dpr) - x,
+      height: Math.round((oy + this.heightCss) * this.dpr) - y
+    };
+  }
+  applyTarget() {
+    const gl = this.gl;
+    const { x, y, width, height } = this.deviceRect();
+    if (!this.target) {
+      gl.disable(gl.SCISSOR_TEST);
+      gl.viewport(0, 0, width, height);
+      return;
+    }
+    const glY = gl.drawingBufferHeight - y - height;
+    gl.viewport(x, glY, width, height);
+    gl.scissor(x, glY, width, height);
+    gl.enable(gl.SCISSOR_TEST);
+  }
+  /** Confine this renderer to a rect of its drawing buffer, or pass null to
+   *  give it the whole buffer back. Takes effect from the next `render()`. */
+  setTarget(target) {
+    this.target = target;
+    this.applyTarget();
+  }
+  getTarget() {
+    return this.target;
+  }
+  isContextLost() {
+    return this.contextLost;
+  }
+  onContextLost(e) {
+    e.preventDefault();
+    this.contextLost = true;
+  }
+  onContextRestored() {
+    this.contextLost = false;
+    this.applyGlState();
+    this.applyTarget();
+    this.effectTargets.releaseAll();
+    this.paintScratch.release();
+    this.paintResources.release();
+    this.paintResources = createPaintResources();
+    this.pathFill = new ShaderProgram(this.gl, VERT_SRC, FRAG_SRC);
+    this.pathFill.lookupUniforms(PATH_FILL_UNIFORMS);
+    this.pathFill.lookupAttributes(PATH_FILL_ATTRIBUTES);
+    this.pathFillVColor = new ShaderProgram(this.gl, VCOLOR_VERT_SRC, VCOLOR_FRAG_SRC);
+    this.pathFillVColor.lookupUniforms(PATH_FILL_UNIFORMS);
+    this.pathFillVColor.lookupAttributes(PATH_FILL_VCOLOR_ATTRIBUTES);
+    this.batchFill = new ShaderProgram(this.gl, BATCH_VERT_SRC, BATCH_FRAG_SRC);
+    this.batchFill.lookupUniforms(BATCH_FILL_UNIFORMS);
+    this.batchFill.lookupAttributes(BATCH_FILL_ATTRIBUTES);
+    this.gradFill = new ShaderProgram(this.gl, GRAD_VERT_SRC, GRAD_FRAG_SRC);
+    this.gradFill.lookupUniforms(GRAD_FILL_UNIFORMS);
+    this.gradFill.lookupAttributes(GRAD_FILL_ATTRIBUTES);
+    this.patternFill = new ShaderProgram(this.gl, PATTERN_VERT_SRC, PATTERN_FRAG_SRC);
+    this.patternFill.lookupUniforms(PATTERN_FILL_UNIFORMS);
+    this.patternFill.lookupAttributes(PATTERN_FILL_ATTRIBUTES);
+    this.glyphPaintPrograms.clear();
+    this.meshCache = new GLMeshCache(this.gl);
+    this.textureCache = new GLTextureCache(this.gl);
+    this.imageCache.abandon();
+    this.imageCache = new GLImageCache(this.gl, this.imageMinification);
+    this.gradRamps = new GradientRampAtlas(this.gl);
+    markAllFontsNotUploaded();
+    this.uploadQuadGeometry();
+    this.drawBatch = new DrawBatch(this.gl, this.batchFill);
+    this.whiteTexture = createWhiteTexture(this.gl);
+    for (const id of this.programRegistry.keys()) {
+      const src = getProgramSource(id);
+      if (!src) continue;
+      try {
+        this.programRegistry.set(id, compileCustomProgram(this.gl, src));
+        this.programSources.set(id, src);
+      } catch (e) {
+        console.error(`weasel: failed to recompile program "${id}" after context restore:`, e);
+      }
+    }
+  }
+  /** Free every GL resource this renderer created and detach its
+   *  context-loss listeners. Idempotent.
+   *
+   *  That covers the built-in and consumer-registered programs (their shaders
+   *  go with them), the shared quad geometry, the batch, the effect targets,
+   *  and every cache: atlas and gradient-ramp textures, bitmap and pattern
+   *  textures, and meshes — transient, persistent, and those whose Path was
+   *  already collected. The context itself is left alone, so a caller-owned
+   *  context can host renderer after renderer without accumulating anything.
+   *
+   *  A disposed renderer ignores further `render()` and `registerProgram()`
+   *  calls. */
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    const gl = this.gl;
+    if (this.lossTarget) {
+      this.lossTarget.removeEventListener("webglcontextlost", this.boundOnLost);
+      this.lossTarget.removeEventListener("webglcontextrestored", this.boundOnRestored);
+    }
+    this.meshCache.dispose();
+    this.paintResources.release();
+    for (const prog of [
+      this.pathFill,
+      this.pathFillVColor,
+      this.batchFill,
+      this.gradFill,
+      this.patternFill,
+      ...this.glyphPaintPrograms.values()
+    ]) {
+      gl.deleteProgram(prog.handle);
+    }
+    this.glyphPaintPrograms.clear();
+    for (const prog of this.programRegistry.values()) {
+      gl.deleteProgram(prog.handle);
+    }
+    this.programRegistry.clear();
+    this.programSources.clear();
+    this.textureCache.free();
+    this.imageCache.dispose();
+    this.gradRamps.free();
+    if (this.quadVbo) gl.deleteBuffer(this.quadVbo);
+    if (this.quadIbo) gl.deleteBuffer(this.quadIbo);
+    this.drawBatch.dispose();
+    if (this.whiteTexture) gl.deleteTexture(this.whiteTexture);
+    this.whiteTexture = null;
+    this.effectTargets.releaseAll();
+    this.paintScratch.release();
+  }
+  /**
+   * Draw one frame.
+   *
+   * `viewMatrix` is the frame's world→screen transform. It is only consulted
+   * by `units: 'world'` gradients, which fall back to screen space without
+   * it — every other command carries its own transform in the stream, so
+   * callers with no view concept can keep calling `render(commands)`.
+   */
+  render(commands, viewMatrix, opts) {
+    if (this.contextLost || this.disposed) return;
+    const t0 = now();
+    const counters = { drawCalls: 0 };
+    const spanStats = [];
+    this.stats = { drawCalls: 0, ms: 0, spans: spanStats };
+    const gl = this.gl;
+    this.meshCache.drainPendingDeletes();
+    this.imageCache.drainPendingDeletes();
+    this.textureCache.sweep(textureRegistry);
+    this.refreshPrograms();
+    resetBakeBudget(this.bakeBudget);
+    this.groupState.reset();
+    this.drawBatch.reset();
+    this.effectTargets.reclaim();
+    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+    this.applyGlState();
+    this.applyTarget();
+    if (this.target?.clear !== false) {
+      gl.stencilMask(255);
+      gl.clear(gl.COLOR_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);
+    }
+    const device = this.deviceRect();
+    const ctx = {
+      gl,
+      pathFill: this.pathFill,
+      pathFillVColor: this.pathFillVColor,
+      batchFill: this.batchFill,
+      gradFill: this.gradFill,
+      patternFill: this.patternFill,
+      meshCache: this.meshCache,
+      textureCache: this.textureCache,
+      imageCache: this.imageCache,
+      gradRamps: this.gradRamps,
+      programRegistry: this.programRegistry,
+      ensureProgram: (id) => this.ensureProgram(id),
+      glyphPaintProgram: (kind) => this.glyphPaintProgram(kind),
+      quadVbo: this.quadVbo,
+      quadIbo: this.quadIbo,
+      drawBatch: this.drawBatch,
+      whiteTexture: this.whiteTexture,
+      state: this.groupState,
+      widthCss: this.widthCss,
+      heightCss: this.heightCss,
+      clipDepth: 0,
+      clipStack: [],
+      flattenTolerance: this.flattenTolerance,
+      textOutlineMinScreenSize: this.textOutlineMinScreenSize,
+      viewMatrix,
+      effectTargets: this.effectTargets,
+      paintScratch: this.paintScratch,
+      renderTarget: null,
+      deviceWidth: device.width,
+      deviceHeight: device.height,
+      restoreTargetRect: () => this.applyTarget(),
+      paintResources: this.paintResources,
+      stats: counters
+    };
+    this.drawBatch.clip = null;
+    const spans = opts?.spans ?? [];
+    let next = 0;
+    for (let si = 0; si < spans.length; si++) {
+      const span = spans[si];
+      for (; next < span.start; next++) dispatch(ctx, commands[next]);
+      const drawsBefore = counters.drawCalls;
+      const spanT0 = now();
+      for (; next < span.end; next++) dispatch(ctx, commands[next]);
+      if (si === spans.length - 1 && next >= commands.length) flushBatch(ctx);
+      spanStats.push({ id: span.id, drawCalls: counters.drawCalls - drawsBefore, ms: now() - spanT0 });
+    }
+    for (; next < commands.length; next++) dispatch(ctx, commands[next]);
+    flushBatch(ctx);
+    this.meshCache.freeTransient();
+    this.stats.drawCalls = counters.drawCalls;
+    this.stats.ms = now() - t0;
+  }
+  /** What the last `render()` cost: GL draw calls issued and CPU milliseconds
+   *  spent issuing them, in total and per requested span. GPU time is not
+   *  measured; the GPU runs asynchronously. */
+  lastFrameStats() {
+    return this.stats;
+  }
+  /** Change the curve-flattening tolerance after construction. `undefined`
+   *  restores the cached `DEFAULT_FLATTEN_TOLERANCE` route. */
+  setFlattenTolerance(tolerance) {
+    this.flattenTolerance = tolerance;
+  }
+  resize(dims) {
+    this.widthCss = dims.width;
+    this.heightCss = dims.height;
+    this.dpr = dims.dpr;
+    if (this.canvas) {
+      this.canvas.width = Math.round(dims.width * dims.dpr);
+      this.canvas.height = Math.round(dims.height * dims.dpr);
+      if (this.canvas.style) {
+        this.canvas.style.width = `${dims.width}px`;
+        this.canvas.style.height = `${dims.height}px`;
+      }
+    }
+    this.applyTarget();
+  }
+  /** @internal */
+  _gl() {
+    return this.gl;
+  }
+  /** @internal */
+  _pathFill() {
+    return this.pathFill;
+  }
+  /** @internal */
+  _pathFillVColor() {
+    return this.pathFillVColor;
+  }
+  /** @internal */
+  _drawBatch() {
+    return this.drawBatch;
+  }
+  /** @internal */
+  _batchFill() {
+    return this.batchFill;
+  }
+  /** @internal */
+  _gradFill() {
+    return this.gradFill;
+  }
+  /** @internal */
+  _patternFill() {
+    return this.patternFill;
+  }
+  /** @internal */
+  _meshCache() {
+    return this.meshCache;
+  }
+  /** @internal */
+  _textureCache() {
+    return this.textureCache;
+  }
+  /** @internal */
+  _imageCache() {
+    return this.imageCache;
+  }
+  /** @internal */
+  _gradRamps() {
+    return this.gradRamps;
+  }
+  /** @internal */
+  _groupState() {
+    return this.groupState;
+  }
+  /** @internal */
+  _widthCss() {
+    return this.widthCss;
+  }
+  /** @internal */
+  _heightCss() {
+    return this.heightCss;
+  }
+  /** @internal */
+  _dpr() {
+    return this.dpr;
+  }
+};
+function createWhiteTexture(gl) {
+  const tex = gl.createTexture();
+  if (!tex) return null;
+  gl.bindTexture(gl.TEXTURE_2D, tex);
+  gl.texImage2D(
+    gl.TEXTURE_2D,
+    0,
+    gl.RGBA,
+    1,
+    1,
+    0,
+    gl.RGBA,
+    gl.UNSIGNED_BYTE,
+    new Uint8Array([255, 255, 255, 255])
+  );
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+  gl.bindTexture(gl.TEXTURE_2D, null);
+  return tex;
+}
+
+// src/spriteSheet.ts
+function frameRect(sheet, index) {
+  const { frameWidth, frameHeight, columns } = sheet;
+  const margin = sheet.margin ?? 0;
+  const spacing = sheet.spacing ?? 0;
+  const col = index % columns;
+  const row = Math.floor(index / columns);
+  return {
+    x: margin + col * (frameWidth + spacing),
+    y: margin + row * (frameHeight + spacing),
+    w: frameWidth,
+    h: frameHeight
+  };
+}
+var SLACK_PX = 1;
+var DEFAULT_MITER_LIMIT = 4;
+function cullDrawCommands(cmds, transform, rect) {
+  return cullList(cmds, transform, slackBox(rect));
+}
+function cullList(cmds, m, box) {
+  let out = null;
+  for (let i = 0; i < cmds.length; i++) {
+    const cmd = cmds[i];
+    const kept = cullOne(cmd, m, box);
+    if (kept === cmd) {
+      out?.push(cmd);
+      continue;
+    }
+    out ??= cmds.slice(0, i);
+    if (kept) out.push(kept);
+  }
+  return out ?? cmds;
+}
+function cullOne(cmd, m, box) {
+  switch (cmd.kind) {
+    case "group": {
+      if (cmd.effects && cmd.effects.length > 0) return cmd;
+      const inner = cmd.transform ? mat3.multiply(m, cmd.transform) : m;
+      const children = cullList(cmd.children, inner, box);
+      if (children === cmd.children) return cmd;
+      return children.length === 0 ? null : { ...cmd, children };
+    }
+    case "path":
+      return pathMisses(cmd.path, cmd.stroke, m, box) ? null : cmd;
+    case "image":
+      return quadMisses(cmd.x, cmd.y, cmd.x + cmd.w, cmd.y + cmd.h, m, box) ? null : cmd;
+    case "sprites":
+      return spritesMiss(cmd.sprites, m, box) ? null : cmd;
+    default:
+      return cmd;
+  }
+}
+function pathMisses(path, stroke, m, box) {
+  let minX, minY, maxX, maxY;
+  if (path.kind === "rect") {
+    minX = Math.min(path.x, path.x + path.width);
+    maxX = Math.max(path.x, path.x + path.width);
+    minY = Math.min(path.y, path.y + path.height);
+    maxY = Math.max(path.y, path.y + path.height);
+  } else if (path.kind === "polygon") {
+    const c = path.coords;
+    if (c.length < 2) return false;
+    minX = maxX = c[0];
+    minY = maxY = c[1];
+    for (let i = 2; i + 1 < c.length; i += 2) {
+      const x = c[i], y = c[i + 1];
+      if (x < minX) minX = x;
+      else if (x > maxX) maxX = x;
+      if (y < minY) minY = y;
+      else if (y > maxY) maxY = y;
+    }
+  } else {
+    return false;
+  }
+  const reach = stroke ? strokeReach(stroke, m) : 0;
+  return quadMisses(minX - reach, minY - reach, maxX + reach, maxY + reach, m, box);
+}
+function strokeReach(stroke, m) {
+  return strokeReachAt(stroke, mat3.meanScaleOf(m), mat3.minScaleOf(m));
+}
+function strokeReachAt(stroke, scale, least = scale) {
+  const at = least > 0 ? least : scale;
+  const base = resolveStrokeWidth(stroke.width ?? 1, typeof stroke.width === "object" ? at : scale);
+  let width = base;
+  if (stroke.vertexWidths) {
+    for (const v of stroke.vertexWidths) if (v > width) width = v;
+  }
+  const spike = Math.max(stroke.miterLimit ?? DEFAULT_MITER_LIMIT, Math.SQRT2);
+  const heads = markerReach(stroke);
+  return Math.max(Math.abs(width) * spike, heads.world, resolveScreenLength({ px: heads.px }, at));
+}
+function spritesMiss(sprites, m, box) {
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (let i = 0; i + SPRITE_STRIDE <= sprites.length; i += SPRITE_STRIDE) {
+    const x0 = sprites[i], y0 = sprites[i + 1];
+    const x1 = x0 + sprites[i + 2], y1 = y0 + sprites[i + 3];
+    minX = Math.min(minX, x0, x1);
+    maxX = Math.max(maxX, x0, x1);
+    minY = Math.min(minY, y0, y1);
+    maxY = Math.max(maxY, y0, y1);
+  }
+  if (minX === Infinity) return false;
+  return quadMisses(minX, minY, maxX, maxY, m, box);
+}
+function boundsMissRect(bounds, transform, rect) {
+  const x0 = Math.min(bounds.x, bounds.x + bounds.width);
+  const x1 = Math.max(bounds.x, bounds.x + bounds.width);
+  const y0 = Math.min(bounds.y, bounds.y + bounds.height);
+  const y1 = Math.max(bounds.y, bounds.y + bounds.height);
+  return quadMisses(x0, y0, x1, y1, transform, slackBox(rect));
+}
+function slackBox(rect) {
+  return {
+    minX: rect.x - SLACK_PX,
+    minY: rect.y - SLACK_PX,
+    maxX: rect.x + rect.width + SLACK_PX,
+    maxY: rect.y + rect.height + SLACK_PX
+  };
+}
+function quadMisses(x0, y0, x1, y1, m, box) {
+  const [ax, ay] = mat3.apply(m, x0, y0);
+  const [bx, by] = mat3.apply(m, x1, y0);
+  const [cx, cy] = mat3.apply(m, x1, y1);
+  const [dx, dy] = mat3.apply(m, x0, y1);
+  return Math.max(ax, bx, cx, dx) < box.minX || Math.min(ax, bx, cx, dx) > box.maxX || Math.max(ay, by, cy, dy) < box.minY || Math.min(ay, by, cy, dy) > box.maxY;
+}
+
+// src/effects/types.ts
+function registerEffect(id, frag) {
+  return registerProgram(id, EFFECT_VERT_SRC, frag);
+}
+
+// src/effects/builtins.ts
+var BLUR_FRAG = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+in vec2 v_uv;
+uniform sampler2D u_source;
+uniform vec2 u_texel;
+uniform vec2 u_direction;
+uniform float u_radius;
+out vec4 outColor;
+
+void main() {
+  // Nine taps on a Gaussian, spread across the requested radius. The weights
+  // are a normalized binomial row, so a radius of 0 collapses to a copy.
+  const float W[5] = float[5](0.2270270, 0.1945946, 0.1216216, 0.0540541, 0.0162162);
+  vec2 step = u_direction * u_texel * (u_radius / 4.0);
+  vec4 sum = texture(u_source, v_uv) * W[0];
+  for (int i = 1; i < 5; i++) {
+    vec2 off = step * float(i);
+    sum += texture(u_source, v_uv + off) * W[i];
+    sum += texture(u_source, v_uv - off) * W[i];
+  }
+  outColor = sum;
+}
+`
+);
+var VIGNETTE_FRAG = (
+  /* glsl */
+  `#version 300 es
+precision highp float;
+in vec2 v_uv;
+uniform sampler2D u_source;
+uniform float u_amount;
+uniform float u_feather;
+out vec4 outColor;
+
+void main() {
+  vec4 src = texture(u_source, v_uv);
+  float d = distance(v_uv, vec2(0.5)) * 1.41421356;
+  float shade = 1.0 - u_amount * smoothstep(1.0 - u_feather, 1.0, d);
+  // Premultiplied in, premultiplied out: scaling all four channels darkens
+  // toward transparent black, which is what a vignette over a transparent
+  // canvas should do.
+  outColor = src * shade;
+}
+`
+);
+var BLUR = registerEffect("weasel:blur", BLUR_FRAG);
+var VIGNETTE = registerEffect("weasel:vignette", VIGNETTE_FRAG);
+function blur({ radius }) {
+  return [
+    { program: BLUR, uniforms: { u_direction: [1, 0], u_radius: radius } },
+    { program: BLUR, uniforms: { u_direction: [0, 1], u_radius: radius } }
+  ];
+}
+function vignette({ amount, feather = 0.6 }) {
+  return [{ program: VIGNETTE, uniforms: { u_amount: amount, u_feather: feather } }];
+}
+function textCommandFromRuns(x, y, runs, style, maxWidth, height, verticalAlign, paint, width, scale = 1) {
+  const resolved = resolveTextStyle(style, paint, scale);
+  return {
+    kind: "text",
+    x,
+    y,
+    runs: resolveRuns(runs, resolved, scale),
+    align: resolved.align,
+    direction: resolved.direction,
+    justify: resolved.align === "justify",
+    maxWidth,
+    style: style ?? {},
+    height,
+    verticalAlign,
+    width
+  };
+}
+function textCommand(x, y, text, style, maxWidth, height, verticalAlign, paint, width, scale = 1) {
+  return textCommandFromRuns(
+    x,
+    y,
+    [{ text }],
+    style,
+    maxWidth,
+    height,
+    verticalAlign,
+    paint,
+    width,
+    scale
+  );
+}
+function textCommandFromPose(pose, scale = 1) {
+  const { runs, opts } = textPoseLayoutInput(pose, scale);
+  return {
+    kind: "text",
+    x: pose.x,
+    y: pose.y,
+    runs: runsInPoseFrame(runs, pose),
+    align: opts.align,
+    direction: opts.direction,
+    justify: opts.justify,
+    maxWidth: opts.maxWidth,
+    width: opts.alignWidth,
+    style: pose.style ?? {},
+    height: pose.height,
+    verticalAlign: pose.verticalAlign
+  };
+}
+function runsInPoseFrame(runs, box) {
+  if (runs.every((r) => isSolid(r.fill) && isSolid(r.stroke?.paint))) return runs;
+  return runs.map((r) => {
+    const fill = r.fill && commandFill(r.fill, box);
+    const paint = r.stroke?.paint && commandFill(r.stroke.paint, box);
+    return { ...r, fill, stroke: r.stroke && { ...r.stroke, paint: paint || void 0 } };
+  });
+}
+function isSolid(paint) {
+  return paint == null || (paint.fill ?? "solid") === "solid";
+}
+
+export { EFFECT_KIT_UNIFORMS, EFFECT_VERT_SRC, IDENTITY_COLOR_MATRIX, OUTLINE_MIN_SCREEN_PX, SPRITE_STRIDE, ShaderCompileError, WeaselRenderer, blur, boundsMissRect, buildGradientRamp, cullDrawCommands, frameRect, registerEffect, strokeReachAt, textCommand, textCommandFromPose, textCommandFromRuns, vignette };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map