@weasel-js/renderer 0.0.0-stage → 1.9.4

package/dist/mesh.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/meshPaint/surface.ts","../src/meshPaint/bake.ts","../src/meshPaint/bakeCache.ts","../src/meshPaint/meshShader.ts","../src/meshPaint/meshPaint.ts","../src/meshPaint/handles.ts"],"names":["resolveColor"],"mappings":"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","file":"mesh.js","sourcesContent":["/**\n * Coons and tensor-product patch surfaces — PDF's shading types 6 and 7, as\n * pure geometry.\n *\n * A patch is a curved quadrilateral: four cubic Bézier edges and a color at\n * each corner. The interior is what the edges imply — a Coons patch reads it\n * off the boundary alone; a tensor patch adds four interior control points\n * that pull it around. Both evaluate at a `(u, v)` in the unit square, which\n * is what lets the renderer subdivide a patch into as many triangles as it\n * wants without the patch knowing.\n *\n * Nothing here touches GL, a color string, or a scene. `evalPatch` is the\n * whole contract.\n */\n\n/** A point in the patch's own space. */\nexport interface MeshPoint {\n  x: number;\n  y: number;\n}\n\n/**\n * One patch.\n *\n * `points` walks the boundary: corner 0, the two control points of the edge\n * leaving it, corner 1, its two, and so on — twelve points, ending with the\n * two controls that return to corner 0. A tensor patch appends its four\n * interior points, in the order `(1,1)`, `(1,2)`, `(2,2)`, `(2,1)` of the\n * bicubic control net, which is PDF's own order.\n *\n * Twelve points is a Coons patch and sixteen is a tensor patch; there is no\n * flag, because the count already says which it is.\n *\n * `colors` are the corner colors in the same walk order, as whatever color\n * form the caller resolves — the renderer hands premultiplied RGBA in, the\n * serializer hands CSS strings.\n */\nexport interface MeshPatch<TColor = string> {\n  points: readonly MeshPoint[];\n  colors: readonly [TColor, TColor, TColor, TColor];\n}\n\n/** Corner `i` of the boundary walk. */\nexport function patchCorner(patch: MeshPatch<unknown>, i: number): MeshPoint {\n  return patch.points[(i & 3) * 3];\n}\n\n/** `true` when the patch carries the four interior points a tensor patch adds. */\nexport function isTensorPatch(patch: MeshPatch<unknown>): boolean {\n  return patch.points.length >= 16;\n}\n\n/** A patch is twelve boundary points, or sixteen with the interior. Anything\n *  else cannot be evaluated, and saying so here beats painting nonsense. */\nexport function isValidPatch(patch: MeshPatch<unknown>): boolean {\n  return patch.points.length === 12 || patch.points.length === 16;\n}\n\nfunction bezier(p0: MeshPoint, p1: MeshPoint, p2: MeshPoint, p3: MeshPoint, t: number): MeshPoint {\n  const s = 1 - t;\n  const a = s * s * s;\n  const b = 3 * s * s * t;\n  const c = 3 * s * t * t;\n  const d = t * t * t;\n  return {\n    x: a * p0.x + b * p1.x + c * p2.x + d * p3.x,\n    y: a * p0.y + b * p1.y + c * p2.y + d * p3.y,\n  };\n}\n\n/** The edge leaving corner `i`, as its four control points. */\nfunction edge(patch: MeshPatch<unknown>, i: number): [MeshPoint, MeshPoint, MeshPoint, MeshPoint] {\n  const p = patch.points;\n  const a = (i & 3) * 3;\n  return [p[a], p[a + 1], p[a + 2], p[((i + 1) & 3) * 3]];\n}\n\n/**\n * The patch surface at `(u, v)`, both in `0..1`.\n *\n * `u` runs along the edge leaving corner 0 and `v` along the edge leaving\n * corner 1, so `(0,0)` is corner 0, `(1,0)` corner 1, `(1,1)` corner 2 and\n * `(0,1)` corner 3 — the same walk `colors` is in.\n */\nexport function evalPatch(patch: MeshPatch<unknown>, u: number, v: number): MeshPoint {\n  return isTensorPatch(patch) ? evalTensor(patch, u, v) : evalCoons(patch, u, v);\n}\n\nfunction evalCoons(patch: MeshPatch<unknown>, u: number, v: number): MeshPoint {\n  const [b0, b1, b2, b3] = edge(patch, 0);        // corner 0 → 1, along u at v=0\n  const [r0, r1, r2, r3] = edge(patch, 1);        // corner 1 → 2, along v at u=1\n  const [t0, t1, t2, t3] = edge(patch, 2);        // corner 2 → 3, along u at v=1\n  const [l0, l1, l2, l3] = edge(patch, 3);        // corner 3 → 0, along v at u=0\n\n  const bottom = bezier(b0, b1, b2, b3, u);\n  const top = bezier(t0, t1, t2, t3, 1 - u);      // walks 2 → 3, so reverse it\n  const right = bezier(r0, r1, r2, r3, v);\n  const left = bezier(l0, l1, l2, l3, 1 - v);     // walks 3 → 0, so reverse it\n\n  const c0 = patchCorner(patch, 0);\n  const c1 = patchCorner(patch, 1);\n  const c2 = patchCorner(patch, 2);\n  const c3 = patchCorner(patch, 3);\n\n  // The Coons construction: the two ruled surfaces between opposite edges,\n  // minus the bilinear surface through the corners they both already carry.\n  const ruledU = (a: number, b: number): number => (1 - v) * a + v * b;\n  const ruledV = (a: number, b: number): number => (1 - u) * a + u * b;\n  const corner = (k0: number, k1: number, k2: number, k3: number): number =>\n    (1 - u) * (1 - v) * k0 + u * (1 - v) * k1 + u * v * k2 + (1 - u) * v * k3;\n\n  return {\n    x: ruledU(bottom.x, top.x) + ruledV(left.x, right.x)\n      - corner(c0.x, c1.x, c2.x, c3.x),\n    y: ruledU(bottom.y, top.y) + ruledV(left.y, right.y)\n      - corner(c0.y, c1.y, c2.y, c3.y),\n  };\n}\n\n/** The bicubic control net a tensor patch's sixteen points make, as\n *  `net[i][j]` with `i` along `u` and `j` along `v`. */\nfunction tensorNet(patch: MeshPatch<unknown>): MeshPoint[][] {\n  const p = patch.points;\n  // Boundary, read off the same walk; interior from the four trailing points.\n  return [\n    [p[0], p[11], p[10], p[9]],\n    [p[1], p[12], p[13], p[8]],\n    [p[2], p[15], p[14], p[7]],\n    [p[3], p[4], p[5], p[6]],\n  ];\n}\n\nconst BERNSTEIN = (t: number): [number, number, number, number] => {\n  const s = 1 - t;\n  return [s * s * s, 3 * s * s * t, 3 * s * t * t, t * t * t];\n};\n\nfunction evalTensor(patch: MeshPatch<unknown>, u: number, v: number): MeshPoint {\n  const net = tensorNet(patch);\n  const bu = BERNSTEIN(u);\n  const bv = BERNSTEIN(v);\n  let x = 0;\n  let y = 0;\n  for (let i = 0; i < 4; i++) {\n    for (let j = 0; j < 4; j++) {\n      const w = bu[i] * bv[j];\n      x += w * net[i][j].x;\n      y += w * net[i][j].y;\n    }\n  }\n  return { x, y };\n}\n\n/**\n * The four corner weights at `(u, v)` — bilinear, in the corner walk order.\n *\n * Color is separate from position on purpose: it interpolates in whatever\n * space the caller chose, which is not a thing the surface can do for it.\n */\nexport function cornerWeights(u: number, v: number): [number, number, number, number] {\n  return [(1 - u) * (1 - v), u * (1 - v), u * v, (1 - u) * v];\n}\n\n/** Axis-aligned bounds of a patch, sampled on a grid. Control points alone\n *  bound a Bézier but not tightly, and a mesh paint is baked into a texture\n *  sized from this — a loose box wastes texels on every side. */\nexport function patchBounds(\n  patch: MeshPatch<unknown>, steps = 8,\n): { x: number; y: number; width: number; height: number } {\n  let minX = Infinity;\n  let minY = Infinity;\n  let maxX = -Infinity;\n  let maxY = -Infinity;\n  for (let i = 0; i <= steps; i++) {\n    for (let j = 0; j <= steps; j++) {\n      const p = evalPatch(patch, i / steps, j / steps);\n      if (p.x < minX) minX = p.x;\n      if (p.y < minY) minY = p.y;\n      if (p.x > maxX) maxX = p.x;\n      if (p.y > maxY) maxY = p.y;\n    }\n  }\n  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };\n}\n","/**\n * A mesh paint baked into one RGBA bitmap.\n *\n * A patch is a surface over `(u, v)`, but a paint has to answer \"what color is\n * this fragment\", which is the inverse question — and inverting a bicubic is\n * Newton iteration per fragment. Every renderer that draws these instead\n * subdivides the patch into small quads and rasterizes them forward, which is\n * what this does, once per paint, into a texture the shader then samples. The\n * cost is a texture and a resolution; the gain is that the paint composes with\n * every fill the renderer already knows how to draw, clipping included.\n *\n * The bitmap is straight (non-premultiplied) RGBA, matching the ramp atlas;\n * the fragment shader premultiplies.\n */\n\nimport { resolveColor } from '@weasel-js/paint';\nimport { lerpColorArray, type ColorSpace } from '@weasel-js/paint';\nimport { evalPatch, isValidPatch, patchBounds, type MeshPatch } from './surface';\n\n/** Texels on a side of a bake when the caller names no size. The renderer\n *  sizes each bake from how large the paint draws — see `meshBakeSize`. */\nexport const MESH_BAKE_SIZE = 256;\n\n/** Texels a rasterized cell spans at most. The rasterizer interpolates color\n *  linearly inside a cell and draws a curved edge as its chord, so this is\n *  what keeps a perceptual blend perceptual and an edge curved at any size. */\nconst TEXELS_PER_CELL = 10;\n\n/** Quads per patch on a side, never fewer than 24. */\nfunction gridFor(size: number): number {\n  return Math.max(24, Math.ceil(size / TEXELS_PER_CELL));\n}\n\n/** The box a bake covers, in the paint's own space. */\nexport interface MeshBox {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n/** The bitmap `bakeMesh` produces, and the paint-space box it covers. */\nexport interface BakedMesh {\n  /** `size` × `size` texels, straight RGBA. */\n  pixels: Uint8ClampedArray;\n  /** Texels on a side; `MESH_BAKE_SIZE` unless the caller asked otherwise. */\n  size: number;\n  /** Where the bitmap sits in paint space, which is what the shader maps a\n   *  fragment through. */\n  box: MeshBox;\n}\n\n/** The union of every patch's bounds, or `null` when nothing is drawable. */\nexport function meshBounds(patches: readonly MeshPatch[]): MeshBox | null {\n  let minX = Infinity;\n  let minY = Infinity;\n  let maxX = -Infinity;\n  let maxY = -Infinity;\n  for (const patch of patches) {\n    if (!isValidPatch(patch)) continue;\n    const b = patchBounds(patch);\n    minX = Math.min(minX, b.x);\n    minY = Math.min(minY, b.y);\n    maxX = Math.max(maxX, b.x + b.width);\n    maxY = Math.max(maxY, b.y + b.height);\n  }\n  if (!Number.isFinite(minX) || maxX <= minX || maxY <= minY) return null;\n  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };\n}\n\ntype Rgba = readonly [number, number, number, number];\n\n/**\n * Corner colors blended at `(u, v)` in `space`.\n *\n * Bilinear as three lerps rather than four weights, because a perceptual space\n * has a midpoint between two colors and no meaningful four-way mix — OKLCh's\n * hue in particular is an arc, which only two endpoints define.\n */\nfunction colorAt(corners: Rgba[], u: number, v: number, space: ColorSpace): number[] {\n  const bottom = lerpColorArray(corners[0], corners[1], u, space);\n  const top = lerpColorArray(corners[3], corners[2], u, space);\n  return lerpColorArray(bottom, top, v, space);\n}\n\n/**\n * Rasterize `patches` into a square bitmap covering their union.\n *\n * Returns `null` when no patch is drawable, which is the caller's cue to paint\n * nothing rather than a blank square.\n */\nexport function bakeMesh(\n  patches: readonly MeshPatch[],\n  space: ColorSpace = 'rgb',\n  size: number = MESH_BAKE_SIZE,\n): BakedMesh | null {\n  const box = meshBounds(patches);\n  if (!box) return null;\n\n  const pixels = new Uint8ClampedArray(size * size * 4);\n  const grid = gridFor(size);\n  // The box maps onto texel *centers*, not texel edges: a corner of the mesh\n  // lands at the center of the corner texel, so the outermost row and column\n  // are covered rather than half-missed by a rasterizer testing centers.\n  const toTexel = (p: { x: number; y: number }): { x: number; y: number } => ({\n    x: ((p.x - box.x) / box.width) * (size - 1) + 0.5,\n    y: ((p.y - box.y) / box.height) * (size - 1) + 0.5,\n  });\n\n  for (const patch of patches) {\n    if (!isValidPatch(patch)) continue;\n    const corners = patch.colors.map((c) => resolveColor(c)) as Rgba[];\n\n    for (let i = 0; i < grid; i++) {\n      for (let j = 0; j < grid; j++) {\n        const u0 = i / grid;\n        const u1 = (i + 1) / grid;\n        const v0 = j / grid;\n        const v1 = (j + 1) / grid;\n        const quad = [\n          { at: toTexel(evalPatch(patch, u0, v0)), color: colorAt(corners, u0, v0, space) },\n          { at: toTexel(evalPatch(patch, u1, v0)), color: colorAt(corners, u1, v0, space) },\n          { at: toTexel(evalPatch(patch, u1, v1)), color: colorAt(corners, u1, v1, space) },\n          { at: toTexel(evalPatch(patch, u0, v1)), color: colorAt(corners, u0, v1, space) },\n        ];\n        fillTriangle(pixels, size, quad[0], quad[1], quad[2]);\n        fillTriangle(pixels, size, quad[0], quad[2], quad[3]);\n      }\n    }\n  }\n\n  return { pixels, size, box };\n}\n\ninterface Vertex {\n  at: { x: number; y: number };\n  color: number[];\n}\n\nconst EDGE_EPS = 1e-6;\n\n/**\n * One triangle, barycentric, colors interpolated across it.\n *\n * Neighboring cells share an edge, so a pixel exactly on one is claimed by\n * both — harmless here because both carry the same color there, and cheaper\n * than a fill rule.\n */\nfunction fillTriangle(\n  pixels: Uint8ClampedArray, size: number, a: Vertex, b: Vertex, c: Vertex,\n): void {\n  const minX = Math.max(0, Math.floor(Math.min(a.at.x, b.at.x, c.at.x)));\n  const maxX = Math.min(size - 1, Math.ceil(Math.max(a.at.x, b.at.x, c.at.x)));\n  const minY = Math.max(0, Math.floor(Math.min(a.at.y, b.at.y, c.at.y)));\n  const maxY = Math.min(size - 1, Math.ceil(Math.max(a.at.y, b.at.y, c.at.y)));\n  if (maxX < minX || maxY < minY) return;\n\n  const area = (b.at.x - a.at.x) * (c.at.y - a.at.y) - (c.at.x - a.at.x) * (b.at.y - a.at.y);\n  // A degenerate cell — a patch collapsed to a line — covers nothing.\n  if (Math.abs(area) < 1e-9) return;\n\n  for (let y = minY; y <= maxY; y++) {\n    for (let x = minX; x <= maxX; x++) {\n      const px = x + 0.5;\n      const py = y + 0.5;\n      const w0 = ((b.at.x - px) * (c.at.y - py) - (c.at.x - px) * (b.at.y - py)) / area;\n      const w1 = ((c.at.x - px) * (a.at.y - py) - (a.at.x - px) * (c.at.y - py)) / area;\n      const w2 = 1 - w0 - w1;\n      // An edge texel's center sits exactly on the boundary, where rounding\n      // can put it a hair outside; the epsilon is what keeps the border row\n      // from dropping out.\n      if (w0 < -EDGE_EPS || w1 < -EDGE_EPS || w2 < -EDGE_EPS) continue;\n      const k = (y * size + x) * 4;\n      for (let ch = 0; ch < 4; ch++) {\n        pixels[k + ch] = (w0 * a.color[ch] + w1 * b.color[ch] + w2 * c.color[ch]) * 255;\n      }\n    }\n  }\n}\n","/**\n * How large a mesh bake is, and the bounded cache the bakes live in.\n *\n * A gradient's ramp is one-dimensional, so 256 texels cover it at any size. A\n * mesh's bake is two-dimensional and is stretched over whatever the paint\n * covers, so a fixed size shows its texels once the paint draws large. The\n * bake is sized from the device pixels it covers instead, in power-of-two\n * buckets so a zoom inside one bucket reuses the bake it already has.\n */\n\nimport { MESH_BAKE_SIZE } from './bake';\n\n/** The smallest bake: below this a texture costs more in bookkeeping than in\n *  bytes. */\nexport const MESH_BAKE_MIN = 32;\n\n/** The largest bake, whatever the context allows: 16 MiB of RGBA, and a bake\n *  that already takes a noticeable moment on the CPU. */\nexport const MESH_BAKE_MAX = 2048;\n\n/** Bytes of baked texture one renderer keeps before evicting the least\n *  recently drawn. */\nexport const MESH_BAKE_CACHE_BYTES = 64 * 1024 * 1024;\n\n/** Bakes one renderer keeps, however small, so a scene of many tiny meshes\n *  cannot hold thousands of GL textures. */\nexport const MESH_BAKE_CACHE_ENTRIES = 256;\n\n/**\n * The bake side for a paint drawn `devicePx` device pixels across, on a\n * context accepting `maxTextureSize`: the next power of two at or above it,\n * clamped to `[MESH_BAKE_MIN, MESH_BAKE_MAX]` and to the context. A size that\n * cannot be measured gets `MESH_BAKE_SIZE`.\n */\nexport function meshBakeSize(devicePx: number, maxTextureSize: number): number {\n  const ceiling = Math.min(MESH_BAKE_MAX, floorPow2(maxTextureSize));\n  if (Number.isNaN(devicePx)) return Math.min(MESH_BAKE_SIZE, ceiling);\n  if (devicePx <= MESH_BAKE_MIN) return Math.min(MESH_BAKE_MIN, ceiling);\n  if (devicePx >= ceiling) return ceiling;\n  return Math.min(ceiling, 2 ** Math.ceil(Math.log2(devicePx)));\n}\n\nfunction floorPow2(n: number): number {\n  if (!(n >= 1)) return MESH_BAKE_MIN;\n  if (!Number.isFinite(n)) return MESH_BAKE_MAX;\n  return 2 ** Math.floor(Math.log2(n));\n}\n\ninterface Entry<T> {\n  value: T;\n  size: number;\n  /** The paint's own bucket map, which is what eviction removes it from. */\n  bySize: Map<number, Entry<T>>;\n}\n\n/**\n * Bakes keyed by paint and bake size, least recently used first out.\n *\n * The paint is held weakly, so a paint nobody draws any more does not pin its\n * key; its texture stays until eviction reaches it, which the bounds keep\n * finite. `free` runs for every value that leaves, by eviction, replacement or\n * `clear`.\n */\nexport class MeshBakeCache<T> {\n  private readonly byPaint = new WeakMap<object, Map<number, Entry<T>>>();\n  /** Insertion order is recency: a hit is deleted and re-added. */\n  private readonly order = new Set<Entry<T>>();\n  private held = 0;\n\n  constructor(\n    private readonly free: (value: T) => void,\n    private readonly budgetBytes: number = MESH_BAKE_CACHE_BYTES,\n    private readonly maxEntries: number = MESH_BAKE_CACHE_ENTRIES,\n  ) {}\n\n  /** Bytes the held bakes occupy, as RGBA8. */\n  get bytes(): number { return this.held; }\n\n  /** Bakes held. */\n  get size(): number { return this.order.size; }\n\n  get(paint: object, size: number): T | undefined {\n    const entry = this.byPaint.get(paint)?.get(size);\n    if (!entry) return undefined;\n    this.order.delete(entry);\n    this.order.add(entry);\n    return entry.value;\n  }\n\n  set(paint: object, size: number, value: T): void {\n    let bySize = this.byPaint.get(paint);\n    if (!bySize) {\n      bySize = new Map();\n      this.byPaint.set(paint, bySize);\n    }\n    const old = bySize.get(size);\n    if (old) this.drop(old);\n    const entry: Entry<T> = { value, size, bySize };\n    bySize.set(size, entry);\n    this.order.add(entry);\n    this.held += size * size * 4;\n    this.evict(entry);\n  }\n\n  /** Free every bake. The cache stays usable. */\n  clear(): void {\n    for (const entry of [...this.order]) this.drop(entry);\n  }\n\n  /** Oldest first until both bounds hold, never evicting `keep` — the bake\n   *  the caller is about to draw. */\n  private evict(keep: Entry<T>): void {\n    for (const entry of this.order) {\n      if (this.held <= this.budgetBytes && this.order.size <= this.maxEntries) return;\n      if (entry !== keep) this.drop(entry);\n    }\n  }\n\n  private drop(entry: Entry<T>): void {\n    if (!this.order.delete(entry)) return;\n    entry.bySize.delete(entry.size);\n    this.held -= entry.size * entry.size * 4;\n    this.free(entry.value);\n  }\n}\n","/**\n * GLSL ES 3.0 sources for the mesh-gradient paint.\n *\n * The vertex stage is the pattern/gradient one: a path fill mesh carries\n * `a_position` only, so paint-space coordinates come back per fragment from\n * the screen position through `u_worldInv`. The fragment stage is a clamped\n * texture read of the baked mesh, with everything outside the bake's box\n * transparent — a mesh covers the area its patches cover, not the whole shape\n * it is filling, and a clamped read would otherwise smear its border colors\n * across the rest.\n *\n * `u_meshOrigin` / `u_meshSize` are the bake's box in paint space, and the\n * bake maps that box onto texel *centers*, which is the half-texel the uv\n * rescale accounts for.\n *\n * Output convention §2: PREMULTIPLIED alpha.\n */\n\n/** The id this program is registered under. */\nexport const MESH_PROGRAM_ID = 'kit:mesh-gradient';\n\nexport const MESH_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\nexport const MESH_FRAG_SRC = /* glsl */ `#version 300 es\nprecision highp float;\nin vec2 v_world;\nuniform sampler2D u_sampler;\nuniform vec2  u_meshOrigin;\nuniform vec2  u_meshSize;\nuniform float u_opacity;\nuniform float u_alpha;\nout vec4 outColor;\nvoid main() {\n  vec2 t =(v_world - u_meshOrigin) / max(u_meshSize, vec2(0.0001));\n  if (t.x < 0.0 || t.x > 1.0 || t.y < 0.0 || t.y > 1.0) {\n    outColor = vec4(0.0);\n    return;\n  }\n  vec2 texels = vec2(textureSize(u_sampler, 0));\n  vec2 uv = (t * (texels - 1.0) + 0.5) / texels;\n  vec4 texel = texture(u_sampler, uv);\n  float a = texel.a * u_opacity * u_alpha;\n  outColor = vec4(texel.rgb * a, a);\n}\n`;\n\nexport const MESH_UNIFORMS = [\n  'u_proj', 'u_model', 'u_worldInv', 'u_sampler',\n  'u_meshOrigin', 'u_meshSize', 'u_opacity', 'u_alpha',\n] as const;\n\nexport const MESH_ATTRIBUTES = ['a_position'] as const;\n","/**\n * The `mesh-gradient` paint kind — PDF's shading types 6 and 7 as a registered\n * paint.\n *\n * A mesh gradient is a set of curved quadrilateral patches, each with a color\n * at every corner. It is the paint SVG tried to standardize as\n * `<meshgradient>` and abandoned, and the one PDF has had since 1993; what it\n * buys over the three gradients is a color field that bends, so a highlight\n * can follow a form instead of running straight across it.\n *\n * This is a registered kind rather than a sixth branch in the renderer, and\n * deliberately: it uses only the slots `registerPaintKind` gives a consumer, so\n * whatever it can do, a consumer's own kind can do too. Its one concession is\n * living in this package, because that is where the shader registry is.\n *\n * `docs/proposals/2026-09-17-paint-kinds-beyond-svg.md` is the design.\n */\n\nimport type { GradStop } from '@weasel-js/paint';\nimport type { PaintBindContext, PaintDrawKind, PaintProgram, PaintResources } from '../paintKinds';\nimport { resolveColor, rgbaToHex } from '@weasel-js/paint';\nimport { mat3 } from '@weasel-js/geom';\nimport { oklabToOklch, oklabToSrgbU8, oklchToOklab, srgbFloatToOklab } from '@weasel-js/paint';\nimport type { ColorSpace, FillStyle, GradientUnits } from '@weasel-js/paint';\nimport type { FillPoseBox } from '../fillInPoseFrame';\nimport { bakeMesh, meshBounds, type MeshBox } from './bake';\nimport { MeshBakeCache, meshBakeSize } from './bakeCache';\nimport { isValidPatch, type MeshPatch, type MeshPoint } from './surface';\nimport { MESH_FRAG_SRC, MESH_PROGRAM_ID, MESH_VERT_SRC } from './meshShader';\n\nexport type { MeshPatch, MeshPoint } from './surface';\n\n/**\n * A mesh gradient paint.\n *\n * `patches` are in the space `units` names, the same way a gradient's\n * geometry is — under `'bounds'` every point is a fraction of the painted\n * node's box, which is what lets the paint survive a resize.\n *\n * `interpolate` is the space corner colors blend through, matching the three\n * gradients. It is more visible here than there: a mesh blends in two\n * directions at once, so an sRGB blend's muddy middle covers area rather than\n * a line.\n */\nexport interface MeshGradientFill {\n  fill: 'mesh-gradient';\n  patches: MeshPatch[];\n  units?: GradientUnits;\n  interpolate?: ColorSpace;\n  opacity?: number;\n}\n\n/** The kind's id, as `FillStyle['fill']` carries it. */\nexport const MESH_GRADIENT_KIND = 'mesh-gradient';\n\n/** A mesh paint, narrowed. */\nexport function isMeshGradientFill(fill: FillStyle | null | undefined): fill is FillStyle & MeshGradientFill {\n  // `FillStyle`'s discriminant stays closed over the built-in kinds — see\n  // `asPaint` — so a registered kind reads it widened.\n  return fill != null && (fill.fill as string | undefined) === MESH_GRADIENT_KIND;\n}\n\nfunction asMesh(fill: FillStyle): MeshGradientFill {\n  return fill as unknown as MeshGradientFill;\n}\n\n// `asPaint`'s cast, kept local: this module must import nothing from the\n// registry, whose state the lazy kind's self-contained copy would duplicate.\nfunction asFill(mesh: MeshGradientFill): FillStyle {\n  return mesh as unknown as FillStyle;\n}\n\n/**\n * `color` moved in OKLCh — lightness, chroma and hue by the given deltas, with\n * its alpha kept. The seed's corners come from one color, and they have to\n * differ enough to read as a mesh rather than as a flat fill.\n */\nfunction shifted(color: string, dL: number, cScale: number, dHueDeg: number): string {\n  const [r, g, b, a] = resolveColor(color);\n  const [L, A, B] = srgbFloatToOklab(r, g, b);\n  const [, C, h] = oklabToOklch(L, A, B);\n  const [nL, nA, nB] = oklchToOklab(\n    Math.min(1, Math.max(0, L + dL)),\n    Math.max(0, C * cScale),\n    h + (dHueDeg * Math.PI) / 180,\n  );\n  const [nr, ng, nb] = oklabToSrgbU8(nL, nA, nB);\n  return rgbaToHex([nr / 255, ng / 255, nb / 255, a]);\n}\n\n/** A one-patch square covering the unit box, its four corners four readings of\n *  `color` — a mesh seeded from a solid has to show *something* curved, or\n *  switching kind looks like nothing happened. */\nexport function seedMeshPatch(color: string): MeshGradientFill {\n  const corners: MeshPoint[] = [\n    { x: 0, y: 0 }, { x: 1, y: 0 }, { x: 1, y: 1 }, { x: 0, y: 1 },\n  ];\n  const points: MeshPoint[] = [];\n  for (let i = 0; i < 4; i++) {\n    const a = corners[i];\n    const b = corners[(i + 1) % 4];\n    // Bow each edge outward by an eighth, so the seed is a patch and not a\n    // rectangle wearing one's clothes.\n    const nx = (b.y - a.y) * 0.125;\n    const ny = -(b.x - a.x) * 0.125;\n    points.push(\n      a,\n      { x: a.x + (b.x - a.x) / 3 + nx, y: a.y + (b.y - a.y) / 3 + ny },\n      { x: a.x + (2 * (b.x - a.x)) / 3 + nx, y: a.y + (2 * (b.y - a.y)) / 3 + ny },\n    );\n  }\n  return {\n    fill: MESH_GRADIENT_KIND,\n    patches: [{\n      points,\n      colors: [\n        color,\n        shifted(color, 0.14, 0.85, 0),\n        shifted(color, -0.06, 1.1, 38),\n        shifted(color, -0.16, 1.0, -22),\n      ],\n    }],\n    units: 'bounds',\n  };\n}\n\n/** The straight-edged patch covering `[x0, x1] × [0, 1]`, in walk order. */\nfunction bandPatch(x0: number, x1: number, left: string, right: string): MeshPatch {\n  const corners: MeshPoint[] = [{ x: x0, y: 0 }, { x: x1, y: 0 }, { x: x1, y: 1 }, { x: x0, y: 1 }];\n  const points: MeshPoint[] = [];\n  for (let i = 0; i < 4; i++) {\n    const a = corners[i];\n    const b = corners[(i + 1) % 4];\n    points.push(a, { x: a.x + (b.x - a.x) / 3, y: a.y + (b.y - a.y) / 3 }, { x: a.x + (2 * (b.x - a.x)) / 3, y: a.y + (2 * (b.y - a.y)) / 3 });\n  }\n  return { points, colors: [left, right, right, left] };\n}\n\n/**\n * A stop list as a mesh: one full-height band per gap between neighboring\n * stops, colored left to right. The bands blend exactly the way the ramp\n * does, so a horizontal gradient survives the switch unchanged. A zero-width\n * gap is a hard break and gets no band.\n */\nexport function meshFromStops(stops: readonly GradStop[]): MeshGradientFill {\n  const sorted = [...stops].sort((a, b) => a.offset - b.offset);\n  if (sorted.length === 1) sorted.push({ offset: 1, color: sorted[0].color });\n  if (sorted.length === 0) return seedMeshPatch('#000000ff');\n  const patches: MeshPatch[] = [];\n  for (let i = 0; i < sorted.length - 1; i++) {\n    const a = sorted[i];\n    const b = sorted[i + 1];\n    if (b.offset > a.offset) patches.push(bandPatch(a.offset, b.offset, a.color, b.color));\n  }\n  return { fill: MESH_GRADIENT_KIND, patches, units: 'bounds' };\n}\n\n/**\n * A mesh read as a stop list: every patch's top edge — corner 0 to corner 1 —\n * placed by its `x` across the mesh's horizontal extent. The inverse of\n * `meshFromStops`, and for any other mesh the ramp across its top.\n */\nexport function meshStops(mesh: MeshGradientFill): GradStop[] {\n  const valid = mesh.patches.filter(isValidPatch);\n  if (valid.length === 0) return [];\n  const xs = valid.flatMap((p) => [p.points[0].x, p.points[3].x]);\n  const lo = Math.min(...xs);\n  const span = Math.max(...xs) - lo;\n  const offsetOf = (x: number) => (span > 0 ? (x - lo) / span : 0);\n  const stops: GradStop[] = [];\n  for (const patch of valid) {\n    for (const [point, color] of [[patch.points[0], patch.colors[0]], [patch.points[3], patch.colors[1]]] as const) {\n      const offset = offsetOf(point.x);\n      if (!stops.some((s) => s.offset === offset && s.color === color)) stops.push({ offset, color });\n    }\n  }\n  return stops.sort((a, b) => a.offset - b.offset);\n}\n\n/** Every patch mapped through `move`. */\nfunction mapPatches(mesh: MeshGradientFill, move: (p: MeshPoint) => MeshPoint): MeshPatch[] {\n  return mesh.patches.map((patch) => ({ ...patch, points: patch.points.map(move) }));\n}\n\n// ─── The bake cache ─────────────────────────────────────────────────────────\n//\n// A kind owns its own GPU state; the registry hands it a `gl` and a resource\n// lifetime. One cache per lifetime, so two renderers — or one renderer past a\n// context restore — never trade textures, and the lifetime's end frees them.\n\ninterface CachedBake {\n  texture: WebGLTexture;\n  /** Where the mesh being bound sits in paint space. The texels are shared by\n   *  every pose-frame copy of one paint; the box is each copy's own. */\n  box: MeshBox;\n}\n\n/** The paint a pose-frame copy was made from. A copy is rebuilt whenever its\n *  node's pose changes, and bakes the same texels as its source. */\nconst BAKE_SOURCE = new WeakMap<object, object>();\n\nconst CACHES = new WeakMap<PaintResources, MeshBakeCache<WebGLTexture>>();\n\nfunction cacheFor(ctx: PaintBindContext): MeshBakeCache<WebGLTexture> {\n  let cache = CACHES.get(ctx.resources);\n  if (!cache) {\n    const gl = ctx.gl;\n    const made = new MeshBakeCache<WebGLTexture>((texture) => gl.deleteTexture(texture));\n    ctx.resources.onRelease(() => {\n      made.clear();\n      CACHES.delete(ctx.resources);\n    });\n    CACHES.set(ctx.resources, made);\n    cache = made;\n  }\n  return cache;\n}\n\n/** Device pixels the larger side of `box` covers when drawn in `units`. */\nfunction devicePixelsOf(ctx: PaintBindContext, mesh: MeshGradientFill, box: MeshBox): number {\n  const m = ctx.spaceToDevice(mesh.units);\n  if (!m) return Number.NaN;\n  return Math.max(box.width * Math.hypot(m[0], m[1]), box.height * Math.hypot(m[3], m[4]));\n}\n\nfunction bakeFor(ctx: PaintBindContext, mesh: MeshGradientFill): CachedBake | null {\n  const box = meshBounds(mesh.patches);\n  if (!box) return null;\n  const size = meshBakeSize(devicePixelsOf(ctx, mesh, box), ctx.maxTextureSize);\n\n  const cache = cacheFor(ctx);\n  const key = BAKE_SOURCE.get(mesh) ?? mesh;\n  const hit = cache.get(key, size);\n  if (hit) return { texture: hit, box };\n\n  const baked = bakeMesh(mesh.patches, mesh.interpolate ?? 'rgb', size);\n  if (!baked) return null;\n\n  const gl = ctx.gl;\n  const texture = gl.createTexture();\n  if (!texture) return null;\n  gl.bindTexture(gl.TEXTURE_2D, texture);\n  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);\n  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);\n  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);\n  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);\n  gl.texImage2D(\n    gl.TEXTURE_2D, 0, gl.RGBA,\n    baked.size, baked.size, 0,\n    gl.RGBA, gl.UNSIGNED_BYTE, baked.pixels,\n  );\n  gl.bindTexture(gl.TEXTURE_2D, null);\n\n  cache.set(key, size, texture);\n  return { texture, box };\n}\n\nfunction bindMesh(ctx: PaintBindContext, fill: FillStyle): PaintProgram | null {\n  const mesh = asMesh(fill);\n  if (!mesh.patches.some(isValidPatch)) return null;\n\n  const inverse = ctx.spaceInverse(mesh.units);\n  if (!inverse) return null;\n\n  const program = ctx.program(MESH_PROGRAM_ID);\n  if (!program) return null;\n\n  const entry = bakeFor(ctx, mesh);\n  if (!entry) return null;\n\n  const gl = ctx.gl;\n  gl.useProgram(program.handle);\n  ctx.setProjAndModel(program);\n  gl.uniformMatrix3fv(program.uniform('u_worldInv')!, false, mat3.toUniform(inverse));\n\n  gl.activeTexture(gl.TEXTURE0);\n  gl.bindTexture(gl.TEXTURE_2D, entry.texture);\n  gl.uniform1i(program.uniform('u_sampler')!, 0);\n\n  const { box } = entry;\n  gl.uniform2f(program.uniform('u_meshOrigin')!, box.x, box.y);\n  gl.uniform2f(program.uniform('u_meshSize')!, box.width, box.height);\n  gl.uniform1f(program.uniform('u_opacity')!, mesh.opacity ?? 1);\n  gl.uniform1f(program.uniform('u_alpha')!, ctx.alpha);\n  return program;\n}\n\n/** The kind's draw half, shader program included. Core adds the editor's\n *  slots and registers the whole entry. */\nexport const meshDrawKind: PaintDrawKind = {\n  id: MESH_GRADIENT_KIND,\n  programs: { [MESH_PROGRAM_ID]: { vert: MESH_VERT_SRC, frag: MESH_FRAG_SRC } },\n  bind: bindMesh,\n  inPoseFrame: (fill, box: FillPoseBox) => {\n    const mesh = asMesh(fill);\n    if (mesh.units !== 'bounds') return fill;\n    const posed = asFill({\n      ...mesh,\n      patches: mapPatches(mesh, (p) => ({\n        x: box.x + p.x * box.width,\n        y: box.y + p.y * box.height,\n      })),\n      units: 'local' as const,\n    });\n    BAKE_SOURCE.set(posed, fill);\n    return posed;\n  },\n  toBoundsFrame: (fill, box: FillPoseBox) => {\n    const mesh = asMesh(fill);\n    if (mesh.units === 'bounds' || box.width === 0 || box.height === 0) return fill;\n    return asFill({\n      ...mesh,\n      patches: mapPatches(mesh, (p) => ({\n        x: (p.x - box.x) / box.width,\n        y: (p.y - box.y) / box.height,\n      })),\n      units: 'bounds' as const,\n    });\n  },\n};\n\n/**\n * The `<defs>` entry for a mesh paint, in weasel's own namespace.\n *\n * Not SVG's abandoned `<meshgradient>`: that vocabulary only reaches Coons\n * patches, shares patch edges implicitly — a reader that gets the sharing\n * wrong tears the surface rather than failing outright — and has exactly one\n * implementation in the world. Ours writes every patch's points in full.\n * `@weasel-js/svg` puts the paint fallback color beside the reference, so a\n * foreign renderer paints flat instead of nothing.\n */\nexport function meshGradientXml(id: string, mesh: MeshGradientFill): string {\n  const P = 'wzl';\n  const units = mesh.units === 'bounds' ? 'objectBoundingBox' : 'userSpaceOnUse';\n  const space = mesh.interpolate && mesh.interpolate !== 'rgb'\n    ? ` interpolate=\"${mesh.interpolate}\"` : '';\n  const patches = mesh.patches.map((patch) => {\n    const points = patch.points.map((p) => `${trim(p.x)},${trim(p.y)}`).join(' ');\n    const colors = patch.colors.join(' ');\n    return `<${P}:patch points=\"${points}\" colors=\"${colors}\"/>`;\n  }).join('');\n  return (\n    `<${P}:meshGradient id=\"${id}\" gradientUnits=\"${units}\"${space}>` +\n    `${patches}</${P}:meshGradient>`\n  );\n}\n\n/** Short decimals, matching what `@weasel-js/svg` writes elsewhere. */\nfunction trim(n: number): string {\n  return Number.isInteger(n) ? String(n) : String(Number(n.toFixed(4)));\n}\n","/**\n * The draggable points of a mesh paint, as pure geometry — what an on-canvas\n * editor lists, and what moving one of them does to the paint.\n *\n * Nothing here knows a frame: the handles are in whatever space the mesh's\n * points are, so a caller resolves a `'bounds'` mesh onto its box first\n * (`fillInPoseFrame`) and normalizes the result back (`fillToBoundsFrame`).\n */\n\nimport type { MeshGradientFill } from './meshPaint';\nimport { isTensorPatch, isValidPatch, type MeshPatch, type MeshPoint } from './surface';\n\n/** What a handle moves: a patch corner, one of the two controls of an edge,\n *  or one of a tensor patch's four interior points. */\nexport type MeshHandleKind = 'corner' | 'control' | 'interior';\n\n/** One stored point: `patches[patch].points[index]`. */\nexport interface MeshPointRef {\n  patch: number;\n  index: number;\n}\n\n/**\n * One draggable point.\n *\n * Patches store their points in full rather than sharing edges, so two\n * patches that meet each carry a copy of the corner and controls they meet\n * at. Those copies are one handle, with a `ref` per copy — dragging one of\n * them alone would tear the surface open along the seam.\n */\nexport interface MeshHandle {\n  /** Stable while the handle moves: its first ref, as `\"patch:index\"`. */\n  id: string;\n  kind: MeshHandleKind;\n  at: MeshPoint;\n  refs: readonly MeshPointRef[];\n}\n\n/** Corner `k`'s interior neighbor in the tensor net. PDF's trailing four walk\n *  the net as (1,1) (1,2) (2,2) (2,1), which puts corner 1's at index 15 and\n *  corner 3's at 13 — the transpose of the obvious reading. */\nconst INTERIOR_OF_CORNER = [12, 15, 14, 13] as const;\n\nfunction kindOf(index: number): MeshHandleKind {\n  if (index >= 12) return 'interior';\n  return index % 3 === 0 ? 'corner' : 'control';\n}\n\nfunction near(a: number, b: number): boolean {\n  return Math.abs(a - b) <= 1e-9 * Math.max(1, Math.abs(a), Math.abs(b));\n}\n\nfunction same(a: MeshPoint, b: MeshPoint): boolean {\n  return near(a.x, b.x) && near(a.y, b.y);\n}\n\n/**\n * Every draggable point of `mesh`, in walk order: each patch's corners and\n * edge controls, then a tensor patch's interior. Coincident points of one\n * kind merge into one handle. A patch that cannot be evaluated has none.\n */\nexport function meshHandles(mesh: MeshGradientFill): MeshHandle[] {\n  const handles: { id: string; kind: MeshHandleKind; at: MeshPoint; refs: MeshPointRef[] }[] = [];\n  mesh.patches.forEach((patch, p) => {\n    if (!isValidPatch(patch)) return;\n    patch.points.forEach((at, index) => {\n      const kind = kindOf(index);\n      const twin = handles.find((h) => h.kind === kind && same(h.at, at));\n      if (twin) twin.refs.push({ patch: p, index });\n      else handles.push({ id: `${p}:${index}`, kind, at, refs: [{ patch: p, index }] });\n    });\n  });\n  return handles;\n}\n\n/** The points a corner carries: the controls of the two edges it joins, and\n *  its interior neighbor when the patch has one. */\nfunction carriedBy(patch: MeshPatch, corner: number): number[] {\n  const k = corner / 3;\n  const carried = [corner + 1, (corner + 11) % 12];\n  if (isTensorPatch(patch)) carried.push(INTERIOR_OF_CORNER[k]);\n  return carried;\n}\n\n/**\n * `mesh` with `handle` moved to `to`. A corner carries its edge controls\n * and interior neighbor along by the same offset, the way a path editor's\n * anchor carries its handles; a control or interior point moves alone.\n * Returns a new paint; `mesh` is not modified.\n */\nexport function moveMeshHandle(\n  mesh: MeshGradientFill, handle: MeshHandle, to: MeshPoint,\n): MeshGradientFill {\n  const dx = to.x - handle.at.x;\n  const dy = to.y - handle.at.y;\n  const placed = new Map<string, MeshPoint>();\n  for (const { patch, index } of handle.refs) {\n    placed.set(`${patch}:${index}`, to);\n  }\n  if (handle.kind === 'corner') {\n    for (const { patch, index } of handle.refs) {\n      for (const carried of carriedBy(mesh.patches[patch], index)) {\n        const key = `${patch}:${carried}`;\n        if (placed.has(key)) continue;\n        const from = mesh.patches[patch].points[carried];\n        placed.set(key, { x: from.x + dx, y: from.y + dy });\n      }\n    }\n  }\n  return {\n    ...mesh,\n    patches: mesh.patches.map((patch, p) => ({\n      ...patch,\n      points: patch.points.map((point, i) => placed.get(`${p}:${i}`) ?? point),\n    })),\n  };\n}\n\n/** The lines an editor draws under the handles, as control polygons. */\nexport interface MeshGuides {\n  /** Every patch edge as its four cubic control points, from the corner it\n   *  leaves to the corner it reaches. */\n  edges: [MeshPoint, MeshPoint, MeshPoint, MeshPoint][];\n  /** Corner to each point it carries — an edge control or interior point. */\n  arms: [MeshPoint, MeshPoint][];\n}\n\n/** The guides for `mesh`'s valid patches. Shared edges appear once per patch. */\nexport function meshGuides(mesh: MeshGradientFill): MeshGuides {\n  const edges: MeshGuides['edges'] = [];\n  const arms: MeshGuides['arms'] = [];\n  for (const patch of mesh.patches) {\n    if (!isValidPatch(patch)) continue;\n    const p = patch.points;\n    for (let k = 0; k < 4; k++) {\n      const corner = k * 3;\n      edges.push([p[corner], p[corner + 1], p[corner + 2], p[(corner + 3) % 12]]);\n      for (const carried of carriedBy(patch, corner)) arms.push([p[corner], p[carried]]);\n    }\n  }\n  return { edges, arms };\n}\n"]}

package/dist/paintKinds-B2vEy9A4.d.ts

@@ -0,0 +1,330 @@
+import { TextureHandle, FillStyle, PosedFill, GradientUnits, GradStop, ColorSpace } from '@weasel-js/paint';
+import { Reflection } from '@weasel-js/registry';
+import { GlMat3 } from '@weasel-js/geom';
+
+/**
+ * Minimal compile/link/lookup wrapper for a GL program. Throws
+ * `ShaderCompileError` on compile or link failure with the GL info log
+ * embedded in the error message — never returns a half-initialized program.
+ *
+ * Designed so test code can stub `getShaderParameter` / `getProgramParameter`
+ * via the recorder Proxy without further special-casing.
+ */
+type Stage = 'vertex' | 'fragment' | 'link';
+/** Thrown when a shader fails to compile or link, carrying which stage failed
+ *  and the driver's log. */
+declare class ShaderCompileError extends Error {
+    readonly stage: Stage;
+    readonly log: string;
+    constructor(stage: Stage, log: string);
+}
+/** An array uniform a program can be written as a whole: its element type as
+ *  declared, its declared length, and the location of slot 0. */
+interface UniformArray {
+    readonly type: string;
+    readonly size: number;
+    readonly location: WebGLUniformLocation;
+}
+/** A linked GL program with its uniform and attribute locations cached by name. */
+declare class ShaderProgram {
+    private readonly gl;
+    readonly handle: WebGLProgram;
+    private readonly uniforms;
+    private readonly arrays;
+    private readonly attributes;
+    constructor(gl: WebGL2RenderingContext, vertSrc: string, fragSrc: string);
+    private compile;
+    lookupUniforms(names: readonly string[]): void;
+    /** Record each array's slot-0 location under its bare name. An array the
+     *  driver optimized away has no location and is left out. */
+    lookupUniformArrays(decls: ReadonlyMap<string, {
+        type: string;
+        size: number;
+    }>): void;
+    lookupAttributes(names: readonly string[]): void;
+    uniform(name: string): WebGLUniformLocation | undefined;
+    uniformArray(name: string): UniformArray | undefined;
+    attribute(name: string): number | undefined;
+}
+
+/**
+ * registerProgram — public API for registering custom shader programs.
+ *
+ * Stores raw GLSL source strings in a module-level registry. GL compilation
+ * happens on each WeaselRenderer via WeaselRenderer.registerProgram(), which
+ * calls getProgramSource() and compiles the result. This keeps registerProgram
+ * GL-context-agnostic — identical pattern to registerFont storing ImageBitmap.
+ *
+ * Module-level state = source strings only; compiled GL
+ * programs live on each renderer's programRegistry (Map<id, ShaderProgram>).
+ *
+ * Lifecycle: program sources live for the module lifetime. No unregister in v1.
+ */
+
+/** Opaque handle to a compiled custom shader program. */
+interface ShaderProgramHandle {
+    readonly id: string;
+}
+/**
+ * A value for one uniform in `ShaderDrawCommand.uniforms`.
+ *
+ * | TS type                 | GL call                              |
+ * |-------------------------|--------------------------------------|
+ * | number                  | uniform1f                            |
+ * | [n, n]                  | uniform2fv                           |
+ * | [n, n, n]               | uniform3fv                           |
+ * | [n, n, n, n]            | uniform4fv                           |
+ * | Float32Array length 9   | uniformMatrix3fv (column-major)      |
+ * | Float64Array            | as the Float32Array of its values    |
+ * | Float32Array length 16  | uniformMatrix4fv (column-major)      |
+ * | TextureHandle           | bind to next tex unit + uniform1i    |
+ *
+ * **Array uniforms.** Keyed by an array's bare name (`u_ripples` for
+ * `uniform vec3 u_ripples[8]`), a flat `number[]`, `Float32Array`,
+ * `Int32Array` or `Uint32Array` fills the array from slot 0 in one
+ * `uniform*v` call chosen by the declared element type (`vec3` →
+ * `uniform3fv`, `ivec2` → `uniform2iv`, `mat4` → `uniformMatrix4fv`, …).
+ * Its length must be a whole number of elements and at most the declared
+ * size; a shorter value leaves the remaining slots as they were. Per-slot
+ * keys (`u_ripples[2]`) keep working and take the table above.
+ */
+type ShaderUniform = number | [number, number] | [number, number, number] | [number, number, number, number] | readonly number[] | Float32Array | Float64Array | Int32Array | Uint32Array | TextureHandle;
+/** A registered program's GLSL source. An empty `vert` means the kit's default vertex shader. */
+interface ProgramSource {
+    vert: string;
+    frag: string;
+}
+/** Every registered program's GLSL source, keyed by program id. */
+declare const programSourceRegistry: Reflection<ProgramSource>;
+/** @internal Test helper — do not call from product code. */
+declare function _resetProgramRegistryForTests(): void;
+/** The source registered under `id`, or `null` when nothing is. */
+declare function getProgramSource(id: string): ProgramSource | null;
+/**
+ * Register a custom shader program by id.
+ *
+ * Pass an empty string for `vert` to use the kit's default vertex shader
+ * (recommended). The kit's vertex shader exposes `v_uv`, `v_screen`, and
+ * `v_world` varyings plus `u_bounds` and `u_view` uniforms.
+ *
+ * **IMPORTANT — Premultiplied alpha:**
+ * Your fragment shader MUST output premultiplied alpha:
+ *   `outColor = vec4(rgb * a, a);`  ← correct
+ *   `outColor = vec4(rgb, a);`      ← WRONG — over-brightens translucent regions
+ *
+ * The renderer uses `gl.blendFunc(ONE, ONE_MINUS_SRC_ALPHA)` to match.
+ * Opaque fragments (a=1) are unaffected; only fragments with a < 1 differ.
+ *
+ * **Re-registration behavior:**
+ * - Dev mode (`NODE_ENV !== 'production'`): calling with an existing id and new
+ *   source replaces it (hot reload). Every renderer that compiled the old source
+ *   recompiles on its next frame and deletes the program it replaces; a
+ *   `<Canvas shaders>` naming the id repaints to show it. If the new source fails
+ *   to compile, the renderer logs the error once and keeps drawing the old one.
+ * - Prod mode: calling with an existing id throws.
+ *
+ * Actual GL compilation and `ShaderCompileError` throwing happen in
+ * `WeaselRenderer.registerProgram()`, not here.
+ *
+ * @experimental API may break before v2.
+ */
+declare function registerProgram(id: string, vert: string, frag: string): ShaderProgramHandle;
+
+/**
+ * Resolve a `units: 'bounds'` gradient into the frame its node is painted in.
+ *
+ * Node painters bake the pose into their geometry (`pathInPoseFrame`) rather
+ * than emitting a per-node transform, so by the time the renderer sees a
+ * scene node there is no node-local space left for a gradient to refer to.
+ * This is the paint-side counterpart: it maps box-relative gradient geometry
+ * onto the same box the path was just projected into, so the two arrive in
+ * the renderer in one frame.
+ */
+
+/** The box a `'bounds'` gradient's normalized geometry is mapped onto —
+ *  usually a node's bounds. */
+interface FillPoseBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * Map a `'bounds'` gradient's `0..1` geometry onto `box`, returning it in the
+ * box's own frame (`units: 'local'`). Any other fill — solid, pattern, or a
+ * gradient in another space — is returned untouched.
+ *
+ * Radii scale by the box's normalized diagonal, SVG's rule for a percentage
+ * radius against `objectBoundingBox`: `sqrt(w² + h²) / sqrt(2)`, which is
+ * exactly `w` for a square box. The renderer's radial gradient is circular,
+ * 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): PosedFill;
+/**
+ * Inverse of {@link fillInPoseFrame}: express a gradient already positioned
+ * in `box`'s frame as `0..1` fractions of that box (`units: 'bounds'`), so
+ * it follows the node when moved or resized.
+ *
+ * The importer's counterpart — SVG `userSpaceOnUse` coordinates arrive in
+ * page space, and normalizing them here makes an imported gradient behave
+ * exactly like one drawn in the app.
+ *
+ * A zero-width or zero-height box has no frame to normalize against; the
+ * fill is returned untouched rather than divided by zero.
+ */
+declare function fillToBoundsFrame(fill: FillStyle, box: FillPoseBox): FillStyle;
+
+/**
+ * The renderer's half of a paint kind: what it takes to draw one.
+ *
+ * Solids, patterns and the three gradients are branches inside the GL
+ * renderer and never come through here. A kind beyond those registers its
+ * bind slot, its frame conversions and its shaders, and the renderer consults
+ * this registry for any kind it does not recognize. What an editor or a
+ * serializer needs of a kind is not the renderer's to know; whoever owns
+ * those registers it beside this.
+ */
+
+/** A compiled GL program. A paint kind gets one from
+ *  {@link PaintBindContext.program} and hands it back from `bind`. */
+type PaintProgram = ShaderProgram;
+/**
+ * The lifetime a paint kind's GPU state belongs to: one renderer on one live
+ * context. The object itself is the key — a kind caches textures in a
+ * `WeakMap` on it, so two renderers sharing a context never trade them — and
+ * `onRelease` is where it frees them.
+ */
+interface PaintResources {
+    /** Run `release` once, when this lifetime ends: the renderer is disposed, or
+     *  its context was lost and restored. Free every GL object made under it
+     *  there. */
+    onRelease(release: () => void): void;
+}
+/**
+ * The renderer surface a paint kind binds against, narrowed to what a paint
+ * needs. The full `DrawContext` is not consumer surface.
+ */
+interface PaintBindContext {
+    readonly gl: WebGL2RenderingContext;
+    /** The group alpha this draw inherits — multiply it into the paint's own. */
+    readonly alpha: number;
+    /**
+     * The compiled program for a `registerProgram` id, compiled against this
+     * renderer on first use. `null` when no source is registered under `id` or
+     * compilation failed.
+     */
+    program(id: string): PaintProgram | null;
+    /** Send `u_proj` and `u_model`, which every kit vertex shader takes. */
+    setProjAndModel(program: PaintProgram): void;
+    /**
+     * `u_worldInv` for a paint declaring `units` — the inverse of the transform
+     * from the paint's space to the frame the geometry arrives in. Paired with
+     * the vertex shader's `v_world` varying this is *the* paint-space
+     * convention; it is not gradient-specific.
+     *
+     * `null` when that space has no inverse — a transform or view that flattens
+     * an axis. Nothing the paint draws there means anything, so `bind` should
+     * return `null` and draw nothing.
+     */
+    spaceInverse(units: GradientUnits | undefined): GlMat3 | null;
+    /**
+     * The transform from the space `units` names to device pixels of the target
+     * this draw lands in — screen pixels times the pixel ratio on screen, output
+     * pixels in a headless render. It is what a paint baking a texture measures
+     * its resolution against. `null` where `spaceInverse` is.
+     */
+    spaceToDevice(units: GradientUnits | undefined): GlMat3 | null;
+    /** The largest texture side this context accepts, `MAX_TEXTURE_SIZE`. */
+    readonly maxTextureSize: number;
+    /** The lifetime GPU state made for this draw belongs to. Stable across the
+     *  frames of one renderer, so it is the key for a kind's texture cache. */
+    readonly resources: PaintResources;
+    /**
+     * Bake a stop ramp into the frame's ramp atlas, bind that atlas to a texture
+     * unit, and return the `v` the ramp's own row sits at — every ramp in a
+     * frame shares one texture, so a paint must sample at the returned `v` and
+     * not at a constant.
+     *
+     * `space` is the blend the stops are baked through, defaulting to `'rgb'`.
+     * It is part of the atlas key, so the same stops under two spaces take two
+     * rows rather than colliding.
+     */
+    bindRamp(stops: GradStop[], unit: number, space?: ColorSpace): number;
+}
+/**
+ * What the renderer needs of one paint kind. Every slot is optional, but
+ * `inPoseFrame` and `toBoundsFrame` come as a pair or not at all: a kind that
+ * converts one direction and not the other paints correctly once and then
+ * drifts on the next resize.
+ */
+interface PaintDrawKind {
+    id: string;
+    /**
+     * Render slot: bind program, uniforms and textures for `fill` and return the
+     * bound program; `null` declines the paint.
+     *
+     * Binding is split from drawing on purpose — a caller owning its own stencil
+     * state (an inner/outer-aligned stroke, an even-odd fill) must issue its own
+     * draw call, and the kit's draw wrapper would clobber that state. Shader
+     * output must be premultiplied: `outColor = vec4(rgb * a, a)`.
+     *
+     * The geometry is not always the node's own. Text below the outline tier
+     * paints by drawing a quad over its glyphs' screen box into an offscreen
+     * buffer and masking that with glyph coverage, so a paint must come from
+     * `v_world` through `spaceInverse`, not from where `a_position` happens to
+     * lie.
+     */
+    bind?(ctx: PaintBindContext, fill: FillStyle): PaintProgram | null;
+    /** Bounds frame → the frame the node is painted in. */
+    inPoseFrame?(fill: FillStyle, box: FillPoseBox): FillStyle;
+    /** The inverse. Required whenever `inPoseFrame` is supplied. */
+    toBoundsFrame?(fill: FillStyle, box: FillPoseBox): FillStyle;
+    /**
+     * Shader programs `bind` looks up through `ctx.program`, keyed by program
+     * id; registering the kind registers them. Declaring them here rather than
+     * calling `registerProgram` at import keeps a kind loaded by
+     * {@link registerPaintDrawKindLoader} free of the shader registry.
+     */
+    programs?: Readonly<Record<string, ProgramSource>>;
+}
+/** Every registered draw kind, with the overrides each displaced. */
+declare const paintDrawKindRegistry: Reflection<PaintDrawKind>;
+/** Register a kind's draw half. Returns a disposer that removes it.
+ *  Re-registering an existing id is an override; disposing it uncovers
+ *  whatever it displaced. */
+declare function registerPaintDrawKind(entry: PaintDrawKind): () => void;
+/** The draw half for `kind`, or `undefined`. A lookup that misses on a kind
+ *  with a loader starts that load; see {@link registerPaintDrawKindLoader}. */
+declare function getPaintDrawKind(kind: string | undefined): PaintDrawKind | undefined;
+/** Resolves with the draw half of a kind that is loaded on first use. */
+type PaintDrawKindLoader = () => Promise<PaintDrawKind>;
+/**
+ * Declare a paint kind that is loaded the first time something looks it up,
+ * so its code stays out of the bundle until a paint of it appears — typically
+ * `() => import('./myKind').then((m) => m.myKindEntry)`.
+ *
+ * Until it lands the kind is unregistered and the renderer draws nothing for
+ * its paints. Call {@link warmPaintKinds} to load ahead of the first frame
+ * instead.
+ *
+ * A kind that is already registered never calls its loader. Returns a
+ * disposer that removes the loader.
+ */
+declare function registerPaintDrawKindLoader(id: string, load: PaintDrawKindLoader): () => void;
+/** Is `id` registered, or declared with a loader? */
+declare function isPaintKindKnown(id: string): boolean;
+/**
+ * Load paint kinds ahead of their first use, so the first frame that meets
+ * one draws it rather than a blank. With no list, loads every kind that has a
+ * loader.
+ *
+ * Resolves once every kind is registered; a kind already registered counts
+ * as loaded. Rejects when a load fails, or for a kind that is neither
+ * registered nor loadable.
+ */
+declare function warmPaintKinds(kinds?: readonly string[]): Promise<void>;
+/** @internal Test helper — do not call from product code. */
+declare function _resetPaintDrawKindsForTests(): void;
+
+export { type FillPoseBox as F, type PaintBindContext as P, type ShaderProgramHandle as S, _resetPaintDrawKindsForTests as _, type ShaderUniform as a, ShaderProgram as b, type PaintDrawKind as c, type PaintDrawKindLoader as d, type PaintProgram as e, type PaintResources as f, type ProgramSource as g, ShaderCompileError as h, fillInPoseFrame as i, fillToBoundsFrame as j, getPaintDrawKind as k, getProgramSource as l, isPaintKindKnown as m, programSourceRegistry as n, registerPaintDrawKindLoader as o, paintDrawKindRegistry as p, registerProgram as q, registerPaintDrawKind as r, _resetProgramRegistryForTests as s, warmPaintKinds as w };

