@weasel-js/core 1.9.2 → 1.9.4

package/dist/renderer/shaders/gradFill.js.map

@@ -1 +1 @@
-{"version":3,"file":"gradFill.js","names":["GRAD_VERT_SRC","GRAD_PAINT_GLSL","GRAD_FRAG_SRC","GRAD_FILL_UNIFORMS","GRAD_FILL_ATTRIBUTES"],"sources":["../../../src/renderer/shaders/gradFill.ts"],"sourcesContent":["/**\n * GLSL ES 3.0 sources for gradient-fill paths (linear, radial, conic).\n *\n * Three gradient kinds via u_gradKind (0=linear, 1=radial, 2=conic).\n * The branch value is uniform across all fragments in one draw call — GPU\n * branch predictor handles uniform-value branches without warp divergence.\n *\n * Output convention §2: PREMULTIPLIED alpha.\n *\n * `u_ramp` is `GradientRampAtlas`'s texture, which holds every baked ramp in\n * the frame, one per row; `u_rampV` picks this fill's row.\n *\n * Step-4 limitation: u_worldInv is identity in v1 since draw.ts doesn't yet\n * receive a view matrix. Gradient coords therefore render in screen space.\n * Step 7 (port createPathLayer) wires the actual view-inverse through layers.\n */\n\nexport const GRAD_VERT_SRC = /* glsl */ `#version 300 es\nin vec2 a_position;\nuniform mat3 u_proj;\nuniform mat3 u_model;\nuniform mat3 u_worldInv;\nout vec2 v_world;\nvoid main() {\n  vec3 screen = u_model * vec3(a_position, 1.0);\n  vec3 clip   = u_proj  * vec3(screen.xy, 1.0);\n  gl_Position = vec4(clip.xy, 0.0, 1.0);\n  vec3 world = u_worldInv * vec3(screen.xy, 1.0);\n  v_world = world.xy;\n}\n`;\n\n/**\n * The gradient's color at a gradient-space point, premultiplied — the whole\n * of the fragment stage but the point it is asked about, so the glyph program\n * can mask the same paint the path program draws.\n */\nexport const GRAD_PAINT_GLSL = /* glsl */ `\nuniform sampler2D u_ramp;\nuniform float u_rampV;\nuniform float u_alpha;\nuniform mat4  u_colorMatrix;\nuniform vec4  u_colorBias;\nuniform float u_opacity;\nuniform int   u_gradKind;\nuniform vec2  u_gradP0;\nuniform vec2  u_gradDir;\nuniform float u_gradLen;\nuniform float u_gradRadius;\nuniform float u_gradAngle;\n\nconst float PI = 3.14159265358979323846;\n\nvec4 shadePaint(vec2 world) {\n  float t;\n  if (u_gradKind == 0) {\n    vec2 d = world - u_gradP0;\n    t = dot(d, u_gradDir) / max(u_gradLen, 0.0001);\n  } else if (u_gradKind == 1) {\n    t = length(world - u_gradP0) / max(u_gradRadius, 0.0001);\n  } else {\n    float a = atan(world.y - u_gradP0.y, world.x - u_gradP0.x) - u_gradAngle;\n    t = fract(a / (2.0 * PI));\n  }\n  t = clamp(t, 0.0, 1.0);\n  vec4 rampColor = texture(u_ramp, vec2(t, u_rampV));\n  // Fill opacity into the alpha channel before the matrix, which is where the\n  // batch program's vertex alpha sits. The two have to agree, since a linear\n  // gradient goes through that one and a radial through this.\n  vec4 src = vec4(rampColor.rgb, rampColor.a * u_opacity);\n  vec4 mapped = clamp(u_colorMatrix * src + u_colorBias, 0.0, 1.0);\n  float a = mapped.a * u_alpha;\n  return vec4(mapped.rgb * a, a);\n}\n`;\n\nexport const GRAD_FRAG_SRC = /* glsl */ `#version 300 es\nprecision highp float;\nin vec2 v_world;\n${GRAD_PAINT_GLSL}\nout vec4 outColor;\nvoid main() {\n  outColor = shadePaint(v_world);\n}\n`;\n\nexport const GRAD_FILL_UNIFORMS = [\n  'u_proj', 'u_model', 'u_worldInv', 'u_ramp', 'u_rampV',\n  'u_alpha', 'u_opacity', 'u_colorMatrix', 'u_colorBias',\n  'u_gradKind', 'u_gradP0', 'u_gradDir', 'u_gradLen', 'u_gradRadius', 'u_gradAngle',\n] as const;\n\nexport const GRAD_FILL_ATTRIBUTES = ['a_position'] as const;\n"],"mappings":";AAiBA,IAAaA,IAA2B,6WAoB3BC,IAA6B,uuCAuC7BC,IAA2B;;;EAGtCD,EAAgB;;;;;GAOLE,IAAqB;CAChC;CAAU;CAAW;CAAc;CAAU;CAC7C;CAAW;CAAa;CAAiB;CACzC;CAAc;CAAY;CAAa;CAAa;CAAgB;AACtE,GAEaC,IAAuB,CAAC,YAAY"}
+{"version":3,"file":"gradFill.js","names":["GRAD_VERT_SRC","GRAD_PAINT_GLSL","GRAD_FRAG_SRC","GRAD_FILL_UNIFORMS","GRAD_FILL_ATTRIBUTES"],"sources":["../../../src/renderer/shaders/gradFill.ts"],"sourcesContent":["/**\n * GLSL ES 3.0 sources for gradient-fill paths (linear, radial, conic).\n *\n * Three gradient kinds via u_gradKind (0=linear, 1=radial, 2=conic).\n * The branch value is uniform across all fragments in one draw call — GPU\n * branch predictor handles uniform-value branches without warp divergence.\n *\n * Output convention §2: PREMULTIPLIED alpha.\n *\n * `u_ramp` is `GradientRampAtlas`'s texture, which holds every baked ramp in\n * the frame, one per row; `u_rampV` picks this fill's row.\n */\n\nexport const GRAD_VERT_SRC = /* glsl */ `#version 300 es\nin vec2 a_position;\nuniform mat3 u_proj;\nuniform mat3 u_model;\nuniform vec2 u_origin;\nuniform mat3 u_worldInv;\nout vec2 v_world;\nvoid main() {\n  vec3 screen = u_model * vec3(a_position - u_origin, 1.0);\n  vec3 clip   = u_proj  * vec3(screen.xy, 1.0);\n  gl_Position = vec4(clip.xy, 0.0, 1.0);\n  vec3 world = u_worldInv * vec3(screen.xy, 1.0);\n  v_world = world.xy;\n}\n`;\n\n/**\n * The gradient's color at a gradient-space point, premultiplied — the whole\n * of the fragment stage but the point it is asked about, so the glyph program\n * can mask the same paint the path program draws.\n */\nexport const GRAD_PAINT_GLSL = /* glsl */ `\nuniform sampler2D u_ramp;\nuniform float u_rampV;\nuniform float u_alpha;\nuniform mat4  u_colorMatrix;\nuniform vec4  u_colorBias;\nuniform float u_opacity;\nuniform int   u_gradKind;\nuniform vec2  u_gradP0;\nuniform vec2  u_gradDir;\nuniform float u_gradLen;\nuniform float u_gradRadius;\nuniform float u_gradAngle;\n\nconst float PI = 3.14159265358979323846;\n\nvec4 shadePaint(vec2 world) {\n  float t;\n  if (u_gradKind == 0) {\n    vec2 d = world - u_gradP0;\n    t = dot(d, u_gradDir) / max(u_gradLen, 0.0001);\n  } else if (u_gradKind == 1) {\n    t = length(world - u_gradP0) / max(u_gradRadius, 0.0001);\n  } else {\n    float a = atan(world.y - u_gradP0.y, world.x - u_gradP0.x) - u_gradAngle;\n    t = fract(a / (2.0 * PI));\n  }\n  t = clamp(t, 0.0, 1.0);\n  vec4 rampColor = texture(u_ramp, vec2(t, u_rampV));\n  // Fill opacity into the alpha channel before the matrix, which is where the\n  // batch program's vertex alpha sits. The two have to agree, since a linear\n  // gradient goes through that one and a radial through this.\n  vec4 src = vec4(rampColor.rgb, rampColor.a * u_opacity);\n  vec4 mapped = clamp(u_colorMatrix * src + u_colorBias, 0.0, 1.0);\n  float a = mapped.a * u_alpha;\n  return vec4(mapped.rgb * a, a);\n}\n`;\n\nexport const GRAD_FRAG_SRC = /* glsl */ `#version 300 es\nprecision highp float;\nin vec2 v_world;\n${GRAD_PAINT_GLSL}\nout vec4 outColor;\nvoid main() {\n  outColor = shadePaint(v_world);\n}\n`;\n\nexport const GRAD_FILL_UNIFORMS = [\n  'u_proj', 'u_model', 'u_origin', 'u_worldInv', 'u_ramp', 'u_rampV',\n  'u_alpha', 'u_opacity', 'u_colorMatrix', 'u_colorBias',\n  'u_gradKind', 'u_gradP0', 'u_gradDir', 'u_gradLen', 'u_gradRadius', 'u_gradAngle',\n] as const;\n\nexport const GRAD_FILL_ATTRIBUTES = ['a_position'] as const;\n"],"mappings":";AAaA,IAAaA,IAA2B,gZAqB3BC,IAA6B,uuCAuC7BC,IAA2B;;;EAGtCD,EAAgB;;;;;GAOLE,IAAqB;CAChC;CAAU;CAAW;CAAY;CAAc;CAAU;CACzD;CAAW;CAAa;CAAiB;CACzC;CAAc;CAAY;CAAa;CAAa;CAAgB;AACtE,GAEaC,IAAuB,CAAC,YAAY"}

package/dist/renderer/shaders/pathFill.js

@@ -1,7 +1,8 @@
 //#region src/renderer/shaders/pathFill.ts
