@weasel-js/core 1.9.3 → 1.10.0

package/dist/{features/meshPaint/lazyKind.js → core/paint/meshKindLazy.js}

@@ -1,5 +1,25 @@
-//#region ../paint/dist/index.js
-var SRGB_TO_LINEAR = (() => {
+//#region ../paint/src/hex.ts
+const HEX = /^#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
+/**
+* The kit's one hex color reader: `#rgb`, `#rgba`, `#rrggbb`, or `#rrggbbaa`,
+* in any case, as four 0..255 channels with alpha last (255 when the color
+* names none). `null` for anything else, a missing `#` included.
+*/
+function parseHexBytes(input) {
+	if (!HEX.test(input)) return null;
+	const digits = input.slice(1);
+	const long = digits.length <= 4 ? digits.replace(/./g, "$&$&") : digits;
+	const byte = (i) => Number.parseInt(long.slice(i, i + 2), 16);
+	return [
+		byte(0),
+		byte(2),
+		byte(4),
+		long.length === 8 ? byte(6) : 255
+	];
+}
+//#endregion
+//#region ../paint/src/colorSpaces.ts
+const SRGB_TO_LINEAR = (() => {
 	const lut = /* @__PURE__ */ new Float64Array(256);
 	for (let i = 0; i < 256; i++) {
 		const c = i / 255;
@@ -13,13 +33,24 @@ function linearToSrgbByte(c) {
 	const v = c <= .0031308 ? c * 12.92 : 1.055 * Math.pow(c, 1 / 2.4) - .055;
 	return Math.round(v * 255);
 }
-var f2u = (v) => Math.max(0, Math.min(255, Math.round(v * 255)));
+/** 0..1 float channel to the 8-bit index the LUTs are cut for. Rounds and
+*  clamps; `& 0xff` would truncate, and wrap anything out of range. */
+const f2u = (v) => Math.max(0, Math.min(255, Math.round(v * 255)));
+/**
+* Convert a 0..1 float sRGB triple to OKLab — the renderer's own color space,
+* and what a caller holding a `resolveColor` result has. Rounds into the u8
+* grid the way every other float→u8 crossing in this file does, rather than
+* leaving each caller to pick a convention.
+*/
 function srgbFloatToOklab(r, g, b) {
 	return srgbU8ToOklab(f2u(r), f2u(g), f2u(b));
 }
+/** Convert an 8-bit sRGB triple to OKLab. Channels are indices into a 256-entry
+*  LUT: pass integers, or `srgbFloatToOklab` for 0..1 floats. */
 function srgbU8ToOklab(r, g, b) {
 	return linearSrgbToOklab(SRGB_TO_LINEAR[r & 255], SRGB_TO_LINEAR[g & 255], SRGB_TO_LINEAR[b & 255]);
 }
+/** Linear-light sRGB (0..1 floats, unclamped) to OKLab. */
 function linearSrgbToOklab(rl, gl, bl) {
 	const l = .4122214708 * rl + .5363325363 * gl + .0514459929 * bl;
 	const m = .2119034982 * rl + .6806995451 * gl + .1073969566 * bl;
@@ -33,6 +64,8 @@ function linearSrgbToOklab(rl, gl, bl) {
 		.0259040371 * lp + .7827717662 * mp - .808675766 * sp
 	];
 }
+/** OKLab to linear-light sRGB. Not gamut-clipped: out-of-gamut colors come
+*  back with channels outside 0..1. */
 function oklabToLinearSrgb(L, A, B) {
 	const lp = L + .3963377774 * A + .2158037573 * B;
 	const mp = L - .1055613458 * A - .0638541728 * B;
@@ -71,6 +104,7 @@ function clipToGamut(L, A, B) {
 		bl
 	];
 }
+/** Convert OKLab back to an 8-bit sRGB triple, clamped into gamut. */
 function oklabToSrgbU8(L, A, B) {
 	const [rl, gl, bl] = clipToGamut(L, A, B);
 	return [
@@ -79,6 +113,9 @@ function oklabToSrgbU8(L, A, B) {
 		linearToSrgbByte(bl)
 	];
 }
+/** Blend two 8-bit sRGB colors through OKLab. Perceptually even, and it does
+*  not pass through the muddy midpoints an sRGB blend produces between
+*  complementary hues. */
 function lerpOklab(from, to, t) {
 	return [
 		from[0] + (to[0] - from[0]) * t,
@@ -86,6 +123,7 @@ function lerpOklab(from, to, t) {
 		from[2] + (to[2] - from[2]) * t
 	];
 }
+/** Convert OKLab (L, a, b) to OKLCh (L, C, h). h is in radians, range [-π, π]. */
 function oklabToOklch(L, A, B) {
 	return [
 		L,
@@ -93,6 +131,7 @@ function oklabToOklch(L, A, B) {
 		Math.atan2(B, A)
 	];
 }
+/** Convert OKLCh (L, C, h) to OKLab (L, a, b). h is in radians. */
 function oklchToOklab(L, C, h) {
 	return [
 		L,
@@ -100,6 +139,10 @@ function oklchToOklab(L, C, h) {
 		C * Math.sin(h)
 	];
 }
+/** Lerp OKLCh values with shortest-arc hue interpolation. Lightness and
+*  chroma lerp linearly. When chroma is near zero on either endpoint, hue
+*  is taken from the other endpoint (avoids hue snap-from-undefined).
+*  h inputs are in radians. */
 function lerpOklch(from, to, t) {
 	const [L1, C1, h1Raw] = from;
 	const [L2, C2, h2Raw] = to;
@@ -116,7 +159,14 @@ function lerpOklch(from, to, t) {
 		h1 + dh * t
 	];
 }
-var u2f = (v) => v / 255;
+const u2f = (v) => v / 255;
+/** Lerp a flat RGBA color array `from` toward `to`. Inputs are 0..1
+*  floats (the renderer's color space); outputs are 0..1 floats too.
+*  Alpha is always linearly lerped; RGB channels are lerped in the
+*  requested color space. OKLab / OKLCh paths bounce through u8 because
+*  the gamma-correction LUT and gamut-clip routines are byte-keyed —
+*  the round-trip is lossy at <1% per channel, well under the visible
+*  threshold for these animations. */
 function lerpColorArray(from, to, t, space = "rgb") {
 	if (from.length !== to.length) throw new Error(`lerpColorArray: length mismatch (from=${from.length}, to=${to.length})`);
 	if (from.length % 4 !== 0) throw new Error(`lerpColorArray: length ${from.length} not divisible by 4`);
@@ -152,6 +202,7 @@ function lerpColorArray(from, to, t, space = "rgb") {
 	}
 	return out;
 }
+/** HSL to sRGB. Hue in degrees, saturation, lightness and output all 0..1. */
 function hslToSrgb(h, s, l) {
 	if (s === 0) return [
 		l,
@@ -176,7 +227,7 @@ function hueToChannel(p, q, t) {
 	return p;
 }
 //#endregion
-//#region src/renderer/math/color.ts
+//#region ../paint/src/color.ts
 /**
 * Parse a CSS color string into [r, g, b, a] with 0..1 components.
 *
@@ -225,12 +276,8 @@ function parseColorUncached(input) {
 const RESOLVE_COLOR_CACHE_CAP = 1024;
 const resolveColorCache = /* @__PURE__ */ new Map();
 /** Cached `parseColor`. Use this from renderer hot paths (per-frame draw
-*  callbacks, gradient ramp builds) so repeated color strings — which are
-*  common when many objects share a fill — don't re-tokenize each frame.
-*
-*  Cache is keyed by input-string identity, capped at ~1024 entries, and
-*  cleared wholesale on overflow (no LRU tracking — simple is fine since
-*  the working set in any one app is typically much smaller than the cap). */
+*  callbacks, gradient ramp builds). The cache is capped at ~1024 entries and
+*  cleared wholesale on overflow. */
 function resolveColor(input) {
 	const hit = resolveColorCache.get(input);
 	if (hit) return hit;
@@ -251,32 +298,14 @@ function rgbaToHex(rgba) {
 	return a >= 1 ? base : `${base}${f(a)}`;
 }
 function parseHex(s) {
-	const hex = s.slice(1);
-	if (hex.length === 3) return [
-		parseInt(hex[0] + hex[0], 16) / 255,
-		parseInt(hex[1] + hex[1], 16) / 255,
-		parseInt(hex[2] + hex[2], 16) / 255,
-		1
-	];
-	if (hex.length === 4) return [
-		parseInt(hex[0] + hex[0], 16) / 255,
-		parseInt(hex[1] + hex[1], 16) / 255,
-		parseInt(hex[2] + hex[2], 16) / 255,
-		parseInt(hex[3] + hex[3], 16) / 255
-	];
-	if (hex.length === 6) return [
-		parseInt(hex.slice(0, 2), 16) / 255,
-		parseInt(hex.slice(2, 4), 16) / 255,
-		parseInt(hex.slice(4, 6), 16) / 255,
-		1
-	];
-	if (hex.length === 8) return [
-		parseInt(hex.slice(0, 2), 16) / 255,
-		parseInt(hex.slice(2, 4), 16) / 255,
-		parseInt(hex.slice(4, 6), 16) / 255,
-		parseInt(hex.slice(6, 8), 16) / 255
+	const bytes = parseHexBytes(s);
+	if (!bytes) throw new Error(`parseColor: invalid hex "${s}"`);
+	return [
+		bytes[0] / 255,
+		bytes[1] / 255,
+		bytes[2] / 255,
+		bytes[3] / 255
 	];
-	throw new Error(`parseColor: invalid hex "${s}"`);
 }
 /** Match `name( body )` and return the trimmed body, or null. */
 function unwrapFn(s, name) {
@@ -362,7 +391,7 @@ function parseHslFunction(s) {
 	const sat = parsePercentOrNumber(channels.rgb[1]);
 	const lit = parsePercentOrNumber(channels.rgb[2]);
 	if (h === null || sat === null || lit === null) return null;
-	const [r, g, b] = hslToRgb(h, sat, lit);
+	const [r, g, b] = hslToSrgb(h, sat, lit);
 	return [
 		r,
 		g,
@@ -390,13 +419,6 @@ function parsePercentOrNumber(tok) {
 	const n = Number(tok);
 	return Number.isFinite(n) ? clamp01(n) : null;
 }
-/**
-* HSL → RGB, all components 0..1 except hue in degrees (0..360). paint's
-* `hslToSrgb` under the name this file's callers use.
-*
-* @internal Not part of the public API; not re-exported from the barrel.
-*/
-const hslToRgb = hslToSrgb;
 function clamp01(n) {
 	return n < 0 ? 0 : n > 1 ? 1 : n;
 }
@@ -569,7 +591,158 @@ const NAMED_COLORS = (() => {
 	return out;
 })();
 //#endregion
-//#region src/features/meshPaint/surface.ts
+//#region ../geom/src/mat3.ts
+/**
+* 2D affine transforms in canvas/DOMMatrix order: [a, b, c, d, e, f].
+*   x' = a·x + c·y + e
+*   y' = b·x + d·y + f
+* Represented as a readonly 6-tuple (f64). The affine tier of the kernel.
+*
+* `glMat3.ts` beside this file holds the renderer's matrix: a 9-element
+* column-major array (a full 3×3) laid out for `uniformMatrix3fv`. Its
+* *logical element order* is identical to ours.
+*/
+/** Inverse, or null when the matrix is singular, non-finite, or too
+*  ill-conditioned to invert meaningfully at its own scale. */
+function invert$1(m) {
+	const det = m[0] * m[3] - m[1] * m[2];
+	const norm2 = Math.max(m[0] * m[0] + m[1] * m[1], m[2] * m[2] + m[3] * m[3]);
+	if (!(Math.abs(det) > 1e-12 * norm2)) return null;
+	const id = 1 / det;
+	const a = m[3] * id;
+	const b = -m[1] * id;
+	const c = -m[2] * id;
+	const d = m[0] * id;
+	return [
+		a,
+		b,
+		c,
+		d,
+		-(m[4] * a + m[5] * c),
+		-(m[4] * b + m[5] * d)
+	];
+}
+//#endregion
+//#region ../geom/src/glMat3.ts
+/**
+* 2D affine matrix utilities. Column-major 9 elements, matching
+* `WebGL2RenderingContext.uniformMatrix3fv` element order so an upload needs
+* no transpose flag.
+*
+* Layout (column-major):
+*   [m00, m10, 0,
+*    m01, m11, 0,
+*    tx,  ty,  1]
+*/
+function create(a, b, c, d, tx, ty) {
+	return new Float64Array([
+		a,
+		b,
+		0,
+		c,
+		d,
+		0,
+		tx,
+		ty,
+		1
+	]);
+}
+function identity() {
+	return create(1, 0, 0, 1, 0, 0);
+}
+function multiply(out, m) {
+	const a = out[0], b = out[1];
+	const c = out[3], d = out[4];
+	const tx = out[6], ty = out[7];
+	const ma = m[0], mb = m[1];
+	const mc = m[3], md = m[4];
+	const mtx = m[6], mty = m[7];
+	return create(a * ma + c * mb, b * ma + d * mb, a * mc + c * md, b * mc + d * md, a * mtx + c * mty + tx, b * mtx + d * mty + ty);
+}
+/** `m · T(tx, ty)`: composes onto `m`, where `@weasel-js/geom`'s `translate`
+*  constructs a fresh matrix. */
+function translated(m, tx, ty) {
+	return multiply(m, create(1, 0, 0, 1, tx, ty));
+}
+/** `m · S(sx, sy)`: composes onto `m`, where geom's `scale` constructs one. */
+function scaled(m, sx, sy) {
+	return multiply(m, create(sx, 0, 0, sy, 0, 0));
+}
+/** This layout read as the kernel's 6-element affine. The two carry the same
+*  logical order, so the conversion is a repack and nothing else. */
+function toAffine(m) {
+	return [
+		m[0],
+		m[1],
+		m[3],
+		m[4],
+		m[6],
+		m[7]
+	];
+}
+/** The kernel's affine in this layout. The inverse of {@link toAffine}. */
+function fromAffine(a) {
+	return create(a[0], a[1], a[2], a[3], a[4], a[5]);
+}
+/** Inverse of an affine matrix, or `null` when `@weasel-js/geom`'s `invert`
+*  finds it singular — the same rule, read through this layout. */
+function invert(m) {
+	const inv = invert$1(toAffine(m));
+	return inv && fromAffine(inv);
+}
+/** A float32 copy of `m`, for `uniformMatrix3fv` or a shader uniform value. */
+function toUniform(m) {
+	return Float32Array.from(m);
+}
+function apply(m, x, y) {
+	const a = m[0], b = m[1];
+	const c = m[3], d = m[4];
+	const tx = m[6], ty = m[7];
+	return [a * x + c * y + tx, b * x + d * y + ty];
+}
+/**
+* Map screen pixel coords (0..width on X, 0..height on Y, top-left origin)
+* into clip space (-1..1 on X, 1..-1 on Y — note Y flip so screen-down
+* matches clip-down).
+*/
+function screenToClip(width, height) {
+	return create(2 / width, 0, 0, -2 / height, -1, 1);
+}
+/**
+* Uniform-equivalent scale factor: the square root of the absolute
+* determinant of the linear part, i.e. the geometric mean of the two axis
+* scales. Rotation-invariant. Under non-uniform scale it is between the two
+* axes and exact on neither — the same compromise `meanScale` documents.
+*/
+function meanScaleOf(m) {
+	return Math.sqrt(Math.abs(m[0] * m[4] - m[1] * m[3]));
+}
+/** The least any direction is scaled by the linear part — its smaller singular
+*  value. What a screen length is worth in world units, at most. */
+function minScaleOf(m) {
+	const sum = m[0] * m[0] + m[1] * m[1] + m[3] * m[3] + m[4] * m[4];
+	const det = m[0] * m[4] - m[1] * m[3];
+	return Math.sqrt(Math.max(0, (sum - Math.sqrt(Math.max(0, sum * sum - 4 * det * det))) / 2));
+}
+/** The renderer's 3x3 matrix operations, as one namespace. These work on the
+*  9-element form the GL uniform upload wants — distinct from the 6-element
+*  affine `Mat3`, though the logical element order is the same. */
+const mat3 = {
+	identity,
+	toAffine,
+	fromAffine,
+	multiply,
+	translated,
+	scaled,
+	invert,
+	toUniform,
+	apply,
+	screenToClip,
+	meanScaleOf,
+	minScaleOf
+};
+//#endregion
+//#region ../renderer/src/meshPaint/surface.ts
 /** Corner `i` of the boundary walk. */
 function patchCorner(patch, i) {
 	return patch.points[(i & 3) * 3];
@@ -692,9 +865,8 @@ function evalTensor(patch, u, v) {
 		y
 	};
 }
-/** Axis-aligned bounds of a patch, sampled on a grid. Control points alone
-*  bound a Bézier but not tightly, and a mesh paint is baked into a texture
-*  sized from this — a loose box wastes texels on every side. */
+/** Axis-aligned bounds of a patch, sampled on a grid: control points alone
+*  bound a Bézier but not tightly. */
 function patchBounds(patch, steps = 8) {
 	let minX = Infinity;
 	let minY = Infinity;
@@ -745,20 +917,16 @@ function meshBounds(patches) {
 	};
 }
 /**
-* Corner colors blended at `(u, v)` in `space`.
-*
-* Bilinear as three lerps rather than four weights, because a perceptual space
-* has a midpoint between two colors and no meaningful four-way mix — OKLCh's
-* hue in particular is an arc, which only two endpoints define.
+* Corner colors blended at `(u, v)` in `space`. Three lerps rather than four
+* weights, because a perceptual space has no meaningful four-way mix — OKLCh's
+* hue is an arc, which only two endpoints define.
 */
 function colorAt(corners, u, v, space) {
 	return lerpColorArray(lerpColorArray(corners[0], corners[1], u, space), lerpColorArray(corners[3], corners[2], u, space), v, space);
 }
 /**
-* Rasterize `patches` into a square bitmap covering their union.
-*
-* Returns `null` when no patch is drawable, which is the caller's cue to paint
-* nothing rather than a blank square.
+* Rasterize `patches` into a square bitmap covering their union, or `null`
+* when no patch is drawable.
 */
 function bakeMesh(patches, space = "rgb", size = 256) {
 	const box = meshBounds(patches);
@@ -806,11 +974,9 @@ function bakeMesh(patches, space = "rgb", size = 256) {
 	};
 }
 /**
-* One triangle, barycentric, colors interpolated across it.
-*
-* Neighboring cells share an edge, so a pixel exactly on one is claimed by
-* both — harmless here because both carry the same color there, and cheaper
-* than a fill rule.
+* One triangle, barycentric, colors interpolated across it. A pixel exactly on
+* an edge two cells share is claimed by both — harmless, because both carry
+* the same color there.
 */
 function fillTriangle(pixels, size, a, b, c) {
 	const minX = Math.max(0, Math.floor(Math.min(a.at.x, b.at.x, c.at.x)));
@@ -929,23 +1095,17 @@ var MeshBakeCache = class {
 	}
 };
 //#endregion
-//#region src/features/meshPaint/meshShader.ts
+//#region ../renderer/src/meshPaint/meshShader.ts
 /**
 * GLSL ES 3.0 sources for the mesh-gradient paint.
 *
-* The vertex stage is the pattern/gradient one: a path fill mesh carries
-* `a_position` only, so paint-space coordinates come back per fragment from
-* the screen position through `u_worldInv`. The fragment stage is a clamped
-* texture read of the baked mesh, with everything outside the bake's box
-* transparent — a mesh covers the area its patches cover, not the whole shape
-* it is filling, and a clamped read would otherwise smear its border colors
-* across the rest.
+* Everything outside the bake's box is transparent: a mesh covers the area its
+* patches cover, not the whole shape it is filling, and a clamped read would
+* otherwise smear its border colors across the rest.
 *
 * `u_meshOrigin` / `u_meshSize` are the bake's box in paint space, and the
 * bake maps that box onto texel *centers*, which is the half-texel the uv
-* rescale accounts for.
-*
-* Output convention §2: PREMULTIPLIED alpha.
+* rescale accounts for. Output is PREMULTIPLIED alpha.
 */
 /** The id this program is registered under. */
 const MESH_PROGRAM_ID = "kit:mesh-gradient";
@@ -986,13 +1146,13 @@ void main() {
 }
 `;
 //#endregion
-//#region src/features/meshPaint/meshPaint.ts
-/** The kind's id, as `FillStyle['fill']` carries it. */
+//#region ../renderer/src/meshPaint/meshPaint.ts
+/** The kind's id, as `Paint['fill']` carries it. */
 const MESH_GRADIENT_KIND = "mesh-gradient";
-function asMesh(fill) {
+function asMesh$1(fill) {
 	return fill;
 }
-function asFill(mesh) {
+function asFill$1(mesh) {
 	return mesh;
 }
 /**
@@ -1050,7 +1210,7 @@ function seedMeshPatch(color) {
 		});
 	}
 	return {
-		fill: MESH_GRADIENT_KIND,
+		kind: MESH_GRADIENT_KIND,
 		patches: [{
 			points,
 			colors: [
@@ -1125,7 +1285,7 @@ function meshFromStops(stops) {
 		if (b.offset > a.offset) patches.push(bandPatch(a.offset, b.offset, a.color, b.color));
 	}
 	return {
-		fill: MESH_GRADIENT_KIND,
+		kind: MESH_GRADIENT_KIND,
 		patches,
 		units: "bounds"
 	};
@@ -1159,12 +1319,15 @@ function mapPatches(mesh, move) {
 		points: patch.points.map(move)
 	}));
 }
+/** The paint a pose-frame copy was made from. A copy is rebuilt whenever its
+*  node's pose changes, and bakes the same texels as its source. */
+const BAKE_SOURCE = /* @__PURE__ */ new WeakMap();
 const CACHES = /* @__PURE__ */ new WeakMap();
 function cacheFor(ctx) {
 	let cache = CACHES.get(ctx.resources);
 	if (!cache) {
 		const gl = ctx.gl;
-		const made = new MeshBakeCache((entry) => gl.deleteTexture(entry.texture));
+		const made = new MeshBakeCache((texture) => gl.deleteTexture(texture));
 		ctx.resources.onRelease(() => {
 			made.clear();
 			CACHES.delete(ctx.resources);
@@ -1185,8 +1348,12 @@ function bakeFor(ctx, mesh) {
 	if (!box) return null;
 	const size = meshBakeSize(devicePixelsOf(ctx, mesh, box), ctx.maxTextureSize);
 	const cache = cacheFor(ctx);
-	const hit = cache.get(mesh, size);
-	if (hit) return hit;
+	const key = BAKE_SOURCE.get(mesh) ?? mesh;
+	const hit = cache.get(key, size);
+	if (hit) return {
+		texture: hit,
+		box
+	};
 	const baked = bakeMesh(mesh.patches, mesh.interpolate ?? "rgb", size);
 	if (!baked) return null;
 	const gl = ctx.gl;
@@ -1199,15 +1366,14 @@ function bakeFor(ctx, mesh) {
 	gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
 	gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, baked.size, baked.size, 0, gl.RGBA, gl.UNSIGNED_BYTE, baked.pixels);
 	gl.bindTexture(gl.TEXTURE_2D, null);
-	const entry = {
+	cache.set(key, size, texture);
+	return {
 		texture,
-		baked
+		box
 	};
-	cache.set(mesh, size, entry);
-	return entry;
 }
 function bindMesh(ctx, fill) {
-	const mesh = asMesh(fill);
+	const mesh = asMesh$1(fill);
 	if (!mesh.patches.some(isValidPatch)) return null;
 	const inverse = ctx.spaceInverse(mesh.units);
 	if (!inverse) return null;
@@ -1218,36 +1384,30 @@ function bindMesh(ctx, fill) {
 	const gl = ctx.gl;
 	gl.useProgram(program.handle);
 	ctx.setProjAndModel(program);
-	gl.uniformMatrix3fv(program.uniform("u_worldInv"), false, inverse);
+	gl.uniformMatrix3fv(program.uniform("u_worldInv"), false, mat3.toUniform(inverse));
 	gl.activeTexture(gl.TEXTURE0);
 	gl.bindTexture(gl.TEXTURE_2D, entry.texture);
 	gl.uniform1i(program.uniform("u_sampler"), 0);
-	const { box } = entry.baked;
+	const { box } = entry;
 	gl.uniform2f(program.uniform("u_meshOrigin"), box.x, box.y);
 	gl.uniform2f(program.uniform("u_meshSize"), box.width, box.height);
 	gl.uniform1f(program.uniform("u_opacity"), mesh.opacity ?? 1);
 	gl.uniform1f(program.uniform("u_alpha"), ctx.alpha);
 	return program;
 }
-/** The kind's registry entry, shader program included. `./register` registers
-*  it; core's paint-kind registry loads it on demand otherwise. */
-const meshGradientKind = {
+/** The kind's draw half, shader program included. Core adds the editor's
+*  slots and registers the whole entry. */
+const meshDrawKind = {
 	id: MESH_GRADIENT_KIND,
 	programs: { [MESH_PROGRAM_ID]: {
 		vert: MESH_VERT_SRC,
 		frag: MESH_FRAG_SRC
 	} },
-	label: "Mesh",
-	icon: "paintMesh",
-	seed: (color) => asFill(seedMeshPatch(color)),
-	colorOf: (paint) => asMesh(paint).patches?.[0]?.colors?.[0],
-	stopsOf: (paint) => meshStops(asMesh(paint)),
-	fromStops: (stops) => asFill(meshFromStops(stops)),
 	bind: bindMesh,
 	inPoseFrame: (fill, box) => {
-		const mesh = asMesh(fill);
+		const mesh = asMesh$1(fill);
 		if (mesh.units !== "bounds") return fill;
-		return asFill({
+		const posed = asFill$1({
 			...mesh,
 			patches: mapPatches(mesh, (p) => ({
 				x: box.x + p.x * box.width,
@@ -1255,11 +1415,13 @@ const meshGradientKind = {
 			})),
 			units: "local"
 		});
+		BAKE_SOURCE.set(posed, fill);
+		return posed;
 	},
 	toBoundsFrame: (fill, box) => {
-		const mesh = asMesh(fill);
+		const mesh = asMesh$1(fill);
 		if (mesh.units === "bounds" || box.width === 0 || box.height === 0) return fill;
-		return asFill({
+		return asFill$1({
 			...mesh,
 			patches: mapPatches(mesh, (p) => ({
 				x: (p.x - box.x) / box.width,
@@ -1267,8 +1429,7 @@ const meshGradientKind = {
 			})),
 			units: "bounds"
 		});
-	},
-	toSvg: (id, fill) => meshGradientXml(id, asMesh(fill))
+	}
 };
 /**
 * The `<defs>` entry for a mesh paint, in weasel's own namespace.
@@ -1293,6 +1454,22 @@ function trim(n) {
 	return Number.isInteger(n) ? String(n) : String(Number(n.toFixed(4)));
 }
 //#endregion
+//#region src/core/paint/meshKind.ts
+const asMesh = (fill) => fill;
+const asFill = (mesh) => mesh;
+/** The `mesh-gradient` kind's registry entry. `./registerMesh` registers it;
+*  the paint-kind registry loads it on demand otherwise. */
+const meshGradientKind = {
+	...meshDrawKind,
+	label: "Mesh",
+	icon: "paintMesh",
+	seed: (color) => asFill(seedMeshPatch(color)),
+	colorOf: (paint) => asMesh(paint).patches?.[0]?.colors?.[0],
+	stopsOf: (paint) => meshStops(asMesh(paint)),
+	fromStops: (stops) => asFill(meshFromStops(stops)),
+	toSvg: (id, fill) => meshGradientXml(id, asMesh(fill))
+};
+//#endregion
 export { meshGradientKind };
 
-//# sourceMappingURL=lazyKind.js.map
+//# sourceMappingURL=meshKindLazy.js.map