package/dist/patterns-builtin.d.ts

@@ -0,0 +1,118 @@
+import { TilePatternSpec, TextureHandle } from '@weasel-js/paint';
+
+/**
+ * The shapes a built-in tile is made of, as data.
+ *
+ * One description, two renderers: `patterns-builtin` strokes/fills these to
+ * an `OffscreenCanvas` to build the GL texture, and `@weasel-js/svg` maps
+ * them to `<pattern>` children. Duplicating the tile drawing in the
+ * serializer would let the raster and vector forms drift apart silently.
+ */
+
+/** One primitive within a pattern tile, in tile-local coordinates. */
+type TileShape = {
+    kind: 'line';
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    width: number;
+    color: string;
+} | {
+    kind: 'circle';
+    cx: number;
+    cy: number;
+    r: number;
+    color: string;
+} | {
+    kind: 'ellipse';
+    cx: number;
+    cy: number;
+    rx: number;
+    ry: number;
+    rotation: number;
+    color: string;
+} | {
+    kind: 'rect';
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    color: string;
+};
+/** A built-in tile's shapes plus the edge length they're drawn within. */
+interface TileGeometry {
+    size: number;
+    shapes: TileShape[];
+}
+/** Defaults per tile kind, matching each factory's signature. */
+declare function tileSize(spec: TilePatternSpec): number;
+/** Resolve a pattern spec to the shapes that make up one tile. Consumers that
+ *  want to draw a pattern swatch themselves — a picker, an SVG export — read
+ *  this rather than rasterizing a texture. */
+declare function tileGeometry(spec: TilePatternSpec): TileGeometry;
+/** Draw a tile's shapes to a 2D context — the raster half of the pair. */
+declare function drawTileShapes(oc: CanvasRenderingContext2D, geometry: TileGeometry): void;
+
+/**
+ * Built-in pattern factories — generic line/dot/scatter textures. Each
+ * returns a `TextureHandle` you can wrap in a `FillStyle` of
+ * `{ fill: 'pattern', pattern }` and pass to anything that accepts a `FillStyle`
+ * (`FillStyle`-aware layers, path fills, etc.).
+ * Imported from a subpath so consumers that ship their own catalog can
+ * avoid the bundle cost.
+ *
+ * All factories require an explicit `color` (and `bg` for `chunks`). No
+ * defaults are baked in — the caller's design system is the source of truth
+ * for palette decisions.
+ *
+ * Each is a thin wrapper over `tileGeometry`, which describes the tile as
+ * shapes so `@weasel-js/svg` can emit the same tile as a `<pattern>`.
+ * Prefer naming a tile in a `TilePatternSpec` over calling these directly —
+ * a spec serializes, a `TextureHandle` does not.
+ */
+
+/** Diagonal hatch (forward slash). */
+interface HatchParams {
+    color: string;
+    size?: number;
+    lineWidth?: number;
+}
+/** Build a diagonal-hatch pattern texture. */
+declare function hatch(params: HatchParams): TextureHandle | null;
+/** Diagonal hatch in both directions. */
+interface CrosshatchParams {
+    color: string;
+    size?: number;
+    lineWidth?: number;
+}
+/** Build a crosshatch pattern texture. */
+declare function crosshatch(params: CrosshatchParams): TextureHandle | null;
+/** Regular grid of filled dots. */
+interface DotsParams {
+    color: string;
+    size?: number;
+    radius?: number;
+}
+/** Build a dot-grid pattern texture. */
+declare function dots(params: DotsParams): TextureHandle | null;
+/**
+ * Random scatter of small ellipses on top of a solid background. Driven by a
+ * seeded PRNG so the same `seed` produces a deterministic tile.
+ *
+ * Note: the `bg` field is optional — omit it for a transparent background
+ * (the scatter shapes draw directly onto whatever sits beneath the overlay).
+ */
+interface ChunksParams {
+    color: string;
+    bg?: string;
+    size?: number;
+    /** Coverage: `chunks * chunkSize²` per `size²` tile. Range ~[0, 1]. */
+    density?: number;
+    chunkSize?: number;
+    seed?: number;
+}
+/** Build a seeded random-scatter pattern texture. */
+declare function chunks(params: ChunksParams): TextureHandle | null;
+
+export { type ChunksParams, type CrosshatchParams, type DotsParams, type HatchParams, type TileGeometry, type TileShape, chunks, crosshatch, dots, drawTileShapes, hatch, tileGeometry, tileSize };