-var e = "#version 300 es\nin vec2 a_position;\nuniform mat3 u_proj;\nuniform mat3 u_model;\nvoid main() {\n  vec3 screen = u_model * vec3(a_position, 1.0);\n  vec3 clip = u_proj * vec3(screen.xy, 1.0);\n  gl_Position = vec4(clip.xy, 0.0, 1.0);\n}\n", t = "#version 300 es\nprecision highp float;\nuniform vec4 u_color;\nuniform float u_alpha;\nuniform mat4 u_colorMatrix;\nuniform vec4 u_colorBias;\nout vec4 outColor;\nvoid main() {\n  vec4 mapped = clamp(u_colorMatrix * u_color + u_colorBias, 0.0, 1.0);\n  float a = mapped.a * u_alpha;\n  outColor = vec4(mapped.rgb * a, a);\n}\n", n = "#version 300 es\nin vec2 a_position;\nin vec4 a_vertexColor;\nuniform mat3 u_proj;\nuniform mat3 u_model;\nout vec4 v_vertexColor;\nvoid main() {\n  vec3 screen = u_model * vec3(a_position, 1.0);\n  vec3 clip = u_proj * vec3(screen.xy, 1.0);\n  gl_Position = vec4(clip.xy, 0.0, 1.0);\n  v_vertexColor = a_vertexColor;\n}\n", r = "#version 300 es\nprecision highp float;\nin vec4 v_vertexColor;\nuniform vec4 u_color;\nuniform float u_alpha;\nuniform mat4 u_colorMatrix;\nuniform vec4 u_colorBias;\nout vec4 outColor;\nvoid main() {\n  vec4 src = u_color * v_vertexColor;\n  vec4 mapped = clamp(u_colorMatrix * src + u_colorBias, 0.0, 1.0);\n  float a = mapped.a * u_alpha;\n  outColor = vec4(mapped.rgb * a, a);\n}\n", i = [
+var e = "#version 300 es\nin vec2 a_position;\nuniform mat3 u_proj;\nuniform mat3 u_model;\nuniform vec2 u_origin;\nvoid main() {\n  vec3 screen = u_model * vec3(a_position - u_origin, 1.0);\n  vec3 clip = u_proj * vec3(screen.xy, 1.0);\n  gl_Position = vec4(clip.xy, 0.0, 1.0);\n}\n", t = "#version 300 es\nprecision highp float;\nuniform vec4 u_color;\nuniform float u_alpha;\nuniform mat4 u_colorMatrix;\nuniform vec4 u_colorBias;\nout vec4 outColor;\nvoid main() {\n  vec4 mapped = clamp(u_colorMatrix * u_color + u_colorBias, 0.0, 1.0);\n  float a = mapped.a * u_alpha;\n  outColor = vec4(mapped.rgb * a, a);\n}\n", n = "#version 300 es\nin vec2 a_position;\nin vec4 a_vertexColor;\nuniform mat3 u_proj;\nuniform mat3 u_model;\nuniform vec2 u_origin;\nout vec4 v_vertexColor;\nvoid main() {\n  vec3 screen = u_model * vec3(a_position - u_origin, 1.0);\n  vec3 clip = u_proj * vec3(screen.xy, 1.0);\n  gl_Position = vec4(clip.xy, 0.0, 1.0);\n  v_vertexColor = a_vertexColor;\n}\n", r = "#version 300 es\nprecision highp float;\nin vec4 v_vertexColor;\nuniform vec4 u_color;\nuniform float u_alpha;\nuniform mat4 u_colorMatrix;\nuniform vec4 u_colorBias;\nout vec4 outColor;\nvoid main() {\n  vec4 src = u_color * v_vertexColor;\n  vec4 mapped = clamp(u_colorMatrix * src + u_colorBias, 0.0, 1.0);\n  float a = mapped.a * u_alpha;\n  outColor = vec4(mapped.rgb * a, a);\n}\n", i = [
 	"u_proj",
 	"u_model",
+	"u_origin",
 	"u_color",
 	"u_alpha",
 	"u_colorMatrix",

package/dist/renderer/shaders/pathFill.js.map

@@ -1 +1 @@
-{"version":3,"file":"pathFill.js","names":["VERT_SRC","FRAG_SRC","VCOLOR_VERT_SRC","VCOLOR_FRAG_SRC","PATH_FILL_UNIFORMS","PATH_FILL_ATTRIBUTES","PATH_FILL_VCOLOR_ATTRIBUTES"],"sources":["../../../src/renderer/shaders/pathFill.ts"],"sourcesContent":["/**\n * GLSL ES 3.0 sources for the built-in solid-fill path shader.\n *\n * Two variants:\n *   - Flat: VERT_SRC + FRAG_SRC, uses uniform color only.\n *   - VColor: VCOLOR_VERT_SRC + VCOLOR_FRAG_SRC, multiplies a per-vertex\n *     `a_vertexColor` attribute with `u_color`.\n *\n * Both variants take `u_colorMatrix` (mat4) + `u_colorBias` (vec4); the\n * color transform is applied to the straight-alpha SRC color BEFORE\n * premultiplication. Identity matrix + zero bias = pass-through.\n *\n * Output (both variants): PREMULTIPLIED alpha.\n * Blend: caller sets `gl.blendFunc(ONE, ONE_MINUS_SRC_ALPHA)`.\n */\n\nexport const VERT_SRC = /* glsl */ `#version 300 es\nin vec2 a_position;\nuniform mat3 u_proj;\nuniform mat3 u_model;\nvoid main() {\n  vec3 screen = u_model * vec3(a_position, 1.0);\n  vec3 clip = u_proj * vec3(screen.xy, 1.0);\n  gl_Position = vec4(clip.xy, 0.0, 1.0);\n}\n`;\n\nexport const FRAG_SRC = /* glsl */ `#version 300 es\nprecision highp float;\nuniform vec4 u_color;\nuniform float u_alpha;\nuniform mat4 u_colorMatrix;\nuniform vec4 u_colorBias;\nout vec4 outColor;\nvoid main() {\n  vec4 mapped = clamp(u_colorMatrix * u_color + u_colorBias, 0.0, 1.0);\n  float a = mapped.a * u_alpha;\n  outColor = vec4(mapped.rgb * a, a);\n}\n`;\n\nexport const VCOLOR_VERT_SRC = /* glsl */ `#version 300 es\nin vec2 a_position;\nin vec4 a_vertexColor;\nuniform mat3 u_proj;\nuniform mat3 u_model;\nout vec4 v_vertexColor;\nvoid main() {\n  vec3 screen = u_model * vec3(a_position, 1.0);\n  vec3 clip = u_proj * vec3(screen.xy, 1.0);\n  gl_Position = vec4(clip.xy, 0.0, 1.0);\n  v_vertexColor = a_vertexColor;\n}\n`;\n\nexport const VCOLOR_FRAG_SRC = /* glsl */ `#version 300 es\nprecision highp float;\nin vec4 v_vertexColor;\nuniform vec4 u_color;\nuniform float u_alpha;\nuniform mat4 u_colorMatrix;\nuniform vec4 u_colorBias;\nout vec4 outColor;\nvoid main() {\n  vec4 src = u_color * v_vertexColor;\n  vec4 mapped = clamp(u_colorMatrix * src + u_colorBias, 0.0, 1.0);\n  float a = mapped.a * u_alpha;\n  outColor = vec4(mapped.rgb * a, a);\n}\n`;\n\n/** Uniforms shared between flat and vertex-color variants. */\nexport const PATH_FILL_UNIFORMS = [\n  'u_proj', 'u_model', 'u_color', 'u_alpha',\n  'u_colorMatrix', 'u_colorBias',\n] as const;\n\n/** Attributes for the flat variant. */\nexport const PATH_FILL_ATTRIBUTES = ['a_position'] as const;\n\n/** Attributes for the vertex-color variant. */\nexport const PATH_FILL_VCOLOR_ATTRIBUTES = ['a_position', 'a_vertexColor'] as const;\n"],"mappings":";AAgBA,IAAaA,IAAsB,mPAWtBC,IAAsB,2UActBC,IAA6B,sUAc7BC,IAA6B,sYAiB7BC,IAAqB;CAChC;CAAU;CAAW;CAAW;CAChC;CAAiB;AACnB,GAGaC,IAAuB,CAAC,YAAY,GAGpCC,IAA8B,CAAC,cAAc,eAAe"}
+{"version":3,"file":"pathFill.js","names":["VERT_SRC","FRAG_SRC","VCOLOR_VERT_SRC","VCOLOR_FRAG_SRC","PATH_FILL_UNIFORMS","PATH_FILL_ATTRIBUTES","PATH_FILL_VCOLOR_ATTRIBUTES"],"sources":["../../../src/renderer/shaders/pathFill.ts"],"sourcesContent":["/**\n * GLSL ES 3.0 sources for the built-in solid-fill path shader.\n *\n * Two variants:\n *   - Flat: VERT_SRC + FRAG_SRC, uses uniform color only.\n *   - VColor: VCOLOR_VERT_SRC + VCOLOR_FRAG_SRC, multiplies a per-vertex\n *     `a_vertexColor` attribute with `u_color`.\n *\n * Both variants take `u_colorMatrix` (mat4) + `u_colorBias` (vec4); the\n * color transform is applied to the straight-alpha SRC color BEFORE\n * premultiplication. Identity matrix + zero bias = pass-through.\n *\n * Output (both variants): PREMULTIPLIED alpha.\n * Blend: caller sets `gl.blendFunc(ONE, ONE_MINUS_SRC_ALPHA)`.\n */\n\nexport const VERT_SRC = /* glsl */ `#version 300 es\nin vec2 a_position;\nuniform mat3 u_proj;\nuniform mat3 u_model;\nuniform vec2 u_origin;\nvoid main() {\n  vec3 screen = u_model * vec3(a_position - u_origin, 1.0);\n  vec3 clip = u_proj * vec3(screen.xy, 1.0);\n  gl_Position = vec4(clip.xy, 0.0, 1.0);\n}\n`;\n\nexport const FRAG_SRC = /* glsl */ `#version 300 es\nprecision highp float;\nuniform vec4 u_color;\nuniform float u_alpha;\nuniform mat4 u_colorMatrix;\nuniform vec4 u_colorBias;\nout vec4 outColor;\nvoid main() {\n  vec4 mapped = clamp(u_colorMatrix * u_color + u_colorBias, 0.0, 1.0);\n  float a = mapped.a * u_alpha;\n  outColor = vec4(mapped.rgb * a, a);\n}\n`;\n\nexport const VCOLOR_VERT_SRC = /* glsl */ `#version 300 es\nin vec2 a_position;\nin vec4 a_vertexColor;\nuniform mat3 u_proj;\nuniform mat3 u_model;\nuniform vec2 u_origin;\nout vec4 v_vertexColor;\nvoid main() {\n  vec3 screen = u_model * vec3(a_position - u_origin, 1.0);\n  vec3 clip = u_proj * vec3(screen.xy, 1.0);\n  gl_Position = vec4(clip.xy, 0.0, 1.0);\n  v_vertexColor = a_vertexColor;\n}\n`;\n\nexport const VCOLOR_FRAG_SRC = /* glsl */ `#version 300 es\nprecision highp float;\nin vec4 v_vertexColor;\nuniform vec4 u_color;\nuniform float u_alpha;\nuniform mat4 u_colorMatrix;\nuniform vec4 u_colorBias;\nout vec4 outColor;\nvoid main() {\n  vec4 src = u_color * v_vertexColor;\n  vec4 mapped = clamp(u_colorMatrix * src + u_colorBias, 0.0, 1.0);\n  float a = mapped.a * u_alpha;\n  outColor = vec4(mapped.rgb * a, a);\n}\n`;\n\n/** Uniforms shared between flat and vertex-color variants. */\nexport const PATH_FILL_UNIFORMS = [\n  'u_proj', 'u_model', 'u_origin', 'u_color', 'u_alpha',\n  'u_colorMatrix', 'u_colorBias',\n] as const;\n\n/** Attributes for the flat variant. */\nexport const PATH_FILL_ATTRIBUTES = ['a_position'] as const;\n\n/** Attributes for the vertex-color variant. */\nexport const PATH_FILL_VCOLOR_ATTRIBUTES = ['a_position', 'a_vertexColor'] as const;\n"],"mappings":";AAgBA,IAAaA,IAAsB,sRAYtBC,IAAsB,2UActBC,IAA6B,yWAe7BC,IAA6B,sYAiB7BC,IAAqB;CAChC;CAAU;CAAW;CAAY;CAAW;CAC5C;CAAiB;AACnB,GAGaC,IAAuB,CAAC,YAAY,GAGpCC,IAA8B,CAAC,cAAc,eAAe"}

package/dist/renderer/shaders/patternFill.js

@@ -1,5 +1,5 @@
 //#region src/renderer/shaders/patternFill.ts
-var e = "#version 300 es\nin vec2 a_position;\nuniform mat3 u_proj;\nuniform mat3 u_model;\nuniform mat3 u_worldInv;\nout vec2 v_world;\nvoid main() {\n  vec3 screen = u_model * vec3(a_position, 1.0);\n  vec3 clip   = u_proj  * vec3(screen.xy, 1.0);\n  gl_Position = vec4(clip.xy, 0.0, 1.0);\n  vec3 world = u_worldInv * vec3(screen.xy, 1.0);\n  v_world = world.xy;\n}\n", t = "\nuniform sampler2D u_sampler;\nuniform vec2  u_tileSize;\nuniform float u_opacity;\nuniform float u_alpha;\nuniform mat4  u_colorMatrix;\nuniform vec4  u_colorBias;\nvec4 shadePaint(vec2 world) {\n  vec2 uv = world / max(u_tileSize, vec2(0.0001));\n  vec4 texel = texture(u_sampler, uv);\n  vec4 mapped = clamp(u_colorMatrix * texel + u_colorBias, 0.0, 1.0);\n  float a = mapped.a * u_opacity * u_alpha;\n  return vec4(mapped.rgb * a, a);\n}\n", n = `#version 300 es
+var e = "#version 300 es\nin vec2 a_position;\nuniform mat3 u_proj;\nuniform mat3 u_model;\nuniform vec2 u_origin;\nuniform mat3 u_worldInv;\nout vec2 v_world;\nvoid main() {\n  vec3 screen = u_model * vec3(a_position - u_origin, 1.0);\n  vec3 clip   = u_proj  * vec3(screen.xy, 1.0);\n  gl_Position = vec4(clip.xy, 0.0, 1.0);\n  vec3 world = u_worldInv * vec3(screen.xy, 1.0);\n  v_world = world.xy;\n}\n", t = "\nuniform sampler2D u_sampler;\nuniform vec2  u_tileSize;\nuniform float u_opacity;\nuniform float u_alpha;\nuniform mat4  u_colorMatrix;\nuniform vec4  u_colorBias;\nvec4 shadePaint(vec2 world) {\n  vec2 uv = world / max(u_tileSize, vec2(0.0001));\n  vec4 texel = texture(u_sampler, uv);\n  vec4 mapped = clamp(u_colorMatrix * texel + u_colorBias, 0.0, 1.0);\n  float a = mapped.a * u_opacity * u_alpha;\n  return vec4(mapped.rgb * a, a);\n}\n", n = `#version 300 es
 precision highp float;
 in vec2 v_world;
 ${t}
@@ -10,6 +10,7 @@ void main() {
 `, r = [
 	"u_proj",
 	"u_model",
+	"u_origin",
 	"u_worldInv",
 	"u_sampler",
 	"u_tileSize",

package/dist/renderer/shaders/patternFill.js.map

@@ -1 +1 @@
-{"version":3,"file":"patternFill.js","names":["PATTERN_VERT_SRC","PATTERN_PAINT_GLSL","PATTERN_FRAG_SRC","PATTERN_FILL_UNIFORMS","PATTERN_FILL_ATTRIBUTES"],"sources":["../../../src/renderer/shaders/patternFill.ts"],"sourcesContent":["/**\n * GLSL ES 3.0 sources for pattern-fill paths.\n *\n * The vertex stage is `gradFill`'s: a path fill mesh carries `a_position`\n * only, so tile-space coordinates are recovered per fragment from the\n * screen position via `u_worldInv` rather than read from a UV attribute.\n * That matrix also carries the tile's origin and transform\n * (`patternTileSpace`). `u_tileSize` then converts to texture space, and\n * `REPEAT` wrapping (set at upload) tiles the result.\n *\n * Output convention §2: PREMULTIPLIED alpha.\n */\n\nexport const PATTERN_VERT_SRC = /* glsl */ `#version 300 es\nin vec2 a_position;\nuniform mat3 u_proj;\nuniform mat3 u_model;\nuniform mat3 u_worldInv;\nout vec2 v_world;\nvoid main() {\n  vec3 screen = u_model * vec3(a_position, 1.0);\n  vec3 clip   = u_proj  * vec3(screen.xy, 1.0);\n  gl_Position = vec4(clip.xy, 0.0, 1.0);\n  vec3 world = u_worldInv * vec3(screen.xy, 1.0);\n  v_world = world.xy;\n}\n`;\n\n/**\n * The pattern's color at a paint-space point, premultiplied — the whole of the\n * fragment stage but the point it is asked about, so the glyph program can\n * mask the same paint the path program draws.\n */\nexport const PATTERN_PAINT_GLSL = /* glsl */ `\nuniform sampler2D u_sampler;\nuniform vec2  u_tileSize;\nuniform float u_opacity;\nuniform float u_alpha;\nuniform mat4  u_colorMatrix;\nuniform vec4  u_colorBias;\nvec4 shadePaint(vec2 world) {\n  vec2 uv = world / max(u_tileSize, vec2(0.0001));\n  vec4 texel = texture(u_sampler, uv);\n  vec4 mapped = clamp(u_colorMatrix * texel + u_colorBias, 0.0, 1.0);\n  float a = mapped.a * u_opacity * u_alpha;\n  return vec4(mapped.rgb * a, a);\n}\n`;\n\nexport const PATTERN_FRAG_SRC = /* glsl */ `#version 300 es\nprecision highp float;\nin vec2 v_world;\n${PATTERN_PAINT_GLSL}\nout vec4 outColor;\nvoid main() {\n  outColor = shadePaint(v_world);\n}\n`;\n\nexport const PATTERN_FILL_UNIFORMS = [\n  'u_proj', 'u_model', 'u_worldInv', 'u_sampler',\n  'u_tileSize', 'u_opacity', 'u_alpha',\n  'u_colorMatrix', 'u_colorBias',\n] as const;\n\nexport const PATTERN_FILL_ATTRIBUTES = ['a_position'] as const;\n"],"mappings":";AAaA,IAAaA,IAA8B,6WAoB9BC,IAAgC,gcAgBhCC,IAA8B;;;EAGzCD,EAAmB;;;;;GAORE,IAAwB;CACnC;CAAU;CAAW;CAAc;CACnC;CAAc;CAAa;CAC3B;CAAiB;AACnB,GAEaC,IAA0B,CAAC,YAAY"}
+{"version":3,"file":"patternFill.js","names":["PATTERN_VERT_SRC","PATTERN_PAINT_GLSL","PATTERN_FRAG_SRC","PATTERN_FILL_UNIFORMS","PATTERN_FILL_ATTRIBUTES"],"sources":["../../../src/renderer/shaders/patternFill.ts"],"sourcesContent":["/**\n * GLSL ES 3.0 sources for pattern-fill paths.\n *\n * The vertex stage is `gradFill`'s: a path fill mesh carries `a_position`\n * only, so tile-space coordinates are recovered per fragment from the\n * screen position via `u_worldInv` rather than read from a UV attribute.\n * That matrix also carries the tile's origin and transform\n * (`patternTileSpace`). `u_tileSize` then converts to texture space, and\n * `REPEAT` wrapping (set at upload) tiles the result.\n *\n * Output convention §2: PREMULTIPLIED alpha.\n */\n\nexport const PATTERN_VERT_SRC = /* glsl */ `#version 300 es\nin vec2 a_position;\nuniform mat3 u_proj;\nuniform mat3 u_model;\nuniform vec2 u_origin;\nuniform mat3 u_worldInv;\nout vec2 v_world;\nvoid main() {\n  vec3 screen = u_model * vec3(a_position - u_origin, 1.0);\n  vec3 clip   = u_proj  * vec3(screen.xy, 1.0);\n  gl_Position = vec4(clip.xy, 0.0, 1.0);\n  vec3 world = u_worldInv * vec3(screen.xy, 1.0);\n  v_world = world.xy;\n}\n`;\n\n/**\n * The pattern's color at a paint-space point, premultiplied — the whole of the\n * fragment stage but the point it is asked about, so the glyph program can\n * mask the same paint the path program draws.\n */\nexport const PATTERN_PAINT_GLSL = /* glsl */ `\nuniform sampler2D u_sampler;\nuniform vec2  u_tileSize;\nuniform float u_opacity;\nuniform float u_alpha;\nuniform mat4  u_colorMatrix;\nuniform vec4  u_colorBias;\nvec4 shadePaint(vec2 world) {\n  vec2 uv = world / max(u_tileSize, vec2(0.0001));\n  vec4 texel = texture(u_sampler, uv);\n  vec4 mapped = clamp(u_colorMatrix * texel + u_colorBias, 0.0, 1.0);\n  float a = mapped.a * u_opacity * u_alpha;\n  return vec4(mapped.rgb * a, a);\n}\n`;\n\nexport const PATTERN_FRAG_SRC = /* glsl */ `#version 300 es\nprecision highp float;\nin vec2 v_world;\n${PATTERN_PAINT_GLSL}\nout vec4 outColor;\nvoid main() {\n  outColor = shadePaint(v_world);\n}\n`;\n\nexport const PATTERN_FILL_UNIFORMS = [\n  'u_proj', 'u_model', 'u_origin', 'u_worldInv', 'u_sampler',\n  'u_tileSize', 'u_opacity', 'u_alpha',\n  'u_colorMatrix', 'u_colorBias',\n] as const;\n\nexport const PATTERN_FILL_ATTRIBUTES = ['a_position'] as const;\n"],"mappings":";AAaA,IAAaA,IAA8B,gZAqB9BC,IAAgC,gcAgBhCC,IAA8B;;;EAGzCD,EAAmB;;;;;GAORE,IAAwB;CACnC;CAAU;CAAW;CAAY;CAAc;CAC/C;CAAc;CAAa;CAC3B;CAAiB;AACnB,GAEaC,IAA0B,CAAC,YAAY"}

package/dist/renderer/shaders/registerProgram.js.map

@@ -1 +1 @@
-{"version":3,"file":"registerProgram.js","names":["registry","createReflectable","programSourceRegistry","getProgramSource","id","isDev","registerProgram"],"sources":["../../../src/renderer/shaders/registerProgram.ts"],"sourcesContent":["/**\n * registerProgram — public API for registering custom shader programs.\n *\n * Stores raw GLSL source strings in a module-level registry. GL compilation\n * happens on each WeaselRenderer via WeaselRenderer.registerProgram(), which\n * calls getProgramSource() and compiles the result. This keeps registerProgram\n * GL-context-agnostic — identical pattern to registerFont storing ImageBitmap.\n *\n * Module-level state = source strings only; compiled GL\n * programs live on each renderer's programRegistry (Map<id, ShaderProgram>).\n *\n * Lifecycle: program sources live for the module lifetime. No unregister in v1.\n */\n\nimport { createReflectable, type Reflection } from '@weasel-js/registry';\nimport { type TextureHandle } from '../textures/registerTexture';\n\nexport type { TextureHandle };\n\n/** Opaque handle to a compiled custom shader program. */\nexport interface ShaderProgramHandle {\n  readonly id: string;\n}\n\n/**\n * A value for one uniform in `ShaderDrawCommand.uniforms`.\n *\n * | TS type                 | GL call                              |\n * |-------------------------|--------------------------------------|\n * | number                  | uniform1f                            |\n * | [n, n]                  | uniform2fv                           |\n * | [n, n, n]               | uniform3fv                           |\n * | [n, n, n, n]            | uniform4fv                           |\n * | Float32Array length 9   | uniformMatrix3fv (column-major)      |\n * | Float32Array length 16  | uniformMatrix4fv (column-major)      |\n * | TextureHandle           | bind to next tex unit + uniform1i    |\n *\n * **Array uniforms.** Keyed by an array's bare name (`u_ripples` for\n * `uniform vec3 u_ripples[8]`), a flat `number[]`, `Float32Array`,\n * `Int32Array` or `Uint32Array` fills the array from slot 0 in one\n * `uniform*v` call chosen by the declared element type (`vec3` →\n * `uniform3fv`, `ivec2` → `uniform2iv`, `mat4` → `uniformMatrix4fv`, …).\n * Its length must be a whole number of elements and at most the declared\n * size; a shorter value leaves the remaining slots as they were. Per-slot\n * keys (`u_ripples[2]`) keep working and take the table above.\n */\nexport type ShaderUniform =\n  | number\n  | [number, number]\n  | [number, number, number]\n  | [number, number, number, number]\n  | readonly number[]\n  | Float32Array\n  | Int32Array\n  | Uint32Array\n  | TextureHandle;\n\n/** A registered program's GLSL source. An empty `vert` means the kit's default vertex shader. */\nexport interface ProgramSource {\n  vert: string;\n  frag: string;\n}\n\nconst registry = createReflectable<ProgramSource>();\n\n/** Every registered program's GLSL source, keyed by program id. */\nexport const programSourceRegistry: Reflection<ProgramSource> = registry.reflection;\n\n/** @internal Test helper — do not call from product code. */\nexport function _resetProgramRegistryForTests(): void {\n  registry.clear();\n}\n\nexport function getProgramSource(id: string): ProgramSource | null {\n  return registry.get(id) ?? null;\n}\n\nconst isDev = (): boolean =>\n  typeof process !== 'undefined' ? process.env.NODE_ENV !== 'production' : true;\n\n/**\n * Register a custom shader program by id.\n *\n * Pass an empty string for `vert` to use the kit's default vertex shader\n * (recommended). The kit's vertex shader exposes `v_uv`, `v_screen`, and\n * `v_world` varyings plus `u_bounds` and `u_view` uniforms.\n *\n * **IMPORTANT — Premultiplied alpha:**\n * Your fragment shader MUST output premultiplied alpha:\n *   `outColor = vec4(rgb * a, a);`  ← correct\n *   `outColor = vec4(rgb, a);`      ← WRONG — over-brightens translucent regions\n *\n * The renderer uses `gl.blendFunc(ONE, ONE_MINUS_SRC_ALPHA)` to match.\n * Opaque fragments (a=1) are unaffected; only fragments with a < 1 differ.\n *\n * **Re-registration behavior:**\n * - Dev mode (`NODE_ENV !== 'production'`): calling with an existing id and new\n *   source replaces it (hot reload). Every renderer that compiled the old source\n *   recompiles on its next frame and deletes the program it replaces; a\n *   `<Canvas shaders>` naming the id repaints to show it. If the new source fails\n *   to compile, the renderer logs the error once and keeps drawing the old one.\n * - Prod mode: calling with an existing id throws.\n *\n * Actual GL compilation and `ShaderCompileError` throwing happen in\n * `WeaselRenderer.registerProgram()`, not here.\n *\n * @experimental API may break before v2.\n */\nexport function registerProgram(\n  id: string,\n  vert: string,\n  frag: string,\n): ShaderProgramHandle {\n  if (registry.has(id) && !isDev()) {\n    throw new Error(`weasel registerProgram: duplicate program id \"${id}\". ` +\n      `In production, re-registration is not allowed. Pass a unique id or call in dev mode.`);\n  }\n  registry.set(id, { vert, frag });\n  return { id };\n}\n"],"mappings":";;AA+DA,IAAMA,IAAWC,EAAiC,GAGrCC,IAAmDF,EAAS;AAOzE,SAAgBG,EAAiB,GAAkC;CACjE,OAAOH,EAAS,IAAII,CAAE,KAAK;AAC7B;AAEA,IAAMC,UACJ,OAAO,UAAY,MAAA,QAAA,IAAA,aAAuC,eAAe;AA8B3E,SAAgBC,EACd,GACA,GACA,GACqB;CACrB,IAAIN,EAAS,IAAII,CAAE,KAAK,CAACC,EAAM,GAC7B,MAAU,MAAM,iDAAiDD,EAAG,wFACoB;CAG1F,OADAJ,EAAS,IAAII,GAAI;EAAE;EAAM;CAAK,CAAC,GACxB,EAAE,MAAG;AACd"}
+{"version":3,"file":"registerProgram.js","names":["registry","createReflectable","programSourceRegistry","getProgramSource","id","isDev","registerProgram"],"sources":["../../../src/renderer/shaders/registerProgram.ts"],"sourcesContent":["/**\n * registerProgram — public API for registering custom shader programs.\n *\n * Stores raw GLSL source strings in a module-level registry. GL compilation\n * happens on each WeaselRenderer via WeaselRenderer.registerProgram(), which\n * calls getProgramSource() and compiles the result. This keeps registerProgram\n * GL-context-agnostic — identical pattern to registerFont storing ImageBitmap.\n *\n * Module-level state = source strings only; compiled GL\n * programs live on each renderer's programRegistry (Map<id, ShaderProgram>).\n *\n * Lifecycle: program sources live for the module lifetime. No unregister in v1.\n */\n\nimport { createReflectable, type Reflection } from '@weasel-js/registry';\nimport { type TextureHandle } from '../textures/registerTexture';\n\nexport type { TextureHandle };\n\n/** Opaque handle to a compiled custom shader program. */\nexport interface ShaderProgramHandle {\n  readonly id: string;\n}\n\n/**\n * A value for one uniform in `ShaderDrawCommand.uniforms`.\n *\n * | TS type                 | GL call                              |\n * |-------------------------|--------------------------------------|\n * | number                  | uniform1f                            |\n * | [n, n]                  | uniform2fv                           |\n * | [n, n, n]               | uniform3fv                           |\n * | [n, n, n, n]            | uniform4fv                           |\n * | Float32Array length 9   | uniformMatrix3fv (column-major)      |\n * | Float64Array            | as the Float32Array of its values    |\n * | Float32Array length 16  | uniformMatrix4fv (column-major)      |\n * | TextureHandle           | bind to next tex unit + uniform1i    |\n *\n * **Array uniforms.** Keyed by an array's bare name (`u_ripples` for\n * `uniform vec3 u_ripples[8]`), a flat `number[]`, `Float32Array`,\n * `Int32Array` or `Uint32Array` fills the array from slot 0 in one\n * `uniform*v` call chosen by the declared element type (`vec3` →\n * `uniform3fv`, `ivec2` → `uniform2iv`, `mat4` → `uniformMatrix4fv`, …).\n * Its length must be a whole number of elements and at most the declared\n * size; a shorter value leaves the remaining slots as they were. Per-slot\n * keys (`u_ripples[2]`) keep working and take the table above.\n */\nexport type ShaderUniform =\n  | number\n  | [number, number]\n  | [number, number, number]\n  | [number, number, number, number]\n  | readonly number[]\n  | Float32Array\n  | Float64Array\n  | Int32Array\n  | Uint32Array\n  | TextureHandle;\n\n/** A registered program's GLSL source. An empty `vert` means the kit's default vertex shader. */\nexport interface ProgramSource {\n  vert: string;\n  frag: string;\n}\n\nconst registry = createReflectable<ProgramSource>();\n\n/** Every registered program's GLSL source, keyed by program id. */\nexport const programSourceRegistry: Reflection<ProgramSource> = registry.reflection;\n\n/** @internal Test helper — do not call from product code. */\nexport function _resetProgramRegistryForTests(): void {\n  registry.clear();\n}\n\nexport function getProgramSource(id: string): ProgramSource | null {\n  return registry.get(id) ?? null;\n}\n\nconst isDev = (): boolean =>\n  typeof process !== 'undefined' ? process.env.NODE_ENV !== 'production' : true;\n\n/**\n * Register a custom shader program by id.\n *\n * Pass an empty string for `vert` to use the kit's default vertex shader\n * (recommended). The kit's vertex shader exposes `v_uv`, `v_screen`, and\n * `v_world` varyings plus `u_bounds` and `u_view` uniforms.\n *\n * **IMPORTANT — Premultiplied alpha:**\n * Your fragment shader MUST output premultiplied alpha:\n *   `outColor = vec4(rgb * a, a);`  ← correct\n *   `outColor = vec4(rgb, a);`      ← WRONG — over-brightens translucent regions\n *\n * The renderer uses `gl.blendFunc(ONE, ONE_MINUS_SRC_ALPHA)` to match.\n * Opaque fragments (a=1) are unaffected; only fragments with a < 1 differ.\n *\n * **Re-registration behavior:**\n * - Dev mode (`NODE_ENV !== 'production'`): calling with an existing id and new\n *   source replaces it (hot reload). Every renderer that compiled the old source\n *   recompiles on its next frame and deletes the program it replaces; a\n *   `<Canvas shaders>` naming the id repaints to show it. If the new source fails\n *   to compile, the renderer logs the error once and keeps drawing the old one.\n * - Prod mode: calling with an existing id throws.\n *\n * Actual GL compilation and `ShaderCompileError` throwing happen in\n * `WeaselRenderer.registerProgram()`, not here.\n *\n * @experimental API may break before v2.\n */\nexport function registerProgram(\n  id: string,\n  vert: string,\n  frag: string,\n): ShaderProgramHandle {\n  if (registry.has(id) && !isDev()) {\n    throw new Error(`weasel registerProgram: duplicate program id \"${id}\". ` +\n      `In production, re-registration is not allowed. Pass a unique id or call in dev mode.`);\n  }\n  registry.set(id, { vert, frag });\n  return { id };\n}\n"],"mappings":";;AAiEA,IAAMA,IAAWC,EAAiC,GAGrCC,IAAmDF,EAAS;AAOzE,SAAgBG,EAAiB,GAAkC;CACjE,OAAOH,EAAS,IAAII,CAAE,KAAK;AAC7B;AAEA,IAAMC,UACJ,OAAO,UAAY,MAAA,QAAA,IAAA,aAAuC,eAAe;AA8B3E,SAAgBC,EACd,GACA,GACA,GACqB;CACrB,IAAIN,EAAS,IAAII,CAAE,KAAK,CAACC,EAAM,GAC7B,MAAU,MAAM,iDAAiDD,EAAG,wFACoB;CAG1F,OADAJ,EAAS,IAAII,GAAI;EAAE;EAAM;CAAK,CAAC,GACxB,EAAE,MAAG;AACd"}

package/dist/renderer/strokeLengths.js.map

@@ -1 +1 @@
-{"version":3,"file":"strokeLengths.js","names":["WORLD","resolveStrokeLengths","stroke","cmd","isPxMarker","markerStart","markerMid","markerEnd","resolved","strokeSpaceOf","transform","screen","metric","ribbon","pxPerUnit","quantizeStrokeScale","scale","resolveStrokeWidth","d","head","ref","spaces","resolvedMarker","resolveMarkerSize"],"sources":["../../src/renderer/strokeLengths.ts"],"sourcesContent":["import type { FillStyle, MarkerRef, Stroke } from '@weasel-js/paint';\nimport type { PathDrawCommand } from './DrawCommand';\nimport type { GlMat3 } from './math/mat3';\nimport { resolveStrokeWidth } from 'features/paths/tessellate/stroke';\nimport {\n  strokeSpaceOf, type ScreenSpace, type StrokeSpaces,\n} from 'features/paths/tessellate/metric';\nimport { quantizeStrokeScale } from './cache/strokeMeshCache';\nimport { resolveMarkerSize } from '../core/markerInset';\n\n/** A path command whose stroke paints. */\nexport type StrokedPathCommand = PathDrawCommand & { stroke: Stroke & { paint: FillStyle } };\n\n/** A stroke command ready to tessellate, and the spaces to tessellate it in. */\nexport interface ResolvedStrokeCommand {\n  cmd: StrokedPathCommand;\n  /** Where the ribbon and each head are built; every length in `cmd` is\n   *  measured in the space of the part it belongs to. */\n  spaces: StrokeSpaces;\n}\n\nconst WORLD: StrokeSpaces = {};\n\n/**\n * `cmd` with its `{ px }` lengths — the stroke width, any marker size, and on a\n * `{ px }` stroke its dashes — resolved against the accumulated transform's\n * quantized scale, so everything downstream (the ribbon cache key, the insets,\n * the heads) sees plain numbers.\n *\n * Under a transform that stretches one direction more than another, each\n * screen-sized part is also built in the transform's stretch, where lengths\n * measure as they do on screen, so it is exact across, down and on every\n * diagonal rather than right only on average. World-sized parts stay in world.\n */\nexport function resolveStrokeLengths(transform: GlMat3, cmd: StrokedPathCommand): ResolvedStrokeCommand {\n  const stroke = cmd.stroke;\n  const { markerStart, markerMid, markerEnd } = stroke;\n  if (typeof stroke.width !== 'object' && !isPxMarker(markerStart)\n    && !isPxMarker(markerMid) && !isPxMarker(markerEnd)) {\n    return { cmd, spaces: WORLD };\n  }\n  const resolved: Stroke & { paint: FillStyle } = { ...stroke };\n  const { scale, metric } = strokeSpaceOf(transform[0], transform[1], transform[3], transform[4]);\n  const screen = (pxPerUnit: number): ScreenSpace | undefined =>\n    metric === null ? undefined : { metric, pxPerUnit };\n  let ribbon: ScreenSpace | undefined;\n  if (typeof stroke.width === 'object') {\n    const pxPerUnit = quantizeStrokeScale(stroke.width.px, scale);\n    resolved.width = resolveStrokeWidth(stroke.width, pxPerUnit);\n    if (stroke.dash && pxPerUnit > 0) resolved.dash = stroke.dash.map((d) => d / pxPerUnit);\n    ribbon = screen(pxPerUnit);\n  }\n  const head = (ref: MarkerRef | undefined): ScreenSpace | undefined => {\n    if (ref === undefined || typeof ref === 'string' || ref.size === undefined) return ribbon;\n    if (typeof ref.size === 'number') return undefined;\n    return screen(quantizeStrokeScale(ref.size.px, scale));\n  };\n  const spaces = { ribbon, start: head(markerStart), mid: head(markerMid), end: head(markerEnd) };\n  if (isPxMarker(markerStart)) resolved.markerStart = resolvedMarker(markerStart, scale);\n  if (isPxMarker(markerMid)) resolved.markerMid = resolvedMarker(markerMid, scale);\n  if (isPxMarker(markerEnd)) resolved.markerEnd = resolvedMarker(markerEnd, scale);\n  return { cmd: { ...cmd, stroke: resolved }, spaces };\n}\n\ntype PxMarker = Exclude<MarkerRef, string> & { size: { px: number } };\n\nfunction isPxMarker(ref: MarkerRef | undefined): ref is PxMarker {\n  return typeof ref === 'object' && typeof ref.size === 'object';\n}\n\nfunction resolvedMarker(ref: PxMarker, scale: number): MarkerRef {\n  return { ...ref, size: resolveMarkerSize(ref, 0, quantizeStrokeScale(ref.size.px, scale)) };\n}\n"],"mappings":";;;;;AAqBA,IAAMA,IAAsB,CAAC;AAa7B,SAAgBC,EAAqB,GAAmB,GAAgD;CACtG,IAAMC,IAASC,EAAI,QACb,EAAE,gBAAa,cAAW,iBAAcD;CAC9C,IAAI,OAAOA,EAAO,SAAU,YAAY,CAACE,EAAWC,CAAW,KAC1D,CAACD,EAAWE,CAAS,KAAK,CAACF,EAAWG,CAAS,GAClD,OAAO;EAAE;EAAK,QAAQP;CAAM;CAE9B,IAAMQ,IAA0C,EAAE,GAAGN,EAAO,GACtD,EAAE,UAAO,cAAWO,EAAcC,EAAU,IAAIA,EAAU,IAAIA,EAAU,IAAIA,EAAU,EAAE,GACxFC,KAAU,MACdC,MAAW,OAAO,KAAA,IAAY;EAAE;EAAQ;CAAU,GAChDC;CACJ,IAAI,OAAOX,EAAO,SAAU,UAAU;EACpC,IAAMY,IAAYC,EAAoBb,EAAO,MAAM,IAAIc,CAAK;EAG5D,AAFA,EAAS,QAAQC,EAAmBf,EAAO,OAAOY,CAAS,GACvDZ,EAAO,QAAQY,IAAY,MAAG,EAAS,OAAOZ,EAAO,KAAK,KAAK,MAAMgB,IAAIJ,CAAS,IACtF,IAASH,EAAOG,CAAS;CAC3B;CACA,IAAMK,KAAQ,MAAwD;EACpE,IAAIC,MAAQ,KAAA,KAAa,OAAOA,KAAQ,YAAYA,EAAI,SAAS,KAAA,GAAW,OAAOP;EACnF,IAAI,OAAOO,EAAI,QAAS,UACxB,OAAOT,EAAOI,EAAoBK,EAAI,KAAK,IAAIJ,CAAK,CAAC;CACvD,GACMK,IAAS;EAAE;EAAQ,OAAOF,EAAKd,CAAW;EAAG,KAAKc,EAAKb,CAAS;EAAG,KAAKa,EAAKZ,CAAS;CAAE;CAI9F,OAHIH,EAAWC,CAAW,MAAG,EAAS,cAAciB,EAAejB,GAAaW,CAAK,IACjFZ,EAAWE,CAAS,MAAG,EAAS,YAAYgB,EAAehB,GAAWU,CAAK,IAC3EZ,EAAWG,CAAS,MAAG,EAAS,YAAYe,EAAef,GAAWS,CAAK,IACxE;EAAE,KAAK;GAAE,GAAGb;GAAK,QAAQK;EAAS;EAAG;CAAO;AACrD;AAIA,SAASJ,EAAW,GAA6C;CAC/D,OAAO,OAAOgB,KAAQ,YAAY,OAAOA,EAAI,QAAS;AACxD;AAEA,SAASE,EAAe,GAAe,GAA0B;CAC/D,OAAO;EAAE,GAAGF;EAAK,MAAMG,EAAkBH,GAAK,GAAGL,EAAoBK,EAAI,KAAK,IAAIJ,CAAK,CAAC;CAAE;AAC5F"}
+{"version":3,"file":"strokeLengths.js","names":["WORLD","resolveStrokeLengths","stroke","cmd","isPxMarker","markerStart","markerMid","markerEnd","resolved","strokeSpaceOf","transform","screen","metric","ribbon","pxPerUnit","quantizeStrokeScale","scale","resolveStrokeWidth","d","head","ref","spaces","resolvedMarker","resolveMarkerSize"],"sources":["../../src/renderer/strokeLengths.ts"],"sourcesContent":["import type { CommandFill, MarkerRef, CommandStroke } from '@weasel-js/paint';\nimport type { PathDrawCommand } from './DrawCommand';\nimport type { GlMat3 } from './math/mat3';\nimport { resolveStrokeWidth } from 'features/paths/tessellate/stroke';\nimport {\n  strokeSpaceOf, type ScreenSpace, type StrokeSpaces,\n} from 'features/paths/tessellate/metric';\nimport { quantizeStrokeScale } from './cache/strokeMeshCache';\nimport { resolveMarkerSize } from '../core/markerInset';\n\n/** A path command whose stroke paints. */\nexport type StrokedPathCommand = PathDrawCommand & { stroke: CommandStroke & { paint: CommandFill } };\n\n/** A stroke command ready to tessellate, and the spaces to tessellate it in. */\nexport interface ResolvedStrokeCommand {\n  cmd: StrokedPathCommand;\n  /** Where the ribbon and each head are built; every length in `cmd` is\n   *  measured in the space of the part it belongs to. */\n  spaces: StrokeSpaces;\n}\n\nconst WORLD: StrokeSpaces = {};\n\n/**\n * `cmd` with its `{ px }` lengths — the stroke width, any marker size, and on a\n * `{ px }` stroke its dashes — resolved against the accumulated transform's\n * quantized scale, so everything downstream (the ribbon cache key, the insets,\n * the heads) sees plain numbers.\n *\n * Under a transform that stretches one direction more than another, each\n * screen-sized part is also built in the transform's stretch, where lengths\n * measure as they do on screen, so it is exact across, down and on every\n * diagonal rather than right only on average. World-sized parts stay in world.\n */\nexport function resolveStrokeLengths(transform: GlMat3, cmd: StrokedPathCommand): ResolvedStrokeCommand {\n  const stroke = cmd.stroke;\n  const { markerStart, markerMid, markerEnd } = stroke;\n  if (typeof stroke.width !== 'object' && !isPxMarker(markerStart)\n    && !isPxMarker(markerMid) && !isPxMarker(markerEnd)) {\n    return { cmd, spaces: WORLD };\n  }\n  const resolved: CommandStroke & { paint: CommandFill } = { ...stroke };\n  const { scale, metric } = strokeSpaceOf(transform[0], transform[1], transform[3], transform[4]);\n  const screen = (pxPerUnit: number): ScreenSpace | undefined =>\n    metric === null ? undefined : { metric, pxPerUnit };\n  let ribbon: ScreenSpace | undefined;\n  if (typeof stroke.width === 'object') {\n    const pxPerUnit = quantizeStrokeScale(stroke.width.px, scale);\n    resolved.width = resolveStrokeWidth(stroke.width, pxPerUnit);\n    if (stroke.dash && pxPerUnit > 0) resolved.dash = stroke.dash.map((d) => d / pxPerUnit);\n    ribbon = screen(pxPerUnit);\n  }\n  const head = (ref: MarkerRef | undefined): ScreenSpace | undefined => {\n    if (ref === undefined || typeof ref === 'string' || ref.size === undefined) return ribbon;\n    if (typeof ref.size === 'number') return undefined;\n    return screen(quantizeStrokeScale(ref.size.px, scale));\n  };\n  const spaces = { ribbon, start: head(markerStart), mid: head(markerMid), end: head(markerEnd) };\n  if (isPxMarker(markerStart)) resolved.markerStart = resolvedMarker(markerStart, scale);\n  if (isPxMarker(markerMid)) resolved.markerMid = resolvedMarker(markerMid, scale);\n  if (isPxMarker(markerEnd)) resolved.markerEnd = resolvedMarker(markerEnd, scale);\n  return { cmd: { ...cmd, stroke: resolved }, spaces };\n}\n\ntype PxMarker = Exclude<MarkerRef, string> & { size: { px: number } };\n\nfunction isPxMarker(ref: MarkerRef | undefined): ref is PxMarker {\n  return typeof ref === 'object' && typeof ref.size === 'object';\n}\n\nfunction resolvedMarker(ref: PxMarker, scale: number): MarkerRef {\n  return { ...ref, size: resolveMarkerSize(ref, 0, quantizeStrokeScale(ref.size.px, scale)) };\n}\n"],"mappings":";;;;;AAqBA,IAAMA,IAAsB,CAAC;AAa7B,SAAgBC,EAAqB,GAAmB,GAAgD;CACtG,IAAMC,IAASC,EAAI,QACb,EAAE,gBAAa,cAAW,iBAAcD;CAC9C,IAAI,OAAOA,EAAO,SAAU,YAAY,CAACE,EAAWC,CAAW,KAC1D,CAACD,EAAWE,CAAS,KAAK,CAACF,EAAWG,CAAS,GAClD,OAAO;EAAE;EAAK,QAAQP;CAAM;CAE9B,IAAMQ,IAAmD,EAAE,GAAGN,EAAO,GAC/D,EAAE,UAAO,cAAWO,EAAcC,EAAU,IAAIA,EAAU,IAAIA,EAAU,IAAIA,EAAU,EAAE,GACxFC,KAAU,MACdC,MAAW,OAAO,KAAA,IAAY;EAAE;EAAQ;CAAU,GAChDC;CACJ,IAAI,OAAOX,EAAO,SAAU,UAAU;EACpC,IAAMY,IAAYC,EAAoBb,EAAO,MAAM,IAAIc,CAAK;EAG5D,AAFA,EAAS,QAAQC,EAAmBf,EAAO,OAAOY,CAAS,GACvDZ,EAAO,QAAQY,IAAY,MAAG,EAAS,OAAOZ,EAAO,KAAK,KAAK,MAAMgB,IAAIJ,CAAS,IACtF,IAASH,EAAOG,CAAS;CAC3B;CACA,IAAMK,KAAQ,MAAwD;EACpE,IAAIC,MAAQ,KAAA,KAAa,OAAOA,KAAQ,YAAYA,EAAI,SAAS,KAAA,GAAW,OAAOP;EACnF,IAAI,OAAOO,EAAI,QAAS,UACxB,OAAOT,EAAOI,EAAoBK,EAAI,KAAK,IAAIJ,CAAK,CAAC;CACvD,GACMK,IAAS;EAAE;EAAQ,OAAOF,EAAKd,CAAW;EAAG,KAAKc,EAAKb,CAAS;EAAG,KAAKa,EAAKZ,CAAS;CAAE;CAI9F,OAHIH,EAAWC,CAAW,MAAG,EAAS,cAAciB,EAAejB,GAAaW,CAAK,IACjFZ,EAAWE,CAAS,MAAG,EAAS,YAAYgB,EAAehB,GAAWU,CAAK,IAC3EZ,EAAWG,CAAS,MAAG,EAAS,YAAYe,EAAef,GAAWS,CAAK,IACxE;EAAE,KAAK;GAAE,GAAGb;GAAK,QAAQK;EAAS;EAAG;CAAO;AACrD;AAIA,SAASJ,EAAW,GAA6C;CAC/D,OAAO,OAAOgB,KAAQ,YAAY,OAAOA,EAAI,QAAS;AACxD;AAEA,SAASE,EAAe,GAAe,GAA0B;CAC/D,OAAO;EAAE,GAAGF;EAAK,MAAMG,EAAkBH,GAAK,GAAGL,EAAoBK,EAAI,KAAK,IAAIJ,CAAK,CAAC;CAAE;AAC5F"}

package/dist/renderer/textures/registerTexture.js

@@ -1,14 +1,34 @@
 import { createReflectable as e } from "@weasel-js/registry";
 //#region src/renderer/textures/registerTexture.ts
-var t = 0, n = e(), r = n.reflection;
-function i(e) {
-	return n.get(e) ?? null;
+var t = 0, n = e(), r = n.reflection, i = [];
+function a(e, t) {
+	let n = {
+		prefix: e,
+		owner: t
+	};
+	return i.push(n), () => {
+		let e = i.indexOf(n);
+		e !== -1 && i.splice(e, 1);
+	};
 }
-function a(e) {
+function o(e) {
+	for (let t = 0; t < i.length; t++) if (e.startsWith(i[t].prefix)) return i[t].owner;
+}
+function s(e) {
+	let t = i.length > 0 ? o(e) : void 0, r = n.get(e);
+	return r ? (t?.touched?.(e), r) : t ? (t.revive(e), n.get(e) ?? null) : null;
+}
+function c(e) {
 	let r = `tex_${++t}`;
 	return n.set(r, { source: e }), { id: r };
 }
+function l(e, t) {
+	return n.set(e, { source: t }), { id: e };
+}
+function u(e) {
+	return n.delete(e.id);
+}
 //#endregion
-export { i as getTexture, a as registerTexture, r as textureRegistry };
+export { s as getTexture, a as ownTextureIds, c as registerTexture, l as registerTextureAs, r as textureRegistry, u as unregisterTexture };
 
 //# sourceMappingURL=registerTexture.js.map

package/dist/renderer/textures/registerTexture.js.map

@@ -1 +1 @@
-{"version":3,"file":"registerTexture.js","names":["counter","registry","createReflectable","textureRegistry","getTexture","id","registerTexture","image"],"sources":["../../../src/renderer/textures/registerTexture.ts"],"sourcesContent":["/**\n * registerTexture — accepts an image source, assigns an opaque id, stores in\n * a module-level registry. Actual GL upload happens lazily at draw time in\n * drawShader() via GLTextureCache.upload (which is idempotent).\n *\n * Lifecycle: textures live for the renderer's lifetime. No unregister in v1.\n *\n * Convention §9: this registry stores image data only — no per-renderer state.\n * Each WeaselRenderer's GLTextureCache does its own dedup via has(id).\n */\n\nimport type { TextureHandle } from '@weasel-js/paint';\nimport { createReflectable, type Reflection } from '@weasel-js/registry';\n\nexport type { TextureHandle };\n\n/** A registered texture's image source, uploaded to GL lazily at first draw. */\nexport interface TextureEntry {\n  source: HTMLImageElement | ImageBitmap;\n}\n\nlet counter = 0;\nconst registry = createReflectable<TextureEntry>();\n\n/** Every registered texture, keyed by its handle id. */\nexport const textureRegistry: Reflection<TextureEntry> = registry.reflection;\n\n/** @internal Test helper — do not call from product code. */\nexport function _resetTextureRegistryForTests(): void {\n  registry.clear();\n  counter = 0;\n}\n\nexport function getTexture(id: string): TextureEntry | null {\n  return registry.get(id) ?? null;\n}\n\n/**\n * Register an image for use as a shader texture uniform.\n *\n * Returns a TextureHandle whose `id` can be passed as a ShaderUniform value.\n * The handle is valid for the lifetime of the renderer it will be used with.\n *\n * @param image  The image to register. HTMLImageElement must be fully loaded.\n * @returns      Opaque TextureHandle.\n */\nexport function registerTexture(\n  image: HTMLImageElement | ImageBitmap,\n): TextureHandle {\n  const id = `tex_${++counter}`;\n  registry.set(id, { source: image });\n  return { id };\n}\n"],"mappings":";;AAqBA,IAAIA,IAAU,GACRC,IAAWC,EAAgC,GAGpCC,IAA4CF,EAAS;AAQlE,SAAgBG,EAAW,GAAiC;CAC1D,OAAOH,EAAS,IAAII,CAAE,KAAK;AAC7B;AAWA,SAAgBC,EACd,GACe;CACf,IAAMD,IAAK,OAAO,EAAEL;CAEpB,OADAC,EAAS,IAAII,GAAI,EAAE,QAAQE,EAAM,CAAC,GAC3B,EAAE,MAAG;AACd"}
+{"version":3,"file":"registerTexture.js","names":["counter","registry","createReflectable","textureRegistry","owners","ownTextureIds","claim","i","ownerOf","id","getTexture","owner","hit","registerTexture","image","registerTextureAs","unregisterTexture","handle"],"sources":["../../../src/renderer/textures/registerTexture.ts"],"sourcesContent":["/**\n * registerTexture — accepts an image source, assigns an opaque id, stores in\n * a module-level registry. Actual GL upload happens lazily at draw time in\n * drawShader() via GLTextureCache.upload (which is idempotent).\n *\n * Lifecycle: a texture lives until `unregisterTexture`. Each renderer frees\n * its own GL copy at the top of its next frame.\n *\n * Convention §9: this registry stores image data only — no per-renderer state.\n * Each WeaselRenderer's GLTextureCache does its own dedup by id and source.\n */\n\nimport type { TextureHandle } from '@weasel-js/paint';\nimport { createReflectable, type Reflection } from '@weasel-js/registry';\n\nexport type { TextureHandle };\n\n/** A registered texture's image source, uploaded to GL lazily at first draw. */\nexport interface TextureEntry {\n  source: HTMLImageElement | ImageBitmap;\n}\n\nlet counter = 0;\nconst registry = createReflectable<TextureEntry>();\n\n/** Every registered texture, keyed by its handle id. */\nexport const textureRegistry: Reflection<TextureEntry> = registry.reflection;\n\n/** @internal Test helper — do not call from product code. */\nexport function _resetTextureRegistryForTests(): void {\n  registry.clear();\n  counter = 0;\n}\n\n/**\n * Whoever mints the ids under one prefix and can rebuild any of them.\n * @internal\n */\nexport interface TextureIdOwner {\n  /** Register `id` again if it can be rebuilt; do nothing otherwise. */\n  revive(id: string): void;\n  /** `id` was looked up and found: something is about to draw it. */\n  touched?(id: string): void;\n}\n\nconst owners: { prefix: string; owner: TextureIdOwner }[] = [];\n\n/**\n * Claim every texture id starting with `prefix`. Returns the release.\n * @internal\n */\nexport function ownTextureIds(prefix: string, owner: TextureIdOwner): () => void {\n  const claim = { prefix, owner };\n  owners.push(claim);\n  return () => {\n    const i = owners.indexOf(claim);\n    if (i !== -1) owners.splice(i, 1);\n  };\n}\n\nfunction ownerOf(id: string): TextureIdOwner | undefined {\n  for (let i = 0; i < owners.length; i++) {\n    if (id.startsWith(owners[i].prefix)) return owners[i].owner;\n  }\n  return undefined;\n}\n\n/**\n * The entry for `id`, as a draw looks it up. An owned id that was\n * unregistered is rebuilt by its owner first, so a handle held past its\n * texture's eviction still draws.\n */\nexport function getTexture(id: string): TextureEntry | null {\n  const owner = owners.length > 0 ? ownerOf(id) : undefined;\n  const hit = registry.get(id);\n  if (hit) {\n    owner?.touched?.(id);\n    return hit;\n  }\n  if (!owner) return null;\n  owner.revive(id);\n  return registry.get(id) ?? null;\n}\n\n/**\n * Register an image for use as a shader texture uniform.\n *\n * Returns a TextureHandle whose `id` can be passed as a ShaderUniform value.\n * The handle is valid for the lifetime of the renderer it will be used with.\n *\n * @param image  The image to register. HTMLImageElement must be fully loaded.\n * @returns      Opaque TextureHandle.\n */\nexport function registerTexture(\n  image: HTMLImageElement | ImageBitmap,\n): TextureHandle {\n  const id = `tex_${++counter}`;\n  registry.set(id, { source: image });\n  return { id };\n}\n\n/**\n * Register an image under an id its caller chose.\n * @internal\n */\nexport function registerTextureAs(\n  id: string,\n  image: HTMLImageElement | ImageBitmap,\n): TextureHandle {\n  registry.set(id, { source: image });\n  return { id };\n}\n\n/**\n * Drop a registered texture. Every renderer that uploaded it frees its GL\n * copy at the top of its next frame; a draw command still holding the handle\n * then draws nothing and warns. The image itself is the caller's to release.\n *\n * @returns Whether the handle was registered.\n */\nexport function unregisterTexture(handle: TextureHandle): boolean {\n  return registry.delete(handle.id);\n}\n"],"mappings":";;AAsBA,IAAIA,IAAU,GACRC,IAAWC,EAAgC,GAGpCC,IAA4CF,EAAS,YAmB5DG,IAAsD,CAAC;AAM7D,SAAgBC,EAAc,GAAgB,GAAmC;CAC/E,IAAMC,IAAQ;EAAE;EAAQ;CAAM;CAE9B,OADAF,EAAO,KAAKE,CAAK,SACJ;EACX,IAAMC,IAAIH,EAAO,QAAQE,CAAK;EAC9B,AAAIC,MAAM,MAAIH,EAAO,OAAOG,GAAG,CAAC;CAClC;AACF;AAEA,SAASC,EAAQ,GAAwC;CACvD,KAAK,IAAID,IAAI,GAAGA,IAAIH,EAAO,QAAQ,KACjC,IAAIK,EAAG,WAAWL,EAAOG,EAAE,CAAC,MAAM,GAAG,OAAOH,EAAOG,EAAE,CAAC;AAG1D;AAOA,SAAgBG,EAAW,GAAiC;CAC1D,IAAMC,IAAQP,EAAO,SAAS,IAAII,EAAQC,CAAE,IAAI,KAAA,GAC1CG,IAAMX,EAAS,IAAIQ,CAAE;CAO3B,OANIG,KACFD,GAAO,UAAUF,CAAE,GACZG,KAEJD,KACLA,EAAM,OAAOF,CAAE,GACRR,EAAS,IAAIQ,CAAE,KAAK,QAFR;AAGrB;AAWA,SAAgBI,EACd,GACe;CACf,IAAMJ,IAAK,OAAO,EAAET;CAEpB,OADAC,EAAS,IAAIQ,GAAI,EAAE,QAAQK,EAAM,CAAC,GAC3B,EAAE,MAAG;AACd;AAMA,SAAgBC,EACd,GACA,GACe;CAEf,OADAd,EAAS,IAAIQ,GAAI,EAAE,QAAQK,EAAM,CAAC,GAC3B,EAAE,MAAG;AACd;AASA,SAAgBE,EAAkB,GAAgC;CAChE,OAAOf,EAAS,OAAOgB,EAAO,EAAE;AAClC"}

package/dist/renderer.d.ts

@@ -1,31 +1,24 @@
-export { C as CullRect, D as DrawCommand, E as Effect, G as GroupDrawCommand, I as IDENTITY_COLOR_MATRIX, a as ImageDrawCommand, b as ImageMinification, P as PathDrawCommand, R as RenderOptions, c as RenderSpan, d as RenderSpanStats, e as RenderStats, f as RenderTarget, S as SPRITE_STRIDE, g as ShaderDrawCommand, h as SolidPaint, i as SpriteSheet, j as SpritesDrawCommand, k as StrokeOptions, T as TextDrawCommand, W as WeaselRenderer, l as WeaselRendererOptions, m as blur, n as buildGradientRamp, o as cullDrawCommands, p as frameRect, r as registerEffect, t as tessellateStroke, v as viewToMat3, q as vignette } from './builtins-C-VgUlWI.js';
-export { G as GlMat3, P as ProgramSource, S as ShaderCompileError, a as ShaderProgramHandle, b as ShaderUniform, m as mat3, p as programSourceRegistry, r as registerProgram } from './registerProgram-BMZRDgrh.js';
+export { C as CullRect, D as DrawCommand, E as Effect, G as GroupDrawCommand, I as IDENTITY_COLOR_MATRIX, a as ImageDrawCommand, b as ImageMinification, P as PathDrawCommand, R as RenderOptions, c as RenderSpan, d as RenderSpanStats, e as RenderStats, f as RenderTarget, S as SPRITE_STRIDE, g as ShaderDrawCommand, h as SolidPaint, i as SpriteSheet, j as SpritesDrawCommand, k as StrokeOptions, T as TextDrawCommand, W as WeaselRenderer, l as WeaselRendererOptions, m as blur, n as buildGradientRamp, o as cullDrawCommands, p as frameRect, r as registerEffect, q as releaseImageSource, t as tessellateStroke, v as viewToMat3, s as vignette } from './builtins-DPcdghtB.js';
+import { TextureHandle } from '@weasel-js/paint';
+export { CommandFill, CommandPaintUnits, CommandStroke, PosedFill, SolidFill, TextureHandle } from '@weasel-js/paint';
+export { G as GlMat3, P as ProgramSource, S as ShaderCompileError, a as ShaderProgramHandle, b as ShaderUniform, m as mat3, p as programSourceRegistry, r as registerProgram } from './registerProgram-T9S_PfAX.js';
 export { Mesh, TessellateOptions, tessellate } from '@weasel-js/geom/tessellate';
 export { RegisterFontOptions, canQueryLocalFonts, cssFontFamily, cssFontFamilyLoading, enableLocalFontOutlines, fontOutlineRegistry, fontRegistry, hasFontOutlines, isCanvasFont, listFontOutlines, loadFontOutlines, outlineStatus, registerCanvasFont, registerFont, registerFontOutlines, subscribeGlyphReady, unregisterCanvasFont, unregisterFontOutlines } from '@weasel-js/font';
-import { TextureHandle } from '@weasel-js/paint';
-export { TextureHandle } from '@weasel-js/paint';
 import { Reflection } from '@weasel-js/registry';
 export { View as ViewLike } from '@weasel-js/routing';
 import '@weasel-js/geom';
-import 'react';
-import '@weasel-js/history';
-import './types-A37hYkeR.js';
 import '@weasel-js/text';
-import './poseDescriptor-D-OH-tu5.js';
-import '@weasel-js/routing/react';
-import './types-B_9g6hMM.js';
-import '@weasel-js/cursor';
-import '@weasel-js/gestures';
 
 /**
  * registerTexture — accepts an image source, assigns an opaque id, stores in
  * a module-level registry. Actual GL upload happens lazily at draw time in
  * drawShader() via GLTextureCache.upload (which is idempotent).
  *
- * Lifecycle: textures live for the renderer's lifetime. No unregister in v1.
+ * Lifecycle: a texture lives until `unregisterTexture`. Each renderer frees
+ * its own GL copy at the top of its next frame.
  *
  * Convention §9: this registry stores image data only — no per-renderer state.
- * Each WeaselRenderer's GLTextureCache does its own dedup via has(id).
+ * Each WeaselRenderer's GLTextureCache does its own dedup by id and source.
  */
 
 /** A registered texture's image source, uploaded to GL lazily at first draw. */
@@ -44,6 +37,14 @@ declare const textureRegistry: Reflection<TextureEntry>;
  * @returns      Opaque TextureHandle.
  */
 declare function registerTexture(image: HTMLImageElement | ImageBitmap): TextureHandle;
+/**
+ * Drop a registered texture. Every renderer that uploaded it frees its GL
+ * copy at the top of its next frame; a draw command still holding the handle
+ * then draws nothing and warns. The image itself is the caller's to release.
+ *
+ * @returns Whether the handle was registered.
+ */
+declare function unregisterTexture(handle: TextureHandle): boolean;
 
 /**
  * On-screen glyph size (CSS px) at or above which a face with registered
@@ -88,4 +89,4 @@ declare const EFFECT_VERT_SRC = "#version 300 es\nin vec2 a_position;\nin vec2 a
  *  redeclare them with different meanings; it may leave any of them out. */
 declare const EFFECT_KIT_UNIFORMS: readonly ["u_source", "u_resolution", "u_texel"];
 
-export { EFFECT_KIT_UNIFORMS, EFFECT_VERT_SRC, OUTLINE_MIN_SCREEN_PX, type TextureEntry, registerTexture, textureRegistry };
+export { EFFECT_KIT_UNIFORMS, EFFECT_VERT_SRC, OUTLINE_MIN_SCREEN_PX, type TextureEntry, registerTexture, textureRegistry, unregisterTexture };

package/dist/renderer.js

@@ -1,18 +1,19 @@
 import { ShaderCompileError as e } from "./renderer/shaders/ShaderProgram.js";
-import { buildGradientRamp as t } from "./renderer/cache/GradientRampAtlas.js";
-import { mat3 as n } from "./renderer/math/mat3.js";
-import { IDENTITY_COLOR_MATRIX as r } from "./renderer/state/GroupState.js";
-import { registerTexture as i, textureRegistry as a } from "./renderer/textures/registerTexture.js";
-import { programSourceRegistry as o, registerProgram as s } from "./renderer/shaders/registerProgram.js";
-import { SPRITE_STRIDE as c } from "./renderer/DrawCommand.js";
-import { tessellateStroke as l } from "./features/paths/tessellate/stroke.js";
+import { registerTexture as t, textureRegistry as n, unregisterTexture as r } from "./renderer/textures/registerTexture.js";
+import { releaseImageSource as i } from "./renderer/cache/GLImageCache.js";
+import { buildGradientRamp as a } from "./renderer/cache/GradientRampAtlas.js";
+import { mat3 as o } from "./renderer/math/mat3.js";
+import { IDENTITY_COLOR_MATRIX as s } from "./renderer/state/GroupState.js";
+import { programSourceRegistry as c, registerProgram as l } from "./renderer/shaders/registerProgram.js";
 import { EFFECT_KIT_UNIFORMS as u, EFFECT_VERT_SRC as d } from "./renderer/effects/effectPrelude.js";
-import { OUTLINE_MIN_SCREEN_PX as f } from "./renderer/draw.js";
-import { WeaselRenderer as p } from "./renderer/WeaselRenderer.js";
-import { frameRect as m } from "./renderer/spriteSheet.js";
-import { viewToMat3 as h } from "./renderer/math/viewToMat3.js";
-import { cullDrawCommands as g } from "./renderer/cullDrawCommands.js";
-import { registerEffect as _ } from "./renderer/effects/types.js";
-import { blur as v, vignette as y } from "./renderer/effects/builtins.js";
-import { canQueryLocalFonts as b, cssFontFamily as x, cssFontFamilyLoading as S, enableLocalFontOutlines as C, fontOutlineRegistry as w, fontRegistry as T, hasFontOutlines as E, isCanvasFont as D, listFontOutlines as O, loadFontOutlines as k, outlineStatus as A, registerCanvasFont as j, registerFont as M, registerFontOutlines as N, subscribeGlyphReady as P, tessellate as F, unregisterCanvasFont as I, unregisterFontOutlines as L } from "./renderer/index.js";
-export { u as EFFECT_KIT_UNIFORMS, d as EFFECT_VERT_SRC, r as IDENTITY_COLOR_MATRIX, f as OUTLINE_MIN_SCREEN_PX, c as SPRITE_STRIDE, e as ShaderCompileError, p as WeaselRenderer, v as blur, t as buildGradientRamp, b as canQueryLocalFonts, x as cssFontFamily, S as cssFontFamilyLoading, g as cullDrawCommands, C as enableLocalFontOutlines, w as fontOutlineRegistry, T as fontRegistry, m as frameRect, E as hasFontOutlines, D as isCanvasFont, O as listFontOutlines, k as loadFontOutlines, n as mat3, A as outlineStatus, o as programSourceRegistry, j as registerCanvasFont, _ as registerEffect, M as registerFont, N as registerFontOutlines, s as registerProgram, i as registerTexture, P as subscribeGlyphReady, F as tessellate, l as tessellateStroke, a as textureRegistry, I as unregisterCanvasFont, L as unregisterFontOutlines, h as viewToMat3, y as vignette };
+import { tessellateStroke as f } from "./features/paths/tessellate/stroke.js";
+import { OUTLINE_MIN_SCREEN_PX as p } from "./renderer/draw/text.js";
+import { SPRITE_STRIDE as m } from "./renderer/DrawCommand.js";
+import { WeaselRenderer as h } from "./renderer/WeaselRenderer.js";
+import { frameRect as g } from "./renderer/spriteSheet.js";
+import { viewToMat3 as _ } from "./renderer/math/viewToMat3.js";
+import { cullDrawCommands as v } from "./renderer/cullDrawCommands.js";
+import { registerEffect as y } from "./renderer/effects/types.js";
+import { blur as b, vignette as x } from "./renderer/effects/builtins.js";
+import { canQueryLocalFonts as S, cssFontFamily as C, cssFontFamilyLoading as w, enableLocalFontOutlines as T, fontOutlineRegistry as E, fontRegistry as D, hasFontOutlines as O, isCanvasFont as k, listFontOutlines as A, loadFontOutlines as j, outlineStatus as M, registerCanvasFont as N, registerFont as P, registerFontOutlines as F, subscribeGlyphReady as I, tessellate as L, unregisterCanvasFont as R, unregisterFontOutlines as z } from "./renderer/index.js";
+export { u as EFFECT_KIT_UNIFORMS, d as EFFECT_VERT_SRC, s as IDENTITY_COLOR_MATRIX, p as OUTLINE_MIN_SCREEN_PX, m as SPRITE_STRIDE, e as ShaderCompileError, h as WeaselRenderer, b as blur, a as buildGradientRamp, S as canQueryLocalFonts, C as cssFontFamily, w as cssFontFamilyLoading, v as cullDrawCommands, T as enableLocalFontOutlines, E as fontOutlineRegistry, D as fontRegistry, g as frameRect, O as hasFontOutlines, k as isCanvasFont, A as listFontOutlines, j as loadFontOutlines, o as mat3, M as outlineStatus, c as programSourceRegistry, N as registerCanvasFont, y as registerEffect, P as registerFont, F as registerFontOutlines, l as registerProgram, t as registerTexture, i as releaseImageSource, I as subscribeGlyphReady, L as tessellate, f as tessellateStroke, n as textureRegistry, R as unregisterCanvasFont, z as unregisterFontOutlines, r as unregisterTexture, _ as viewToMat3, x as vignette };

package/dist/resize.d.ts

@@ -1,11 +1,10 @@
-export { C as CORNER_ANCHORS, a as CornerAnchor, b as CornerHandle, U as UseResizeOptions, c as cornerPoint, d as cornerResizeHandles, f as fixedCornerOf, h as hitCornerHandle } from './cornerHandles-BCrDp_mH.js';
-export { P as PoseDescriptor, R as RECT_POSE_DESCRIPTOR, a as ROTATED_POSE_DESCRIPTOR, p as poseDescriptorForNode } from './poseDescriptor-D-OH-tu5.js';
-import { B as BoundsConstraint } from './types-B_9g6hMM.js';
+export { C as CORNER_ANCHORS, a as CornerAnchor, b as CornerHandle, U as UseResizeOptions, c as cornerPoint, d as cornerResizeHandles, f as fixedCornerOf, h as hitCornerHandle } from './cornerHandles-CtCb8a3G.js';
+export { A as AUTO_POSE_DESCRIPTOR, P as PoseDescriptor, R as RECT_POSE_DESCRIPTOR, a as ROTATED_POSE_DESCRIPTOR, i as isPathLike, b as isRectPose, p as poseDescriptorForNode } from './autoPoseDescriptor-Ct7yqivU.js';
+import { B as BoundsConstraint } from './types-B4iJRHC3.js';
 import { Bounds, ModifierState } from '@weasel-js/routing';
-export { A as AUTO_POSE_DESCRIPTOR, i as isPathLike, a as isRectPose } from './autoPoseDescriptor-vCdt55xm.js';
-import './types-A37hYkeR.js';
-import '@weasel-js/history';
 import '@weasel-js/geom';
+import './types-k-5Oqh-U.js';
+import '@weasel-js/history';
 
 /** Resize constraint that stops a node shrinking past a minimum. The anchored
  *  edge stays put, so clamping pushes the dragged edge back rather than moving

package/dist/resize.js

@@ -1,7 +1,7 @@
 import { RECT_POSE_DESCRIPTOR as e, ROTATED_POSE_DESCRIPTOR as t, poseDescriptorForNode as n } from "./core/geometry/poseDescriptor.js";
 import { AUTO_POSE_DESCRIPTOR as r, isPathLike as i, isRectPose as a } from "./interactions/actions/resize/autoPoseDescriptor.js";
-import { clampMinSize as o } from "./interactions/actions/resize/behaviors/clampMinSize.js";
-import { lockAspectWithModifier as s } from "./interactions/actions/resize/behaviors/lockAspect.js";
-import { DEFAULT_RESIZE_BEHAVIORS as c } from "./interactions/actions/resize/behaviors/index.js";
-import { CORNER_ANCHORS as l, cornerPoint as u, cornerResizeHandles as d, fixedCornerOf as f, hitCornerHandle as p } from "./interactions/actions/resize/cornerHandles.js";
-export { r as AUTO_POSE_DESCRIPTOR, l as CORNER_ANCHORS, c as DEFAULT_RESIZE_BEHAVIORS, e as RECT_POSE_DESCRIPTOR, t as ROTATED_POSE_DESCRIPTOR, o as clampMinSize, u as cornerPoint, d as cornerResizeHandles, f as fixedCornerOf, p as hitCornerHandle, i as isPathLike, a as isRectPose, s as lockAspectWithModifier, n as poseDescriptorForNode };
+import { CORNER_ANCHORS as o, cornerPoint as s, cornerResizeHandles as c, fixedCornerOf as l, hitCornerHandle as u } from "./interactions/actions/resize/cornerHandles.js";
+import { clampMinSize as d } from "./interactions/actions/resize/behaviors/clampMinSize.js";
+import { lockAspectWithModifier as f } from "./interactions/actions/resize/behaviors/lockAspect.js";
+import { DEFAULT_RESIZE_BEHAVIORS as p } from "./interactions/actions/resize/behaviors/index.js";
+export { r as AUTO_POSE_DESCRIPTOR, o as CORNER_ANCHORS, p as DEFAULT_RESIZE_BEHAVIORS, e as RECT_POSE_DESCRIPTOR, t as ROTATED_POSE_DESCRIPTOR, d as clampMinSize, s as cornerPoint, c as cornerResizeHandles, l as fixedCornerOf, u as hitCornerHandle, i as isPathLike, a as isRectPose, f as lockAspectWithModifier, n as poseDescriptorForNode };

package/dist/style.css

@@ -1,2 +1,2 @@
-._numeric_zns9n_4{font-family:var(--wzl-font-numeric);font-variant-numeric:tabular-nums}._hud_1hv8c_3{z-index:10000;color:#e8e8e8;pointer-events:none;text-align:right;background:#000000b3;border-radius:4px;padding:6px 8px;font:11px/1.4 ui-monospace,SFMono-Regular,Menlo,monospace;position:fixed}._sized_1hv8c_17{min-width:120px;max-width:260px}._readings_1hv8c_22{grid-template-columns:auto auto;column-gap:8px;margin:0;display:grid}._readings_1hv8c_22 dt{text-align:left}._readings_1hv8c_22 dd{white-space:nowrap;margin:0}._muted_1hv8c_39{color:#888}._absent_1hv8c_44{color:#888;font-style:italic}._header_1hv8c_49{margin-bottom:2px}._list_1hv8c_53{flex-direction:column;gap:1px;margin:0;padding:0;list-style:none;display:flex}._item_1hv8c_62{white-space:nowrap;text-overflow:ellipsis;overflow:hidden}._itemBest_1hv8c_68{font-weight:700}._row_1hv8c_72{white-space:nowrap;justify-content:flex-end;gap:8px;display:flex}._stack_1hv8c_79{flex-direction:column;align-items:flex-end;display:flex}
+._numeric_25fd0b{font-family:var(--wzl-font-numeric);font-variant-numeric:tabular-nums}._hud_4467cb{z-index:900;color:#e8e8e8;pointer-events:none;text-align:right;background:#000000b3;border-radius:4px;padding:6px 8px;font:11px/1.4 ui-monospace,SFMono-Regular,Menlo,monospace;position:fixed}._sized_4467cb{min-width:120px;max-width:260px}._readings_4467cb{grid-template-columns:auto auto;column-gap:8px;margin:0;display:grid}._readings_4467cb dt{text-align:left}._readings_4467cb dd{white-space:nowrap;margin:0}._muted_4467cb{color:#888}._absent_4467cb{color:#888;font-style:italic}._header_4467cb{margin-bottom:2px}._list_4467cb{flex-direction:column;gap:1px;margin:0;padding:0;list-style:none;display:flex}._item_4467cb{white-space:nowrap;text-overflow:ellipsis;overflow:hidden}._itemBest_4467cb{font-weight:700}._row_4467cb{white-space:nowrap;justify-content:flex-end;gap:8px;display:flex}._stack_4467cb{flex-direction:column;align-items:flex-end;display:flex}
 /*$vite$:1*/

package/dist/test-hook/install.js

@@ -1,12 +1,18 @@
 import { createTestHook as e } from "./createTestHook.js";
 //#region src/test-hook/install.ts
-function t(t) {
-	if (typeof window > "u" || typeof process < "u" && process.env.NODE_ENV === "production" || new URLSearchParams(window.location.search).get("test") !== "1") return null;
-	if (window.__weaselTest) return window.__weaselTest;
-	let n = e(t);
-	return window.__weaselTest = n, n;
+var t = [];
+function n(n) {
+	if (typeof window > "u" || typeof process < "u" && process.env.NODE_ENV === "production" || new URLSearchParams(window.location.search).get("test") !== "1" || window.__weaselTest && window.__weaselTest !== t[0]) return null;
+	let r = e(n);
+	return t.push(r), window.__weaselTest = t[0], r;
+}
+function r(e) {
+	let n = t.indexOf(e);
+	if (n < 0) return;
+	let r = typeof window < "u" && window.__weaselTest === e;
+	t.splice(n, 1), r && (t.length > 0 ? window.__weaselTest = t[0] : delete window.__weaselTest);
 }
 //#endregion
-export { t as installTestHookIfRequested };
+export { n as installTestHookIfRequested, r as releaseTestHook };
 
 //# sourceMappingURL=install.js.map

package/dist/test-hook/install.js.map

@@ -1 +1 @@
-{"version":3,"file":"install.js","names":["installTestHookIfRequested","hook","createTestHook","refs"],"sources":["../../src/test-hook/install.ts"],"sourcesContent":["// src/test-hook/install.ts\nimport { createTestHook } from './createTestHook';\nimport type { TestHookRefs, WeaselTestHook } from './types';\n\n/** Attach `window.__weaselTest` and return the hook iff\n *    - `process.env.NODE_ENV !== 'production'` (never in production consumer\n *      builds — paired with a call-site gate in SceneCanvas so the entire\n *      module DCEs out), AND\n *    - the URL contains `?test=1`.\n *  Otherwise returns null and does not touch `window`. */\nexport function installTestHookIfRequested(refs: TestHookRefs): WeaselTestHook | null {\n  if (typeof window === 'undefined') return null;\n  // Defense in depth: even if the call-site gate is bypassed, never expose\n  // the hook in production.\n  if (typeof process !== 'undefined' && process.env?.NODE_ENV === 'production') return null;\n  const params = new URLSearchParams(window.location.search);\n  if (params.get('test') !== '1') return null;\n  // If a hook is already installed (HMR), keep it.\n  if (window.__weaselTest) return window.__weaselTest;\n  const hook = createTestHook(refs);\n  window.__weaselTest = hook;\n  return hook;\n}\n"],"mappings":";;AAUA,SAAgBA,EAA2B,GAA2C;CAMpF,IALI,OAAO,SAAW,OAGlB,OAAO,UAAY,OAAA,QAAA,IAAA,aAAyC,gBAE5D,IADe,gBAAgB,OAAO,SAAS,MAC/C,CAAA,CAAO,IAAI,MAAM,MAAM,KAAK,OAAO;CAEvC,IAAI,OAAO,cAAc,OAAO,OAAO;CACvC,IAAMC,IAAOC,EAAeC,CAAI;CAEhC,OADA,OAAO,eAAeF,GACfA;AACT"}
+{"version":3,"file":"install.js","names":["live","installTestHookIfRequested","hook","createTestHook","refs","releaseTestHook","i","owned"],"sources":["../../src/test-hook/install.ts"],"sourcesContent":["// src/test-hook/install.ts\nimport { createTestHook } from './createTestHook';\nimport type { TestHookRefs, WeaselTestHook } from './types';\n\n/** Hooks of the canvases mounted now, oldest first. `window.__weaselTest` is the first. */\nconst live: WeaselTestHook[] = [];\n\n/** Make a hook for this canvas and return it iff\n *    - `process.env.NODE_ENV !== 'production'` (never in production consumer\n *      builds — paired with a call-site gate in SceneCanvas so the entire\n *      module DCEs out), AND\n *    - the URL contains `?test=1`, AND\n *    - `window.__weaselTest` is not held by something other than a canvas.\n *  Otherwise returns null and does not touch `window`. `window.__weaselTest`\n *  answers for the earliest canvas still mounted; the caller hands its hook to\n *  `releaseTestHook` when it unmounts. */\nexport function installTestHookIfRequested(refs: TestHookRefs): WeaselTestHook | null {\n  if (typeof window === 'undefined') return null;\n  // Defense in depth: even if the call-site gate is bypassed, never expose\n  // the hook in production.\n  if (typeof process !== 'undefined' && process.env?.NODE_ENV === 'production') return null;\n  const params = new URLSearchParams(window.location.search);\n  if (params.get('test') !== '1') return null;\n  if (window.__weaselTest && window.__weaselTest !== live[0]) return null;\n  const hook = createTestHook(refs);\n  live.push(hook);\n  window.__weaselTest = live[0];\n  return hook;\n}\n\n/** Drop `hook`; if it held `window.__weaselTest`, the next canvas's hook takes over. */\nexport function releaseTestHook(hook: WeaselTestHook): void {\n  const i = live.indexOf(hook);\n  if (i < 0) return;\n  const owned = typeof window !== 'undefined' && window.__weaselTest === hook;\n  live.splice(i, 1);\n  if (!owned) return;\n  if (live.length > 0) window.__weaselTest = live[0];\n  else delete window.__weaselTest;\n}\n"],"mappings":";;AAKA,IAAMA,IAAyB,CAAC;AAWhC,SAAgBC,EAA2B,GAA2C;CAOpF,IANI,OAAO,SAAW,OAGlB,OAAO,UAAY,OAAA,QAAA,IAAA,aAAyC,gBAE5D,IADe,gBAAgB,OAAO,SAAS,MAC/C,CAAA,CAAO,IAAI,MAAM,MAAM,OACvB,OAAO,gBAAgB,OAAO,iBAAiBD,EAAK,IAAI,OAAO;CACnE,IAAME,IAAOC,EAAeC,CAAI;CAGhC,OAFAJ,EAAK,KAAKE,CAAI,GACd,OAAO,eAAeF,EAAK,IACpBE;AACT;AAGA,SAAgBG,EAAgB,GAA4B;CAC1D,IAAMC,IAAIN,EAAK,QAAQE,CAAI;CAC3B,IAAII,IAAI,GAAG;CACX,IAAMC,IAAQ,OAAO,SAAW,OAAe,OAAO,iBAAiBL;CAEvE,AADAF,EAAK,OAAOM,GAAG,CAAC,GACXC,MACDP,EAAK,SAAS,IAAG,OAAO,eAAeA,EAAK,KAC3C,OAAO,OAAO;AACrB"}

package/dist/{test-seams-CuIxe0xY.d.ts → test-seams-DM2B87-g.d.ts}

@@ -1,7 +1,7 @@
-import { FillStyle, GradientUnits, GradStop, ColorSpace, MarkerKey, Stroke } from '@weasel-js/paint';
+import { FillStyle, PosedFill, GradientUnits, GradStop, ColorSpace, MarkerKey, Stroke } from '@weasel-js/paint';
 import { ComponentType } from 'react';
 import { Reflection } from '@weasel-js/registry';
-import { c as ShaderProgram, G as GlMat3, P as ProgramSource } from './registerProgram-BMZRDgrh.js';
+import { c as ShaderProgram, G as GlMat3, P as ProgramSource } from './registerProgram-T9S_PfAX.js';
 import { Path } from '@weasel-js/geom';
 
 /**
@@ -34,7 +34,7 @@ interface FillPoseBox {
  * so a non-square box cannot make it the ellipse SVG would — this keeps the
  * radius proportionate instead.
  */
-declare function fillInPoseFrame(fill: FillStyle, box: FillPoseBox): FillStyle;
+declare function fillInPoseFrame(fill: FillStyle, box: FillPoseBox): PosedFill;
 /**
  * Inverse of {@link fillInPoseFrame}: express a gradient already positioned
  * in `box`'s frame as `0..1` fractions of that box (`units: 'bounds'`), so
@@ -155,7 +155,7 @@ interface PaintKindEntry {
     id: string;
     label: string;
     /** Glyph naming this kind in an editor's kind bar, as an icon name the UI
-     *  layer resolves — the same indirection `ToolPrefBase.icon` uses. A kind
+     *  layer resolves — the same indirection `PrefBase.icon` uses. A kind
      *  without one is named by its `label`. */
     icon?: string;
     /** A paint of this kind seeded from a color — what an editor writes when a

package/dist/test-seams.d.ts

@@ -1,6 +1,6 @@
-export { _ as _resetMarkersForTests, z as _resetPaintKindsForTests } from './test-seams-CuIxe0xY.js';
+export { _ as _resetMarkersForTests, z as _resetPaintKindsForTests } from './test-seams-DM2B87-g.js';
 import '@weasel-js/paint';
 import 'react';
 import '@weasel-js/registry';
-import './registerProgram-BMZRDgrh.js';
+import './registerProgram-T9S_PfAX.js';
 import '@weasel-js/geom';

package/dist/tools/builtin/ellipse/useEllipseTool.js

@@ -9,6 +9,7 @@ function o(o = {}) {
 	let { behaviors: s } = o;
 	return r(() => e({
 		id: "ellipse",
+		keybinding: { key: "E" },
 		capabilities: ["creates-shapes"],
 		hookName: "useEllipseTool",
 		cursor: a("crosshairEllipse", { fallback: "crosshair" }),

package/dist/tools/builtin/ellipse/useEllipseTool.js.map

@@ -1 +1 @@
-{"version":3,"file":"useEllipseTool.js","names":["EllipseIcon","useEllipseTool","options","useMemo","defineTool","cursorFor","insertBindingBehaviors","behaviors"],"sources":["../../../../src/tools/builtin/ellipse/useEllipseTool.tsx"],"sourcesContent":["import { useMemo } from 'react';\nimport { defineTool } from '../../overlayBinding';\nimport { EllipseIcon } from '../../../icons';\nimport type { Tool } from '../../overlayBinding';\nimport { insertBindingBehaviors, type InsertToolOptions } from '../shared/insertToolOptions';\nimport { cursorFor } from '@weasel-js/cursor';\n\n/**\n * Drag-to-draw ellipse tool. Mirrors `useRectTool`: the `drag` binding\n * routes to `insertAction`, which owns the live preview and commits\n * through the `insert` dep. Alt toggles from-corner ⇄ from-center\n * mid-drag via the action's live modifier read.\n */\nexport function useEllipseTool(options: InsertToolOptions = {}): Tool<null> {\n  const { behaviors } = options;\n  return useMemo(\n    () =>\n      defineTool<null>({\n        id: 'ellipse',\n        capabilities: ['creates-shapes'],\n        hookName: 'useEllipseTool',\n        cursor: cursorFor('crosshairEllipse', { fallback: 'crosshair' }),\n        presentation: {\n          label: 'Ellipse',\n          group: 'shape',\n          icon: <EllipseIcon />,\n        },\n        bindings: [\n          {\n            spec: { kind: 'drag' },\n            actionId: 'insert',\n            opts: { params: { kind: 'ellipse' } , ...insertBindingBehaviors(behaviors) },\n          },\n        ],\n      }),\n    [behaviors],\n  );\n}\n"],"mappings":";;;;;;;AAaA,SAAgBC,EAAe,IAA6B,CAAC,GAAe;CAC1E,IAAM,EAAE,iBAAcC;CACtB,OAAOC,QAEHC,EAAiB;EACf,IAAI;EACJ,cAAc,CAAC,gBAAgB;EAC/B,UAAU;EACV,QAAQC,EAAU,oBAAoB,EAAE,UAAU,YAAY,CAAC;EAC/D,cAAc;GACZ,OAAO;GACP,OAAO;GACP,MAAM,kBAACL,GAAD,CAAc,CAAA;EACtB;EACA,UAAU,CACR;GACE,MAAM,EAAE,MAAM,OAAO;GACrB,UAAU;GACV,MAAM;IAAE,QAAQ,EAAE,MAAM,UAAU;IAAI,GAAGM,EAAuBC,CAAS;GAAE;EAC7E,CACF;CACF,CAAC,GACH,CAACA,CAAS,CACZ;AACF"}
+{"version":3,"file":"useEllipseTool.js","names":["EllipseIcon","useEllipseTool","options","useMemo","defineTool","cursorFor","insertBindingBehaviors","behaviors"],"sources":["../../../../src/tools/builtin/ellipse/useEllipseTool.tsx"],"sourcesContent":["import { useMemo } from 'react';\nimport { defineTool } from '../../overlayBinding';\nimport { EllipseIcon } from '../../../icons';\nimport type { Tool } from '../../overlayBinding';\nimport { insertBindingBehaviors, type InsertToolOptions } from '../shared/insertToolOptions';\nimport { cursorFor } from '@weasel-js/cursor';\n\n/**\n * Drag-to-draw ellipse tool. Mirrors `useRectTool`: the `drag` binding\n * routes to `insertAction`, which owns the live preview and commits\n * through the `insert` dep. Alt toggles from-corner ⇄ from-center\n * mid-drag via the action's live modifier read.\n */\nexport function useEllipseTool(options: InsertToolOptions = {}): Tool<null> {\n  const { behaviors } = options;\n  return useMemo(\n    () =>\n      defineTool<null>({\n        id: 'ellipse',\n        keybinding: { key: 'E' },\n        capabilities: ['creates-shapes'],\n        hookName: 'useEllipseTool',\n        cursor: cursorFor('crosshairEllipse', { fallback: 'crosshair' }),\n        presentation: {\n          label: 'Ellipse',\n          group: 'shape',\n          icon: <EllipseIcon />,\n        },\n        bindings: [\n          {\n            spec: { kind: 'drag' },\n            actionId: 'insert',\n            opts: { params: { kind: 'ellipse' } , ...insertBindingBehaviors(behaviors) },\n          },\n        ],\n      }),\n    [behaviors],\n  );\n}\n"],"mappings":";;;;;;;AAaA,SAAgBC,EAAe,IAA6B,CAAC,GAAe;CAC1E,IAAM,EAAE,iBAAcC;CACtB,OAAOC,QAEHC,EAAiB;EACf,IAAI;EACJ,YAAY,EAAE,KAAK,IAAI;EACvB,cAAc,CAAC,gBAAgB;EAC/B,UAAU;EACV,QAAQC,EAAU,oBAAoB,EAAE,UAAU,YAAY,CAAC;EAC/D,cAAc;GACZ,OAAO;GACP,OAAO;GACP,MAAM,kBAACL,GAAD,CAAc,CAAA;EACtB;EACA,UAAU,CACR;GACE,MAAM,EAAE,MAAM,OAAO;GACrB,UAAU;GACV,MAAM;IAAE,QAAQ,EAAE,MAAM,UAAU;IAAI,GAAGM,EAAuBC,CAAS;GAAE;EAC7E,CACF;CACF,CAAC,GACH,CAACA,CAAS,CACZ;AACF"}

package/dist/tools/builtin/hand/useHandTool.js

@@ -7,6 +7,7 @@ function a(a = {}) {
 	let o = i(a);
 	return r(() => Object.assign(e({
 		id: "hand",
+		keybinding: { key: "H" },
 		capabilities: ["navigation"],
 		hotkey: "space",
 		hookName: "useHandTool",

package/dist/tools/builtin/hand/useHandTool.js.map

@@ -1 +1 @@
-{"version":3,"file":"useHandTool.js","names":["HandIcon","useHandTool","optsRef","useLatest","opts","useMemo","defineTool","createElement"],"sources":["../../../../src/tools/builtin/hand/useHandTool.ts"],"sourcesContent":["import { useMemo, createElement } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { defineTool } from '../../overlayBinding';\nimport type { Tool } from '../../overlayBinding';\nimport { HandIcon } from '../../../icons';\nimport type { View } from 'core/viewport/view';\nimport type { InertiaConfig } from 'core/viewport/useDecayLoop';\n\nexport type { InertiaConfig };\n\n/** Options for `useHandTool`. Both are forwarded to `viewport.dragPan` as\n *  binding params; momentum additionally needs a `view` dep publishing\n *  `decay`, which `<SceneCanvas>` wires. */\nexport interface UseHandToolOptions {\n  /** Momentum after release. Omit or pass `false` for none. */\n  inertia?: false | InertiaConfig;\n  /**\n   * Which axes the drag responds to. Default `'both'`.\n   *\n   * - `'both'` — pan both axes (default).\n   * - `'x'` — drag only changes `view.x`. Inertia (if enabled) also stays on x.\n   * - `'y'` — drag only changes `view.y`. Inertia stays on y.\n   *\n   * Locks drag panning to a single axis. The former `useWheelPanTool` /\n   * `useWheelZoomTool` / `useKeyboardZoomTool` axis option is dissolved.\n   */\n  axis?: 'both' | 'x' | 'y';\n}\n\n/** @internal */\ninterface HandScratch {\n  startView: View;\n  startScreenPoint: { x: number; y: number };\n}\n\n/**\n * Pan-on-drag tool. Registered in both the active slot (sticky, `H` key)\n * and the hotkey slot (momentary, hold `space`).\n *\n * Drag handlers compute pan deltas inline. View is read from ctx.view at\n * gesture start and written via ctx.setView on every move — so the tool\n * works with both controlled and uncontrolled Canvas viewport modes\n * without any extra wiring.\n *\n * Sign convention: dragging the mouse right moves the canvas content right\n * relative to the viewport — i.e. the camera moves *left*. So the new view\n * is `{ x: startView.x - dx, y: startView.y - dy }`.\n */\nexport function useHandTool(opts: UseHandToolOptions = {}): Tool<HandScratch | null> {\n  // Read through a ref from a params thunk rather than closing over the\n  // values: a consumer passing `inertia={{ friction: 0.9 }}` inline would\n  // otherwise mint a new tool identity on every render.\n  const optsRef = useLatest(opts);\n  return useMemo(\n    () =>\n      Object.assign(defineTool<HandScratch>({\n        id: 'hand',\n        capabilities: ['navigation'],\n        hotkey: 'space',\n        hookName: 'useHandTool',\n        presentation: {\n          label: 'Hand',\n          icon: createElement(HandIcon),\n          group: 'view',\n        },\n        cursor: 'grab',\n      }), {\n        // Declarative binding routes drag through the dispatcher +\n        // viewportDragPanAction, which also owns the grabbing cursor\n        // (`Action.activeCursor`) the tool used to declare as an `engaged`\n        // phase entry.\n        bindings: [{\n          spec: { kind: 'drag' as const },\n          actionId: 'viewport.dragPan',\n          opts: {\n            params: () => ({\n              axis: optsRef.current.axis ?? 'both',\n              inertia: optsRef.current.inertia,\n            }),\n          },\n        }],\n      }) as Tool<HandScratch | null>,\n    [optsRef],\n  );\n}\n"],"mappings":";;;;;AAgDA,SAAgBC,EAAY,IAA2B,CAAC,GAA6B;CAInF,IAAMC,IAAUC,EAAUC,CAAI;CAC9B,OAAOC,QAEH,OAAO,OAAOC,EAAwB;EACpC,IAAI;EACJ,cAAc,CAAC,YAAY;EAC3B,QAAQ;EACR,UAAU;EACV,cAAc;GACZ,OAAO;GACP,MAAMC,EAAcP,CAAQ;GAC5B,OAAO;EACT;EACA,QAAQ;CACV,CAAC,GAAG,EAKF,UAAU,CAAC;EACT,MAAM,EAAE,MAAM,OAAgB;EAC9B,UAAU;EACV,MAAM,EACJ,eAAe;GACb,MAAME,EAAQ,QAAQ,QAAQ;GAC9B,SAASA,EAAQ,QAAQ;EAC3B,GACF;CACF,CAAC,EACH,CAAC,GACH,CAACA,CAAO,CACV;AACF"}
+{"version":3,"file":"useHandTool.js","names":["HandIcon","useHandTool","optsRef","useLatest","opts","useMemo","defineTool","createElement"],"sources":["../../../../src/tools/builtin/hand/useHandTool.ts"],"sourcesContent":["import { useMemo, createElement } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { defineTool } from '../../overlayBinding';\nimport type { Tool } from '../../overlayBinding';\nimport { HandIcon } from '../../../icons';\nimport type { InertiaConfig } from 'core/viewport/useDecayLoop';\n\nexport type { InertiaConfig };\n\n/** Options for `useHandTool`. Both are forwarded to `viewport.dragPan` as\n *  binding params; momentum additionally needs a `view` dep publishing\n *  `decay`, which `<SceneCanvas>` wires. */\nexport interface UseHandToolOptions {\n  /** Momentum after release. Omit or pass `false` for none. */\n  inertia?: false | InertiaConfig;\n  /**\n   * Which axes the drag responds to. Default `'both'`.\n   *\n   * - `'both'` — pan both axes (default).\n   * - `'x'` — drag only changes `view.x`. Inertia (if enabled) also stays on x.\n   * - `'y'` — drag only changes `view.y`. Inertia stays on y.\n   *\n   * Locks drag panning to a single axis. The former `useWheelPanTool` /\n   * `useWheelZoomTool` / `useKeyboardZoomTool` axis option is dissolved.\n   */\n  axis?: 'both' | 'x' | 'y';\n}\n\n/**\n * Pan-on-drag tool. Registered in both the active slot (sticky, `H` key)\n * and the hotkey slot (momentary, hold `space`).\n *\n * A declarative shell: its one binding routes a drag to the\n * `viewport.dragPan` action, which owns the gesture, the view writes, and\n * the grabbing cursor. The tool only passes `axis` and `inertia` along.\n */\nexport function useHandTool(opts: UseHandToolOptions = {}): Tool<null> {\n  // Read through a ref from a params thunk rather than closing over the\n  // values: a consumer passing `inertia={{ friction: 0.9 }}` inline would\n  // otherwise mint a new tool identity on every render.\n  const optsRef = useLatest(opts);\n  return useMemo(\n    () =>\n      Object.assign(defineTool<null>({\n        id: 'hand',\n        keybinding: { key: 'H' },\n        capabilities: ['navigation'],\n        hotkey: 'space',\n        hookName: 'useHandTool',\n        presentation: {\n          label: 'Hand',\n          icon: createElement(HandIcon),\n          group: 'view',\n        },\n        cursor: 'grab',\n      }), {\n        // Declarative binding routes drag through the dispatcher +\n        // viewportDragPanAction, which also owns the grabbing cursor\n        // (`Action.activeCursor`) the tool used to declare as an `engaged`\n        // phase entry.\n        bindings: [{\n          spec: { kind: 'drag' as const },\n          actionId: 'viewport.dragPan',\n          opts: {\n            params: () => ({\n              axis: optsRef.current.axis ?? 'both',\n              inertia: optsRef.current.inertia,\n            }),\n          },\n        }],\n      }) as Tool<null>,\n    [optsRef],\n  );\n}\n"],"mappings":";;;;;AAoCA,SAAgBC,EAAY,IAA2B,CAAC,GAAe;CAIrE,IAAMC,IAAUC,EAAUC,CAAI;CAC9B,OAAOC,QAEH,OAAO,OAAOC,EAAiB;EAC7B,IAAI;EACJ,YAAY,EAAE,KAAK,IAAI;EACvB,cAAc,CAAC,YAAY;EAC3B,QAAQ;EACR,UAAU;EACV,cAAc;GACZ,OAAO;GACP,MAAMC,EAAcP,CAAQ;GAC5B,OAAO;EACT;EACA,QAAQ;CACV,CAAC,GAAG,EAKF,UAAU,CAAC;EACT,MAAM,EAAE,MAAM,OAAgB;EAC9B,UAAU;EACV,MAAM,EACJ,eAAe;GACb,MAAME,EAAQ,QAAQ,QAAQ;GAC9B,SAASA,EAAQ,QAAQ;EAC3B,GACF;CACF,CAAC,EACH,CAAC,GACH,CAACA,CAAO,CACV;AACF"}

package/dist/tools/builtin/lasso/useLassoTool.js

@@ -3,16 +3,16 @@ import t from "../../../icons/LassoIcon.js";
 import { createElement as n, useMemo as r } from "react";
 import { useLatest as i } from "@weasel-js/react";
 //#region src/tools/builtin/lasso/useLassoTool.ts
-function a(a, o = {}) {
-	let s = i({
-		mode: o.mode ?? "intersect",
-		...o.minVertexSpacing === void 0 ? {} : { minVertexSpacing: o.minVertexSpacing }
-	}), { behaviors: c } = o;
+function a(a = {}) {
+	let o = i({
+		mode: a.mode ?? "intersect",
+		...a.minVertexSpacing === void 0 ? {} : { minVertexSpacing: a.minVertexSpacing }
+	}), { behaviors: s } = a;
 	return r(() => e({
 		id: "lasso",
 		capabilities: ["creates-selection"],
 		hookName: "useLassoTool",
-		...o.keybinding === null ? {} : { keybinding: o.keybinding ?? { key: "L" } },
+		...a.keybinding === null ? {} : { keybinding: a.keybinding ?? { key: "L" } },
 		cursor: "crosshair",
 		presentation: {
 			label: "Lasso",
@@ -26,14 +26,14 @@ function a(a, o = {}) {
 			},
 			actionId: "lassoSelect",
 			opts: {
-				params: () => s.current,
-				...c ? { behaviors: c } : {}
+				params: () => o.current,
+				...s ? { behaviors: s } : {}
 			}
 		}]
 	}), [
-		o.keybinding,
-		c,
-		s
+		a.keybinding,
+		s,
+		o
 	]);
 }
 //#endregion

package/dist/tools/builtin/lasso/useLassoTool.js.map

@@ -1 +1 @@
-{"version":3,"file":"useLassoTool.js","names":["LassoIcon","useLassoTool","paramsRef","useLatest","options","useMemo","defineTool","createElement","behaviors"],"sources":["../../../../src/tools/builtin/lasso/useLassoTool.ts"],"sourcesContent":["import { useMemo, createElement } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { defineTool } from '../../overlayBinding';\nimport { LassoIcon } from '../../../icons';\nimport type { Tool } from '../../overlayBinding';\nimport type { UseLassoSelectOptions } from 'interactions/actions/lasso-select/options';\nimport type { LassoHitMode, LassoSelectAdapter } from 'core/adapters/types';\nimport type { ToolKeybinding } from '@weasel-js/routing';\n\n/** Options for `useLassoTool` — the lasso-select action's options plus the\n *  tool's own hit mode and activation key. */\nexport interface UseLassoToolOptions extends UseLassoSelectOptions {\n  /** Hit mode for the action's own selection commit, which runs when no\n   *  behavior claims the gesture. A behavior carries its own, as\n   *  `selectFromLasso({ mode })` does. Default 'intersect'. */\n  mode?: LassoHitMode;\n  /** Override the default keybinding (`{ key: 'L' }`). Pass `null` to omit. */\n  keybinding?: ToolKeybinding | null;\n}\n\n/** Free-form polygon select Tool. Drag is handled entirely by the gesture\n *  dispatcher via the `lassoSelect` action binding below; the dispatcher\n *  overlay layer (`useDispatcherOverlayLayer`) paints the live polyline +\n *  dashed close-line while the gesture is in flight. Esc cancels through\n *  the dispatcher's standard cancel pipeline.\n *\n *  The legacy `useLassoSelect` hook is removed — all gesture\n *  state, overlay rendering, and selection commit live in\n *  `lassoSelectAction` (see `src/interactions/actions/defaults/lassoSelect.ts`). */\nexport function useLassoTool(\n  _adapter: LassoSelectAdapter,\n  options: UseLassoToolOptions = {},\n): Tool<undefined> {\n  const paramsRef = useLatest<{ mode: LassoHitMode; minVertexSpacing?: number }>({\n    mode: options.mode ?? 'intersect',\n    ...(options.minVertexSpacing !== undefined ? { minVertexSpacing: options.minVertexSpacing } : {}),\n  });\n  const { behaviors } = options;\n\n  return useMemo(() => {\n    return defineTool<undefined>({\n      id: 'lasso',\n      capabilities: ['creates-selection'],\n      hookName: 'useLassoTool',\n      ...(options.keybinding === null ? {} : { keybinding: options.keybinding ?? { key: 'L' } }),\n      cursor: 'crosshair',\n      presentation: {\n        label: 'Lasso',\n        icon: createElement(LassoIcon),\n        group: 'select',\n      },\n      // Declarative drag binding for the new gesture dispatcher. The\n      // dispatcher invokes `lassoSelectAction`, which owns vertex buffering,\n      // overlay state, and the commit-on-end selection write.\n      bindings: [\n        {\n          spec: { kind: 'drag', mods: { shift: 'optional' } },\n          actionId: 'lassoSelect',\n          // Thunked so a mode or spacing change reaches the next gesture\n          // without rebuilding the tool.\n          opts: {\n            params: () => paramsRef.current,\n            ...(behaviors ? { behaviors } : {}),\n          },\n        },\n      ],\n    });\n  }, [options.keybinding, behaviors, paramsRef]);\n}\n"],"mappings":";;;;;AA6BA,SAAgBC,EACd,GACA,IAA+B,CAAC,GACf;CACjB,IAAMC,IAAYC,EAA6D;EAC7E,MAAMC,EAAQ,QAAQ;EACtB,GAAIA,EAAQ,qBAAqB,KAAA,IAA6D,CAAC,IAAlD,EAAE,kBAAkBA,EAAQ,iBAAiB;CAC5F,CAAC,GACK,EAAE,iBAAcA;CAEtB,OAAOC,QACEC,EAAsB;EAC3B,IAAI;EACJ,cAAc,CAAC,mBAAmB;EAClC,UAAU;EACV,GAAIF,EAAQ,eAAe,OAAO,CAAC,IAAI,EAAE,YAAYA,EAAQ,cAAc,EAAE,KAAK,IAAI,EAAE;EACxF,QAAQ;EACR,cAAc;GACZ,OAAO;GACP,MAAMG,EAAcP,CAAS;GAC7B,OAAO;EACT;EAIA,UAAU,CACR;GACE,MAAM;IAAE,MAAM;IAAQ,MAAM,EAAE,OAAO,WAAW;GAAE;GAClD,UAAU;GAGV,MAAM;IACJ,cAAcE,EAAU;IACxB,GAAIM,IAAY,EAAE,aAAU,IAAI,CAAC;GACnC;EACF,CACF;CACF,CAAC,GACA;EAACJ,EAAQ;EAAYI;EAAWN;CAAS,CAAC;AAC/C"}
+{"version":3,"file":"useLassoTool.js","names":["LassoIcon","useLassoTool","paramsRef","useLatest","options","useMemo","defineTool","createElement","behaviors"],"sources":["../../../../src/tools/builtin/lasso/useLassoTool.ts"],"sourcesContent":["import { useMemo, createElement } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { defineTool } from '../../overlayBinding';\nimport { LassoIcon } from '../../../icons';\nimport type { Tool } from '../../overlayBinding';\nimport type { UseLassoSelectOptions } from 'interactions/actions/lasso-select/options';\nimport type { LassoHitMode } from 'core/adapters/types';\nimport type { ToolKeybinding } from '@weasel-js/routing';\n\n/** Options for `useLassoTool` — the lasso-select action's options plus the\n *  tool's own hit mode and activation key. */\nexport interface UseLassoToolOptions extends UseLassoSelectOptions {\n  /** Hit mode for the action's own selection commit, which runs when no\n   *  behavior claims the gesture. A behavior carries its own, as\n   *  `selectFromLasso({ mode })` does. Default 'intersect'. */\n  mode?: LassoHitMode;\n  /** Override the default keybinding (`{ key: 'L' }`). Pass `null` to omit. */\n  keybinding?: ToolKeybinding | null;\n}\n\n/** Free-form polygon select Tool. Drag is handled entirely by the gesture\n *  dispatcher via the `lassoSelect` action binding below; the dispatcher\n *  overlay layer (`useDispatcherOverlayLayer`) paints the live polyline +\n *  dashed close-line while the gesture is in flight. Esc cancels through\n *  the dispatcher's standard cancel pipeline.\n *\n *  The legacy `useLassoSelect` hook is removed — all gesture\n *  state, overlay rendering, and selection commit live in\n *  `lassoSelectAction` (see `src/interactions/actions/defaults/lassoSelect.ts`). */\nexport function useLassoTool(options: UseLassoToolOptions = {}): Tool<undefined> {\n  const paramsRef = useLatest<{ mode: LassoHitMode; minVertexSpacing?: number }>({\n    mode: options.mode ?? 'intersect',\n    ...(options.minVertexSpacing !== undefined ? { minVertexSpacing: options.minVertexSpacing } : {}),\n  });\n  const { behaviors } = options;\n\n  return useMemo(() => {\n    return defineTool<undefined>({\n      id: 'lasso',\n      capabilities: ['creates-selection'],\n      hookName: 'useLassoTool',\n      ...(options.keybinding === null ? {} : { keybinding: options.keybinding ?? { key: 'L' } }),\n      cursor: 'crosshair',\n      presentation: {\n        label: 'Lasso',\n        icon: createElement(LassoIcon),\n        group: 'select',\n      },\n      // Declarative drag binding for the new gesture dispatcher. The\n      // dispatcher invokes `lassoSelectAction`, which owns vertex buffering,\n      // overlay state, and the commit-on-end selection write.\n      bindings: [\n        {\n          spec: { kind: 'drag', mods: { shift: 'optional' } },\n          actionId: 'lassoSelect',\n          // Thunked so a mode or spacing change reaches the next gesture\n          // without rebuilding the tool.\n          opts: {\n            params: () => paramsRef.current,\n            ...(behaviors ? { behaviors } : {}),\n          },\n        },\n      ],\n    });\n  }, [options.keybinding, behaviors, paramsRef]);\n}\n"],"mappings":";;;;;AA6BA,SAAgBC,EAAa,IAA+B,CAAC,GAAoB;CAC/E,IAAMC,IAAYC,EAA6D;EAC7E,MAAMC,EAAQ,QAAQ;EACtB,GAAIA,EAAQ,qBAAqB,KAAA,IAA6D,CAAC,IAAlD,EAAE,kBAAkBA,EAAQ,iBAAiB;CAC5F,CAAC,GACK,EAAE,iBAAcA;CAEtB,OAAOC,QACEC,EAAsB;EAC3B,IAAI;EACJ,cAAc,CAAC,mBAAmB;EAClC,UAAU;EACV,GAAIF,EAAQ,eAAe,OAAO,CAAC,IAAI,EAAE,YAAYA,EAAQ,cAAc,EAAE,KAAK,IAAI,EAAE;EACxF,QAAQ;EACR,cAAc;GACZ,OAAO;GACP,MAAMG,EAAcP,CAAS;GAC7B,OAAO;EACT;EAIA,UAAU,CACR;GACE,MAAM;IAAE,MAAM;IAAQ,MAAM,EAAE,OAAO,WAAW;GAAE;GAClD,UAAU;GAGV,MAAM;IACJ,cAAcE,EAAU;IACxB,GAAIM,IAAY,EAAE,aAAU,IAAI,CAAC;GACnC;EACF,CACF;CACF,CAAC,GACA;EAACJ,EAAQ;EAAYI;EAAWN;CAAS,CAAC;AAC/C"}

package/dist/tools/builtin/line/useLineTool.js

@@ -9,6 +9,7 @@ function o(o = {}) {
 	let { behaviors: s } = o;
 	return r(() => e({
 		id: "line",
+		keybinding: { key: "\\" },
 		capabilities: ["creates-shapes"],
 		hookName: "useLineTool",
 		cursor: a("crosshairLine", { fallback: "crosshair" }),