package/dist/patterns-builtin.js

@@ -0,0 +1,28 @@
+import { createTilePattern } from './chunk-2VOBNWBN.js';
+import { tileGeometry, drawTileShapes, tileSize } from './chunk-ORBXHIRB.js';
+export { drawTileShapes, tileGeometry, tileSize } from './chunk-ORBXHIRB.js';
+
+// src/patterns/patterns-builtin.ts
+function build(spec) {
+  const geometry = tileGeometry(spec);
+  return createTilePattern({
+    size: tileSize(spec),
+    draw: (oc) => drawTileShapes(oc, geometry)
+  });
+}
+function hatch(params) {
+  return build({ tile: "hatch", ...params });
+}
+function crosshatch(params) {
+  return build({ tile: "crosshatch", ...params });
+}
+function dots(params) {
+  return build({ tile: "dots", ...params });
+}
+function chunks(params) {
+  return build({ tile: "chunks", ...params });
+}
+
+export { chunks, crosshatch, dots, hatch };
+//# sourceMappingURL=patterns-builtin.js.map
+//# sourceMappingURL=patterns-builtin.js.map

package/dist/patterns-builtin.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/patterns/patterns-builtin.ts"],"names":[],"mappings":";;;;;AA0BA,SAAS,MAAM,IAAA,EAA6C;AAC1D,EAAA,MAAM,QAAA,GAAW,aAAa,IAAI,CAAA;AAClC,EAAA,OAAO,iBAAA,CAAkB;AAAA,IACvB,IAAA,EAAM,SAAS,IAAI,CAAA;AAAA,IACnB,IAAA,EAAM,CAAC,EAAA,KAAO,cAAA,CAAe,IAAI,QAAQ;AAAA,GAC1C,CAAA;AACH;AAUO,SAAS,MAAM,MAAA,EAA2C;AAC/D,EAAA,OAAO,MAAM,EAAE,IAAA,EAAM,OAAA,EAAS,GAAG,QAAQ,CAAA;AAC3C;AAUO,SAAS,WAAW,MAAA,EAAgD;AACzE,EAAA,OAAO,MAAM,EAAE,IAAA,EAAM,YAAA,EAAc,GAAG,QAAQ,CAAA;AAChD;AAUO,SAAS,KAAK,MAAA,EAA0C;AAC7D,EAAA,OAAO,MAAM,EAAE,IAAA,EAAM,MAAA,EAAQ,GAAG,QAAQ,CAAA;AAC1C;AAoBO,SAAS,OAAO,MAAA,EAA4C;AACjE,EAAA,OAAO,MAAM,EAAE,IAAA,EAAM,QAAA,EAAU,GAAG,QAAQ,CAAA;AAC5C","file":"patterns-builtin.js","sourcesContent":["/**\n * Built-in pattern factories — generic line/dot/scatter textures. Each\n * returns a `TextureHandle` you can wrap in a `FillStyle` of\n * `{ fill: 'pattern', pattern }` and pass to anything that accepts a `FillStyle`\n * (`FillStyle`-aware layers, path fills, etc.).\n * Imported from a subpath so consumers that ship their own catalog can\n * avoid the bundle cost.\n *\n * All factories require an explicit `color` (and `bg` for `chunks`). No\n * defaults are baked in — the caller's design system is the source of truth\n * for palette decisions.\n *\n * Each is a thin wrapper over `tileGeometry`, which describes the tile as\n * shapes so `@weasel-js/svg` can emit the same tile as a `<pattern>`.\n * Prefer naming a tile in a `TilePatternSpec` over calling these directly —\n * a spec serializes, a `TextureHandle` does not.\n */\n\nexport { tileGeometry, tileSize, drawTileShapes } from './tileGeometry';\nexport type { TileShape, TileGeometry } from './tileGeometry';\n\nimport { createTilePattern } from './';\nimport { tileGeometry, drawTileShapes, tileSize } from './tileGeometry';\nimport type { TilePatternSpec } from '@weasel-js/paint';\nimport type { TextureHandle } from '../textures/registerTexture';\n\nfunction build(spec: TilePatternSpec): TextureHandle | null {\n  const geometry = tileGeometry(spec);\n  return createTilePattern({\n    size: tileSize(spec),\n    draw: (oc) => drawTileShapes(oc, geometry),\n  });\n}\n\n/** Diagonal hatch (forward slash). */\nexport interface HatchParams {\n  color: string;\n  size?: number;\n  lineWidth?: number;\n}\n\n/** Build a diagonal-hatch pattern texture. */\nexport function hatch(params: HatchParams): TextureHandle | null {\n  return build({ tile: 'hatch', ...params });\n}\n\n/** Diagonal hatch in both directions. */\nexport interface CrosshatchParams {\n  color: string;\n  size?: number;\n  lineWidth?: number;\n}\n\n/** Build a crosshatch pattern texture. */\nexport function crosshatch(params: CrosshatchParams): TextureHandle | null {\n  return build({ tile: 'crosshatch', ...params });\n}\n\n/** Regular grid of filled dots. */\nexport interface DotsParams {\n  color: string;\n  size?: number;\n  radius?: number;\n}\n\n/** Build a dot-grid pattern texture. */\nexport function dots(params: DotsParams): TextureHandle | null {\n  return build({ tile: 'dots', ...params });\n}\n\n/**\n * Random scatter of small ellipses on top of a solid background. Driven by a\n * seeded PRNG so the same `seed` produces a deterministic tile.\n *\n * Note: the `bg` field is optional — omit it for a transparent background\n * (the scatter shapes draw directly onto whatever sits beneath the overlay).\n */\nexport interface ChunksParams {\n  color: string;\n  bg?: string;\n  size?: number;\n  /** Coverage: `chunks * chunkSize²` per `size²` tile. Range ~[0, 1]. */\n  density?: number;\n  chunkSize?: number;\n  seed?: number;\n}\n\n/** Build a seeded random-scatter pattern texture. */\nexport function chunks(params: ChunksParams): TextureHandle | null {\n  return build({ tile: 'chunks', ...params });\n}\n"]}