@weasel-js/core 1.9.4 → 1.10.0

package/dist/features/meshPaint/meshPaint.js

@@ -1,239 +0,0 @@
-import { resolveColor as e, rgbaToHex as t } from "../../renderer/math/color.js";
-import { mat3 as n } from "../../renderer/math/mat3.js";
-import { isValidPatch as r } from "./surface.js";
-import { bakeMesh as i, meshBounds as a } from "./bake.js";
-import { MeshBakeCache as o, meshBakeSize as s } from "./bakeCache.js";
-import { MESH_FRAG_SRC as c, MESH_PROGRAM_ID as l, MESH_VERT_SRC as u } from "./meshShader.js";
-import { oklabToOklch as d, oklabToSrgbU8 as f, oklchToOklab as p, srgbFloatToOklab as m } from "@weasel-js/paint";
-//#region src/features/meshPaint/meshPaint.ts
-var h = "mesh-gradient";
-function g(e) {
-	return e != null && e.fill === h;
-}
-function _(e) {
-	return e;
-}
-function v(e) {
-	return e;
-}
-function y(n, r, i, a) {
-	let [o, s, c, l] = e(n), [u, h, g] = m(o, s, c), [, _, v] = d(u, h, g), [y, b, x] = p(Math.min(1, Math.max(0, u + r)), Math.max(0, _ * i), v + a * Math.PI / 180), [S, C, w] = f(y, b, x);
-	return t([
-		S / 255,
-		C / 255,
-		w / 255,
-		l
-	]);
-}
-function b(e) {
-	let t = [
-		{
-			x: 0,
-			y: 0
-		},
-		{
-			x: 1,
-			y: 0
-		},
-		{
-			x: 1,
-			y: 1
-		},
-		{
-			x: 0,
-			y: 1
-		}
-	], n = [];
-	for (let e = 0; e < 4; e++) {
-		let r = t[e], i = t[(e + 1) % 4], a = (i.y - r.y) * .125, o = -(i.x - r.x) * .125;
-		n.push(r, {
-			x: r.x + (i.x - r.x) / 3 + a,
-			y: r.y + (i.y - r.y) / 3 + o
-		}, {
-			x: r.x + 2 * (i.x - r.x) / 3 + a,
-			y: r.y + 2 * (i.y - r.y) / 3 + o
-		});
-	}
-	return {
-		fill: h,
-		patches: [{
-			points: n,
-			colors: [
-				e,
-				y(e, .14, .85, 0),
-				y(e, -.06, 1.1, 38),
-				y(e, -.16, 1, -22)
-			]
-		}],
-		units: "bounds"
-	};
-}
-function x(e, t, n, r) {
-	let i = [
-		{
-			x: e,
-			y: 0
-		},
-		{
-			x: t,
-			y: 0
-		},
-		{
-			x: t,
-			y: 1
-		},
-		{
-			x: e,
-			y: 1
-		}
-	], a = [];
-	for (let e = 0; e < 4; e++) {
-		let t = i[e], n = i[(e + 1) % 4];
-		a.push(t, {
-			x: t.x + (n.x - t.x) / 3,
-			y: t.y + (n.y - t.y) / 3
-		}, {
-			x: t.x + 2 * (n.x - t.x) / 3,
-			y: t.y + 2 * (n.y - t.y) / 3
-		});
-	}
-	return {
-		points: a,
-		colors: [
-			n,
-			r,
-			r,
-			n
-		]
-	};
-}
-function S(e) {
-	let t = [...e].sort((e, t) => e.offset - t.offset);
-	if (t.length === 1 && t.push({
-		offset: 1,
-		color: t[0].color
-	}), t.length === 0) return b("#000000ff");
-	let n = [];
-	for (let e = 0; e < t.length - 1; e++) {
-		let r = t[e], i = t[e + 1];
-		i.offset > r.offset && n.push(x(r.offset, i.offset, r.color, i.color));
-	}
-	return {
-		fill: h,
-		patches: n,
-		units: "bounds"
-	};
-}
-function C(e) {
-	let t = e.patches.filter(r);
-	if (t.length === 0) return [];
-	let n = t.flatMap((e) => [e.points[0].x, e.points[3].x]), i = Math.min(...n), a = Math.max(...n) - i, o = (e) => a > 0 ? (e - i) / a : 0, s = [];
-	for (let e of t) for (let [t, n] of [[e.points[0], e.colors[0]], [e.points[3], e.colors[1]]]) {
-		let e = o(t.x);
-		s.some((t) => t.offset === e && t.color === n) || s.push({
-			offset: e,
-			color: n
-		});
-	}
-	return s.sort((e, t) => e.offset - t.offset);
-}
-function w(e, t) {
-	return e.patches.map((e) => ({
-		...e,
-		points: e.points.map(t)
-	}));
-}
-var T = /* @__PURE__ */ new WeakMap(), E = /* @__PURE__ */ new WeakMap();
-function D(e) {
-	let t = E.get(e.resources);
-	if (!t) {
-		let n = e.gl, r = new o((e) => n.deleteTexture(e));
-		e.resources.onRelease(() => {
-			r.clear(), E.delete(e.resources);
-		}), E.set(e.resources, r), t = r;
-	}
-	return t;
-}
-function O(e, t, n) {
-	let r = e.spaceToDevice(t.units);
-	return r ? Math.max(n.width * Math.hypot(r[0], r[1]), n.height * Math.hypot(r[3], r[4])) : NaN;
-}
-function k(e, t) {
-	let n = a(t.patches);
-	if (!n) return null;
-	let r = s(O(e, t, n), e.maxTextureSize), o = D(e), c = T.get(t) ?? t, l = o.get(c, r);
-	if (l) return {
-		texture: l,
-		box: n
-	};
-	let u = i(t.patches, t.interpolate ?? "rgb", r);
-	if (!u) return null;
-	let d = e.gl, f = d.createTexture();
-	return f ? (d.bindTexture(d.TEXTURE_2D, f), d.texParameteri(d.TEXTURE_2D, d.TEXTURE_MIN_FILTER, d.LINEAR), d.texParameteri(d.TEXTURE_2D, d.TEXTURE_MAG_FILTER, d.LINEAR), d.texParameteri(d.TEXTURE_2D, d.TEXTURE_WRAP_S, d.CLAMP_TO_EDGE), d.texParameteri(d.TEXTURE_2D, d.TEXTURE_WRAP_T, d.CLAMP_TO_EDGE), d.texImage2D(d.TEXTURE_2D, 0, d.RGBA, u.size, u.size, 0, d.RGBA, d.UNSIGNED_BYTE, u.pixels), d.bindTexture(d.TEXTURE_2D, null), o.set(c, r, f), {
-		texture: f,
-		box: n
-	}) : null;
-}
-function A(e, t) {
-	let i = _(t);
-	if (!i.patches.some(r)) return null;
-	let a = e.spaceInverse(i.units);
-	if (!a) return null;
-	let o = e.program(l);
-	if (!o) return null;
-	let s = k(e, i);
-	if (!s) return null;
-	let c = e.gl;
-	c.useProgram(o.handle), e.setProjAndModel(o), c.uniformMatrix3fv(o.uniform("u_worldInv"), !1, n.toUniform(a)), c.activeTexture(c.TEXTURE0), c.bindTexture(c.TEXTURE_2D, s.texture), c.uniform1i(o.uniform("u_sampler"), 0);
-	let { box: u } = s;
-	return c.uniform2f(o.uniform("u_meshOrigin"), u.x, u.y), c.uniform2f(o.uniform("u_meshSize"), u.width, u.height), c.uniform1f(o.uniform("u_opacity"), i.opacity ?? 1), c.uniform1f(o.uniform("u_alpha"), e.alpha), o;
-}
-var j = {
-	id: h,
-	programs: { [l]: {
-		vert: u,
-		frag: c
-	} },
-	label: "Mesh",
-	icon: "paintMesh",
-	seed: (e) => v(b(e)),
-	colorOf: (e) => _(e).patches?.[0]?.colors?.[0],
-	stopsOf: (e) => C(_(e)),
-	fromStops: (e) => v(S(e)),
-	bind: A,
-	inPoseFrame: (e, t) => {
-		let n = _(e);
-		if (n.units !== "bounds") return e;
-		let r = v({
-			...n,
-			patches: w(n, (e) => ({
-				x: t.x + e.x * t.width,
-				y: t.y + e.y * t.height
-			})),
-			units: "local"
-		});
-		return T.set(r, e), r;
-	},
-	toBoundsFrame: (e, t) => {
-		let n = _(e);
-		return n.units === "bounds" || t.width === 0 || t.height === 0 ? e : v({
-			...n,
-			patches: w(n, (e) => ({
-				x: (e.x - t.x) / t.width,
-				y: (e.y - t.y) / t.height
-			})),
-			units: "bounds"
-		});
-	},
-	toSvg: (e, t) => M(e, _(t))
-};
-function M(e, t) {
-	return `<wzl:meshGradient id="${e}" gradientUnits="${t.units === "bounds" ? "objectBoundingBox" : "userSpaceOnUse"}"${t.interpolate && t.interpolate !== "rgb" ? ` interpolate="${t.interpolate}"` : ""}>${t.patches.map((e) => `<wzl:patch points="${e.points.map((e) => `${N(e.x)},${N(e.y)}`).join(" ")}" colors="${e.colors.join(" ")}"/>`).join("")}</wzl:meshGradient>`;
-}
-function N(e) {
-	return String(Number.isInteger(e) ? e : Number(e.toFixed(4)));
-}
-//#endregion
-export { h as MESH_GRADIENT_KIND, g as isMeshGradientFill, S as meshFromStops, j as meshGradientKind, M as meshGradientXml, C as meshStops, b as seedMeshPatch };
-
-//# sourceMappingURL=meshPaint.js.map

package/dist/features/meshPaint/meshPaint.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"meshPaint.js","names":["MESH_GRADIENT_KIND","isMeshGradientFill","fill","asMesh","asFill","mesh","shifted","r","g","b","a","resolveColor","color","L","A","B","srgbFloatToOklab","C","h","oklabToOklch","nL","nA","nB","oklchToOklab","dL","cScale","dHueDeg","nr","ng","nb","oklabToSrgbU8","rgbaToHex","seedMeshPatch","corners","points","i","nx","ny","bandPatch","x0","x1","left","right","meshFromStops","sorted","stops","patches","meshStops","valid","isValidPatch","xs","p","lo","span","offsetOf","x","patch","point","offset","s","mapPatches","move","BAKE_SOURCE","CACHES","cacheFor","cache","ctx","gl","made","MeshBakeCache","texture","devicePixelsOf","m","box","bakeFor","meshBounds","size","meshBakeSize","key","hit","baked","bakeMesh","bindMesh","inverse","program","MESH_PROGRAM_ID","entry","mat3","meshGradientKind","MESH_VERT_SRC","MESH_FRAG_SRC","paint","posed","meshGradientXml","id","trim","n"],"sources":["../../../src/features/meshPaint/meshPaint.ts"],"sourcesContent":["/**\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, PaintKindEntry, PaintProgram, PaintResources } from '../../core/paintKinds';\nimport { resolveColor, rgbaToHex } from '../../renderer/math/color';\nimport { mat3 } from '../../renderer/math/mat3';\nimport { oklabToOklch, oklabToSrgbU8, oklchToOklab, srgbFloatToOklab } from '@weasel-js/paint';\nimport type { ColorSpace, FillStyle, GradientUnits } from '@weasel-js/paint';\nimport type { FillPoseBox } from '../../core/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 `lazyKind`'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 registry entry, shader program included. `./register` registers\n *  it; core's paint-kind registry loads it on demand otherwise. */\nexport const meshGradientKind: PaintKindEntry = {\n  id: MESH_GRADIENT_KIND,\n  programs: { [MESH_PROGRAM_ID]: { vert: MESH_VERT_SRC, frag: MESH_FRAG_SRC } },\n  label: 'Mesh',\n  icon: 'paintMesh',\n  seed: (color) => asFill(seedMeshPatch(color)),\n  // The first corner of the first patch: a mesh has no single color, and this\n  // is the one a fallback swatch and an SVG paint fallback both read.\n  colorOf: (paint) => asMesh(paint).patches?.[0]?.colors?.[0],\n  stopsOf: (paint) => meshStops(asMesh(paint)),\n  fromStops: (stops) => asFill(meshFromStops(stops)),\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  toSvg: (id, fill) => meshGradientXml(id, asMesh(fill)),\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"],"mappings":"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"}

package/dist/features/meshPaint/meshShader.js

@@ -1,6 +0,0 @@
-//#region src/features/meshPaint/meshShader.ts
-var e = "kit:mesh-gradient", t = "#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 = "#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";
-//#endregion
-export { n as MESH_FRAG_SRC, e as MESH_PROGRAM_ID, t as MESH_VERT_SRC };
-
-//# sourceMappingURL=meshShader.js.map

package/dist/features/meshPaint/meshShader.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"meshShader.js","names":["MESH_PROGRAM_ID","MESH_VERT_SRC","MESH_FRAG_SRC"],"sources":["../../../src/features/meshPaint/meshShader.ts"],"sourcesContent":["/**\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"],"mappings":";AAmBA,IAAaA,IAAkB,qBAElBC,IAA2B,6WAe3BC,IAA2B"}

package/dist/features/meshPaint/register.js

@@ -1,7 +0,0 @@
-import { registerPaintKind as e } from "../../core/paintKinds.js";
-import { meshGradientKind as t } from "./meshPaint.js";
-//#region src/features/meshPaint/register.ts
-e(t);
-//#endregion
-
-//# sourceMappingURL=register.js.map

package/dist/features/meshPaint/register.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"register.js","names":["registerPaintKind","meshGradientKind"],"sources":["../../../src/features/meshPaint/register.ts"],"sourcesContent":["/** Registers the mesh-gradient kind at import; `@weasel-js/core/mesh` imports it for effect. */\nimport { registerPaintKind } from '../../core/paintKinds';\nimport { meshGradientKind } from './meshPaint';\n\nregisterPaintKind(meshGradientKind);\n"],"mappings":";;;AAIAA,EAAkBC,CAAgB"}

package/dist/features/meshPaint/surface.js

@@ -1,110 +0,0 @@
-//#region src/features/meshPaint/surface.ts
-function e(e, t) {
-	return e.points[(t & 3) * 3];
-}
-function t(e) {
-	return e.points.length >= 16;
-}
-function n(e) {
-	return e.points.length === 12 || e.points.length === 16;
-}
-function r(e, t, n, r, i) {
-	let a = 1 - i, o = a * a * a, s = 3 * a * a * i, c = 3 * a * i * i, l = i * i * i;
-	return {
-		x: o * e.x + s * t.x + c * n.x + l * r.x,
-		y: o * e.y + s * t.y + c * n.y + l * r.y
-	};
-}
-function i(e, t) {
-	let n = e.points, r = (t & 3) * 3;
-	return [
-		n[r],
-		n[r + 1],
-		n[r + 2],
-		n[(t + 1 & 3) * 3]
-	];
-}
-function a(e, n, r) {
-	return t(e) ? l(e, n, r) : o(e, n, r);
-}
-function o(t, n, a) {
-	let [o, s, c, l] = i(t, 0), [u, d, f, p] = i(t, 1), [m, h, g, _] = i(t, 2), [v, y, b, x] = i(t, 3), S = r(o, s, c, l, n), C = r(m, h, g, _, 1 - n), w = r(u, d, f, p, a), T = r(v, y, b, x, 1 - a), E = e(t, 0), D = e(t, 1), O = e(t, 2), k = e(t, 3), A = (e, t) => (1 - a) * e + a * t, j = (e, t) => (1 - n) * e + n * t, M = (e, t, r, i) => (1 - n) * (1 - a) * e + n * (1 - a) * t + n * a * r + (1 - n) * a * i;
-	return {
-		x: A(S.x, C.x) + j(T.x, w.x) - M(E.x, D.x, O.x, k.x),
-		y: A(S.y, C.y) + j(T.y, w.y) - M(E.y, D.y, O.y, k.y)
-	};
-}
-function s(e) {
-	let t = e.points;
-	return [
-		[
-			t[0],
-			t[11],
-			t[10],
-			t[9]
-		],
-		[
-			t[1],
-			t[12],
-			t[13],
-			t[8]
-		],
-		[
-			t[2],
-			t[15],
-			t[14],
-			t[7]
-		],
-		[
-			t[3],
-			t[4],
-			t[5],
-			t[6]
-		]
-	];
-}
-var c = (e) => {
-	let t = 1 - e;
-	return [
-		t * t * t,
-		3 * t * t * e,
-		3 * t * e * e,
-		e * e * e
-	];
-};
-function l(e, t, n) {
-	let r = s(e), i = c(t), a = c(n), o = 0, l = 0;
-	for (let e = 0; e < 4; e++) for (let t = 0; t < 4; t++) {
-		let n = i[e] * a[t];
-		o += n * r[e][t].x, l += n * r[e][t].y;
-	}
-	return {
-		x: o,
-		y: l
-	};
-}
-function u(e, t) {
-	return [
-		(1 - e) * (1 - t),
-		e * (1 - t),
-		e * t,
-		(1 - e) * t
-	];
-}
-function d(e, t = 8) {
-	let n = Infinity, r = Infinity, i = -Infinity, o = -Infinity;
-	for (let s = 0; s <= t; s++) for (let c = 0; c <= t; c++) {
-		let l = a(e, s / t, c / t);
-		l.x < n && (n = l.x), l.y < r && (r = l.y), l.x > i && (i = l.x), l.y > o && (o = l.y);
-	}
-	return {
-		x: n,
-		y: r,
-		width: i - n,
-		height: o - r
-	};
-}
-//#endregion
-export { u as cornerWeights, a as evalPatch, t as isTensorPatch, n as isValidPatch, d as patchBounds, e as patchCorner };
-
-//# sourceMappingURL=surface.js.map

package/dist/features/meshPaint/surface.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"surface.js","names":["patchCorner","patch","i","isTensorPatch","isValidPatch","bezier","s","t","a","b","d","p0","p1","p2","p3","edge","p","evalPatch","evalTensor","u","v","evalCoons","b0","b1","b2","b3","r0","r1","r2","r3","t0","t1","t2","t3","l0","l1","l2","l3","bottom","top","right","left","c0","c1","c2","c3","ruledU","ruledV","corner","k0","k1","k2","k3","tensorNet","BERNSTEIN","net","bu","bv","x","y","j","w","cornerWeights","patchBounds","minX","minY","maxX","maxY","steps"],"sources":["../../../src/features/meshPaint/surface.ts"],"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"],"mappings":";AA2CA,SAAgBA,EAAY,GAA2B,GAAsB;CAC3E,OAAOC,EAAM,QAAQC,IAAI,KAAK;AAChC;AAGA,SAAgBC,EAAc,GAAoC;CAChE,OAAOF,EAAM,OAAO,UAAU;AAChC;AAIA,SAAgBG,EAAa,GAAoC;CAC/D,OAAOH,EAAM,OAAO,WAAW,MAAMA,EAAM,OAAO,WAAW;AAC/D;AAEA,SAASI,EAAO,GAAe,GAAe,GAAe,GAAe,GAAsB;CAChG,IAAMC,IAAI,IAAIC,GACRC,IAAIF,IAAIA,IAAIA,GACZG,IAAI,IAAIH,IAAIA,IAAIC,GAChB,IAAI,IAAID,IAAIC,IAAIA,GAChBG,IAAIH,IAAIA,IAAIA;CAClB,OAAO;EACL,GAAGC,IAAIG,EAAG,IAAIF,IAAIG,EAAG,IAAI,IAAIC,EAAG,IAAIH,IAAII,EAAG;EAC3C,GAAGN,IAAIG,EAAG,IAAIF,IAAIG,EAAG,IAAI,IAAIC,EAAG,IAAIH,IAAII,EAAG;CAC7C;AACF;AAGA,SAASC,EAAK,GAA2B,GAAyD;CAChG,IAAMC,IAAIf,EAAM,QACVO,KAAKN,IAAI,KAAK;CACpB,OAAO;EAACc,EAAER;EAAIQ,EAAER,IAAI;EAAIQ,EAAER,IAAI;EAAIQ,GAAId,IAAI,IAAK,KAAK;CAAE;AACxD;AASA,SAAgBe,EAAU,GAA2B,GAAW,GAAsB;CACpF,OAAOd,EAAcF,CAAK,IAAIiB,EAAWjB,GAAOkB,GAAGC,CAAC,IAAIC,EAAUpB,GAAOkB,GAAGC,CAAC;AAC/E;AAEA,SAASC,EAAU,GAA2B,GAAW,GAAsB;CAC7E,IAAM,CAACC,GAAIC,GAAIC,GAAIC,KAAMV,EAAKd,GAAO,CAAC,GAChC,CAACyB,GAAIC,GAAIC,GAAIC,KAAMd,EAAKd,GAAO,CAAC,GAChC,CAAC6B,GAAIC,GAAIC,GAAIC,KAAMlB,EAAKd,GAAO,CAAC,GAChC,CAACiC,GAAIC,GAAIC,GAAIC,KAAMtB,EAAKd,GAAO,CAAC,GAEhCqC,IAASjC,EAAOiB,GAAIC,GAAIC,GAAIC,GAAIN,CAAC,GACjCoB,IAAMlC,EAAOyB,GAAIC,GAAIC,GAAIC,GAAI,IAAId,CAAC,GAClCqB,IAAQnC,EAAOqB,GAAIC,GAAIC,GAAIC,GAAIT,CAAC,GAChCqB,IAAOpC,EAAO6B,GAAIC,GAAIC,GAAIC,GAAI,IAAIjB,CAAC,GAEnCsB,IAAK1C,EAAYC,GAAO,CAAC,GACzB0C,IAAK3C,EAAYC,GAAO,CAAC,GACzB2C,IAAK5C,EAAYC,GAAO,CAAC,GACzB4C,IAAK7C,EAAYC,GAAO,CAAC,GAIzB6C,KAAU,GAAW,OAAuB,IAAI1B,KAAKZ,IAAIY,IAAIX,GAC7DsC,KAAU,GAAW,OAAuB,IAAI5B,KAAKX,IAAIW,IAAIV,GAC7DuC,KAAU,GAAY,GAAY,GAAY,OACjD,IAAI7B,MAAM,IAAIC,KAAK6B,IAAK9B,KAAK,IAAIC,KAAK8B,IAAK/B,IAAIC,IAAI+B,KAAM,IAAIhC,KAAKC,IAAIgC;CAEzE,OAAO;EACL,GAAGN,EAAOR,EAAO,GAAGC,EAAI,CAAC,IAAIQ,EAAON,EAAK,GAAGD,EAAM,CAAC,IAC/CQ,EAAON,EAAG,GAAGC,EAAG,GAAGC,EAAG,GAAGC,EAAG,CAAC;EACjC,GAAGC,EAAOR,EAAO,GAAGC,EAAI,CAAC,IAAIQ,EAAON,EAAK,GAAGD,EAAM,CAAC,IAC/CQ,EAAON,EAAG,GAAGC,EAAG,GAAGC,EAAG,GAAGC,EAAG,CAAC;CACnC;AACF;AAIA,SAASQ,EAAU,GAA0C;CAC3D,IAAMrC,IAAIf,EAAM;CAEhB,OAAO;EACL;GAACe,EAAE;GAAIA,EAAE;GAAKA,EAAE;GAAKA,EAAE;EAAE;EACzB;GAACA,EAAE;GAAIA,EAAE;GAAKA,EAAE;GAAKA,EAAE;EAAE;EACzB;GAACA,EAAE;GAAIA,EAAE;GAAKA,EAAE;GAAKA,EAAE;EAAE;EACzB;GAACA,EAAE;GAAIA,EAAE;GAAIA,EAAE;GAAIA,EAAE;EAAE;CACzB;AACF;AAEA,IAAMsC,KAAa,MAAgD;CACjE,IAAMhD,IAAI,IAAIC;CACd,OAAO;EAACD,IAAIA,IAAIA;EAAG,IAAIA,IAAIA,IAAIC;EAAG,IAAID,IAAIC,IAAIA;EAAGA,IAAIA,IAAIA;CAAC;AAC5D;AAEA,SAASW,EAAW,GAA2B,GAAW,GAAsB;CAC9E,IAAMqC,IAAMF,EAAUpD,CAAK,GACrBuD,IAAKF,EAAUnC,CAAC,GAChBsC,IAAKH,EAAUlC,CAAC,GAClBsC,IAAI,GACJC,IAAI;CACR,KAAK,IAAIzD,IAAI,GAAGA,IAAI,GAAG,KACrB,KAAK,IAAI0D,IAAI,GAAGA,IAAI,GAAG,KAAK;EAC1B,IAAMC,IAAIL,EAAGtD,KAAKuD,EAAGG;EAErB,AADA,KAAKC,IAAIN,EAAIrD,EAAE,CAAC0D,EAAE,CAAC,GACnB,KAAKC,IAAIN,EAAIrD,EAAE,CAAC0D,EAAE,CAAC;CACrB;CAEF,OAAO;EAAE;EAAG;CAAE;AAChB;AAQA,SAAgBE,EAAc,GAAW,GAA6C;CACpF,OAAO;GAAE,IAAI3C,MAAM,IAAIC;EAAID,KAAK,IAAIC;EAAID,IAAIC;GAAI,IAAID,KAAKC;CAAC;AAC5D;AAKA,SAAgB2C,EACd,GAA2B,IAAQ,GACsB;CACzD,IAAIC,IAAO,UACPC,IAAO,UACPC,IAAO,WACPC,IAAO;CACX,KAAK,IAAIjE,IAAI,GAAGA,KAAKkE,GAAO,KAC1B,KAAK,IAAIR,IAAI,GAAGA,KAAKQ,GAAO,KAAK;EAC/B,IAAMpD,IAAIC,EAAUhB,GAAOC,IAAIkE,GAAOR,IAAIQ,CAAK;EAI/C,AAHIpD,EAAE,IAAIgD,MAAM,IAAOhD,EAAE,IACrBA,EAAE,IAAIiD,MAAM,IAAOjD,EAAE,IACrBA,EAAE,IAAIkD,MAAM,IAAOlD,EAAE,IACrBA,EAAE,IAAImD,MAAM,IAAOnD,EAAE;CAC3B;CAEF,OAAO;EAAE,GAAGgD;EAAM,GAAGC;EAAM,OAAOC,IAAOF;EAAM,QAAQG,IAAOF;CAAK;AACrE"}

package/dist/features/minimap/actions.js

@@ -1,53 +0,0 @@
-//#region src/features/minimap/actions.ts
-var e = "minimap.center", t = "minimap.pan";
-function n(e, t, n) {
-	let r = e.hostSize?.();
-	if (!r) return;
-	let i = e.get();
-	e.set({
-		x: t - r.width / (2 * i.scale.x),
-		y: n - r.height / (2 * i.scale.y),
-		scale: i.scale
-	});
-}
-function r(e) {
-	return e.rootView;
-}
-function i() {
-	return {
-		id: e,
-		label: "Minimap — center the view here",
-		requires: ["rootView"],
-		invoker: {
-			timing: "immediate",
-			run: (e, t) => {
-				let i = t, a = r(e);
-				a && i?.worldX !== void 0 && i.worldY !== void 0 && n(a, i.worldX, i.worldY);
-			}
-		}
-	};
-}
-function a() {
-	return {
-		id: t,
-		label: "Minimap — pan the view",
-		requires: ["rootView"],
-		invoker: {
-			timing: "ongoing",
-			start(e) {
-				let t = r(e.deps);
-				return t ? {
-					onMove: (e) => {
-						let r = e.drag?.current ?? e.world;
-						n(t, r.x, r.y);
-					},
-					onEnd: () => {}
-				} : {};
-			}
-		}
-	};
-}
-//#endregion
-export { e as MINIMAP_CENTER, t as MINIMAP_PAN, n as centerRootOn, i as minimapCenterAction, a as minimapPanAction };
-
-//# sourceMappingURL=actions.js.map

package/dist/features/minimap/actions.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"actions.js","names":["MINIMAP_CENTER","MINIMAP_PAN","centerRootOn","size","root","v","x","y","rootOf","deps","minimapCenterAction","p","params","minimapPanAction","ctx","m"],"sources":["../../../src/features/minimap/actions.ts"],"sourcesContent":["/**\n * The minimap's input: press to recenter the main camera on a world point,\n * drag to keep it there. Both read `rootView` — never `view`, which inside the\n * minimap's own view answers the minimap's camera.\n */\nimport type { Action, InvocationCtx, OngoingHandle } from '@weasel-js/routing';\nimport type { ViewApi } from 'interactions/actions/depSchema';\n\n/** Action id for `minimapCenterAction`. */\nexport const MINIMAP_CENTER = 'minimap.center';\n/** Action id for `minimapPanAction`. */\nexport const MINIMAP_PAN = 'minimap.pan';\n\n/** Move `root` so world point (`x`, `y`) sits at the center of its host,\n *  keeping its scale. A no-op while the host is unmeasured. */\nexport function centerRootOn(root: ViewApi, x: number, y: number): void {\n  const size = root.hostSize?.();\n  if (!size) return;\n  const v = root.get();\n  root.set({\n    x: x - size.width / (2 * v.scale.x),\n    y: y - size.height / (2 * v.scale.y),\n    scale: v.scale,\n  });\n}\n\nfunction rootOf(deps: InvocationCtx['deps']): ViewApi | undefined {\n  return deps.rootView;\n}\n\n/** Recenter the main camera on the pressed world point. */\nexport function minimapCenterAction(): Action {\n  return {\n    id: MINIMAP_CENTER,\n    label: 'Minimap — center the view here',\n    requires: ['rootView'],\n    invoker: {\n      timing: 'immediate',\n      run: (deps, params) => {\n        const p = params as { worldX?: number; worldY?: number } | undefined;\n        const root = rootOf(deps);\n        if (!root || p?.worldX === undefined || p.worldY === undefined) return;\n        centerRootOn(root, p.worldX, p.worldY);\n      },\n    },\n  };\n}\n\n/** Keep the main camera centered on the pointer's world point while dragging.\n *  Pair it with `minimap.center` on `pointerDown`, which handles the press.\n *  A recenter lands the moment it is computed, so there is nothing to commit\n *  and a cancel ends where a release does. */\nexport function minimapPanAction(): Action {\n  return {\n    id: MINIMAP_PAN,\n    label: 'Minimap — pan the view',\n    requires: ['rootView'],\n    invoker: {\n      timing: 'ongoing',\n      start(ctx: InvocationCtx): OngoingHandle {\n        const root = rootOf(ctx.deps);\n        if (!root) return {};\n        // The press already centered (`minimap.center`); the move that crossed\n        // the drag threshold is pumped to `onMove` like every later one.\n        return {\n          onMove: (m) => {\n            const p = m.drag?.current ?? m.world;\n            centerRootOn(root, p.x, p.y);\n          },\n          onEnd: () => {},\n        };\n      },\n    },\n  };\n}\n"],"mappings":";AASA,IAAaA,IAAiB,kBAEjBC,IAAc;AAI3B,SAAgBC,EAAa,GAAe,GAAW,GAAiB;CACtE,IAAMC,IAAOC,EAAK,WAAW;CAC7B,IAAI,CAACD,GAAM;CACX,IAAME,IAAID,EAAK,IAAI;CACnB,EAAK,IAAI;EACP,GAAGE,IAAIH,EAAK,SAAS,IAAIE,EAAE,MAAM;EACjC,GAAGE,IAAIJ,EAAK,UAAU,IAAIE,EAAE,MAAM;EAClC,OAAOA,EAAE;CACX,CAAC;AACH;AAEA,SAASG,EAAO,GAAkD;CAChE,OAAOC,EAAK;AACd;AAGA,SAAgBC,IAA8B;CAC5C,OAAO;EACL,IAAIV;EACJ,OAAO;EACP,UAAU,CAAC,UAAU;EACrB,SAAS;GACP,QAAQ;GACR,MAAM,GAAM,MAAW;IACrB,IAAMW,IAAIC,GACJR,IAAOI,EAAOC,CAAI;IACxB,AAAKL,KAAQO,GAAG,WAAW,KAAA,KAAaA,EAAE,WAAW,KAAA,KACrDT,EAAaE,GAAMO,EAAE,QAAQA,EAAE,MAAM;GACvC;EACF;CACF;AACF;AAMA,SAAgBE,IAA2B;CACzC,OAAO;EACL,IAAIZ;EACJ,OAAO;EACP,UAAU,CAAC,UAAU;EACrB,SAAS;GACP,QAAQ;GACR,MAAM,GAAmC;IACvC,IAAMG,IAAOI,EAAOM,EAAI,IAAI;IAI5B,OAHKV,IAGE;KACL,SAAS,MAAM;MACb,IAAMO,IAAII,EAAE,MAAM,WAAWA,EAAE;MAC/B,EAAaX,GAAMO,EAAE,GAAGA,EAAE,CAAC;KAC7B;KACA,aAAa,CAAC;IAChB,IATkB,CAAC;GAUrB;EACF;CACF;AACF"}

package/dist/features/minimap/createMinimapContribution.js

@@ -1,96 +0,0 @@
-import { AUTO_POSE_DESCRIPTOR as e } from "../../interactions/actions/resize/autoPoseDescriptor.js";
-import { MINIMAP_CENTER as t, MINIMAP_PAN as n, minimapCenterAction as r, minimapPanAction as i } from "./actions.js";
-import { FALLBACK_FIT_VIEW as a, computeFitView as o } from "../../canvas/minimapMath.js";
-import { createIndicatorLayer as s, createLinkedCursorLayer as c } from "./layers.js";
-import { FALLBACK_ACCENT as l, accentColorOf as u } from "../../canvas/accentColor.js";
-//#region src/features/minimap/createMinimapContribution.ts
-function d(e, t) {
-	let n = null, r = l, i = (e) => e !== null && t.some((t) => t !== e.viewId);
-	return {
-		layer: c({
-			id: e,
-			pointer: () => n,
-			color: () => r,
-			views: t
-		}),
-		attach: (e, t) => {
-			let a = t.get("pointer");
-			if (!a) return () => {};
-			r = u(e.element), n = a.get();
-			let o = a.subscribe(() => {
-				let t = n;
-				n = a.get(), (i(t) || i(n)) && e.requestRedraw();
-			});
-			return () => {
-				o(), n = null, e.requestRedraw();
-			};
-		}
-	};
-}
-function f(e = {}) {
-	let t = e.id ?? "linked-cursor", n = d(t, e.views ?? [null]);
-	return {
-		id: t,
-		eligibility: { always: !0 },
-		overlay: n.layer,
-		attach: n.attach
-	};
-}
-var p = "#18181c";
-function m(c) {
-	let l = c.id ?? "minimap", u = c.fit ?? "scene", f = null, m = null, h = (t, n) => {
-		let r = f?.get("scene");
-		if (!r) return a;
-		let i = typeof c.rect == "function" ? c.rect(t, n) : c.rect, s = r.getVersion();
-		if (m && m.scene === r && m.version === s && m.w === i.w && m.h === i.h) return m.view;
-		let l = f?.get("poseDescriptor") ?? e, d = o(r, {
-			width: i.w,
-			height: i.h
-		}, u, l);
-		return m = {
-			scene: r,
-			version: s,
-			w: i.w,
-			h: i.h,
-			view: d
-		}, d;
-	}, g = d(`${l}.cursor`, [null, l]), _ = s({
-		viewId: l,
-		root: () => f?.get("rootView"),
-		...c.indicatorStyle ? { style: c.indicatorStyle } : {}
-	});
-	return {
-		id: l,
-		eligibility: { always: !0 },
-		views: [{
-			id: l,
-			bounds: c.rect,
-			view: h,
-			interactive: !0,
-			background: c.background ?? p,
-			...c.layers ? { layers: c.layers } : {}
-		}],
-		actions: [r(), i()],
-		bindings: [{
-			spec: { kind: "pointerDown" },
-			actionId: t,
-			opts: { views: [l] }
-		}, {
-			spec: { kind: "drag" },
-			actionId: n,
-			opts: { views: [l] }
-		}],
-		overlay: [_, g.layer],
-		attach: (e, t) => {
-			f = t;
-			let n = g.attach(e, t);
-			return e.requestRedraw(), () => {
-				n(), f = null, m = null;
-			};
-		}
-	};
-}
-//#endregion
-export { f as createLinkedCursorContribution, m as createMinimapContribution };
-
-//# sourceMappingURL=createMinimapContribution.js.map

package/dist/features/minimap/createMinimapContribution.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createMinimapContribution.js","names":["linkedCursor","pointer","color","FALLBACK_ACCENT","visible","p","ownViews","v","createLinkedCursorLayer","store","deps","accentColorOf","api","off","prev","createLinkedCursorContribution","id","opts","cursor","DEFAULT_BACKGROUND","createMinimapContribution","fit","cached","fitCamera","scene","FALLBACK_FIT_VIEW","r","outer","dims","version","descriptor","AUTO_POSE_DESCRIPTOR","view","computeFitView","indicator","createIndicatorLayer","minimapCenterAction","minimapPanAction","MINIMAP_CENTER","MINIMAP_PAN","reader","detachCursor"],"sources":["../../../src/features/minimap/createMinimapContribution.ts"],"sourcesContent":["/**\n * A minimap over a `<SceneCanvas>`, written as one `SurfaceContribution`: a\n * view through a fit camera, the pan that moves the main camera from inside\n * it, the visible-rect indicator, and a linked crosshair.\n */\nimport type { Dims, RenderLayer } from 'core/layers/render';\nimport type { View } from 'core/viewport/view';\nimport type { Scene } from 'core/scene/types';\nimport type { PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport { AUTO_POSE_DESCRIPTOR } from 'interactions/actions/resize/autoPoseDescriptor';\nimport type { PointerWorldPos } from 'features/pointer/PointerContext';\nimport type { CanvasExtensionApi } from '../../canvas/canvasExtension';\nimport type { ViewRect } from '../../canvas/CanvasView';\nimport type { ContributionDepReader, SurfaceContribution } from '../../canvas/surfaceContribution';\nimport {\n  computeFitView, FALLBACK_FIT_VIEW, type IndicatorStyle, type MinimapFit,\n} from '../../canvas/minimapMath';\nimport {\n  MINIMAP_CENTER, MINIMAP_PAN, minimapCenterAction, minimapPanAction,\n} from './actions';\nimport { createIndicatorLayer, createLinkedCursorLayer } from './layers';\nimport { accentColorOf, FALLBACK_ACCENT } from '../../canvas/accentColor';\n\n\n/**\n * The linked crosshair's live half: follows the pointer store, and asks the\n * surface to repaint whenever the crosshair shows, moves, or has just hidden.\n * `ownViews` are the view ids this surface paints; the crosshair shows in any\n * of them the pointer is not over.\n */\nfunction linkedCursor(id: string, ownViews: readonly (string | null)[]) {\n  let pointer: PointerWorldPos = null;\n  let color = FALLBACK_ACCENT;\n  const visible = (p: PointerWorldPos): boolean =>\n    p !== null && ownViews.some((v) => v !== p.viewId);\n  const layer = createLinkedCursorLayer({ id, pointer: () => pointer, color: () => color, views: ownViews });\n  const attach = (api: CanvasExtensionApi, deps: ContributionDepReader): (() => void) => {\n    const store = deps.get('pointer');\n    if (!store) return () => {};\n    color = accentColorOf(api.element);\n    pointer = store.get();\n    const off = store.subscribe(() => {\n      const prev = pointer;\n      pointer = store.get();\n      if (visible(prev) || visible(pointer)) api.requestRedraw();\n    });\n    return () => {\n      off();\n      pointer = null;\n      api.requestRedraw();\n    };\n  };\n  return { layer, attach };\n}\n\n/** Options for {@link createLinkedCursorContribution}. */\nexport interface LinkedCursorOptions {\n  /** Entry id. Default `'linked-cursor'`. */\n  id?: string;\n  /** Views on this surface the crosshair may paint in. Default `[null]`, the\n   *  surface's own camera — the main canvas beside a detached minimap. */\n  views?: readonly (string | null)[];\n}\n\n/**\n * The linked crosshair alone: this surface paints the pointer's position\n * whenever the pointer is over some other view — another surface under the\n * same `<PointerContextProvider>`, such as a detached `<MinimapCanvas>`.\n *\n * A surface carrying `createMinimapContribution` already has one, in both its\n * views; this is for a surface without.\n */\nexport function createLinkedCursorContribution(opts: LinkedCursorOptions = {}): SurfaceContribution {\n  const id = opts.id ?? 'linked-cursor';\n  const cursor = linkedCursor(id, opts.views ?? [null]);\n  return { id, eligibility: { always: true }, overlay: cursor.layer, attach: cursor.attach };\n}\n\n/** Options for {@link createMinimapContribution}. */\nexport interface MinimapContributionOptions<TData = unknown, TLayer extends string = string, TPose = unknown> {\n  /** View and entry id. Default `'minimap'`. */\n  id?: string;\n  /** Where the minimap paints, in CSS pixels from the canvas top-left. A\n   *  function is re-read every frame, so it can follow the canvas's size. */\n  rect: ViewRect | ((outer: View, dims: Dims) => ViewRect);\n  /** What the minimap frames. Default `'scene'`, the union of leaf poses. */\n  fit?: MinimapFit<TData, TLayer, TPose>;\n  /** The surface layers the minimap paints. Default: all of them. */\n  layers?: (surface: readonly RenderLayer<unknown>[]) => readonly RenderLayer<unknown>[];\n  /** Ground painted before the minimap's layers, so the main canvas does not\n   *  show through. */\n  background?: string;\n  /** The visible-rect indicator's stroke. */\n  indicatorStyle?: IndicatorStyle;\n}\n\nconst DEFAULT_BACKGROUND = '#18181c';\n\n/**\n * A minimap inside a `<SceneCanvas>`, installed with one entry:\n *\n * ```tsx\n * const minimap = useMemo(() => createMinimapContribution({ rect: { x: 8, y: 8, w: 160, h: 110 } }), []);\n * <SceneCanvas ambient={[minimap]} … />\n * ```\n *\n * Press in it to center the main camera on that point, drag to keep it there.\n * It shows the main camera's visible rect, and a crosshair where the pointer is\n * over the other view. Build it once — each instance keeps the live state its\n * layers read.\n */\nexport function createMinimapContribution<TData = unknown, TLayer extends string = string, TPose = unknown>(\n  opts: MinimapContributionOptions<TData, TLayer, TPose>,\n): SurfaceContribution {\n  const id = opts.id ?? 'minimap';\n  const fit = (opts.fit ?? 'scene') as MinimapFit<unknown, string, unknown>;\n  let deps: ContributionDepReader | null = null;\n\n  // The fit follows the scene, so it is recomputed only when the scene's\n  // version or the minimap's size changes — it is read on every frame and\n  // every event.\n  let cached: { scene: unknown; version: number; w: number; h: number; view: View } | null = null;\n  const fitCamera = (outer: View, dims: Dims): View => {\n    const scene = deps?.get('scene') as Scene<unknown, string, unknown> | undefined;\n    if (!scene) return FALLBACK_FIT_VIEW;\n    const r = typeof opts.rect === 'function' ? opts.rect(outer, dims) : opts.rect;\n    const version = scene.getVersion();\n    if (cached && cached.scene === scene && cached.version === version && cached.w === r.w && cached.h === r.h) {\n      return cached.view;\n    }\n    const descriptor = (deps?.get('poseDescriptor') ?? AUTO_POSE_DESCRIPTOR) as PoseDescriptor<unknown>;\n    const view = computeFitView(scene, { width: r.w, height: r.h }, fit, descriptor);\n    cached = { scene, version, w: r.w, h: r.h, view };\n    return view;\n  };\n\n  const cursor = linkedCursor(`${id}.cursor`, [null, id]);\n  const indicator = createIndicatorLayer({\n    viewId: id,\n    root: () => deps?.get('rootView'),\n    ...(opts.indicatorStyle ? { style: opts.indicatorStyle } : {}),\n  });\n\n  return {\n    id,\n    eligibility: { always: true },\n    views: [{\n      id,\n      bounds: opts.rect,\n      view: fitCamera,\n      interactive: true,\n      background: opts.background ?? DEFAULT_BACKGROUND,\n      ...(opts.layers ? { layers: opts.layers } : {}),\n    }],\n    actions: [minimapCenterAction(), minimapPanAction()],\n    bindings: [\n      { spec: { kind: 'pointerDown' }, actionId: MINIMAP_CENTER, opts: { views: [id] } },\n      { spec: { kind: 'drag' }, actionId: MINIMAP_PAN, opts: { views: [id] } },\n    ],\n    overlay: [indicator, cursor.layer],\n    attach: (api, reader) => {\n      deps = reader;\n      const detachCursor = cursor.attach(api, reader);\n      // The fit camera had no scene until now.\n      api.requestRedraw();\n      return () => {\n        detachCursor();\n        deps = null;\n        cached = null;\n      };\n    },\n  };\n}\n"],"mappings":"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"}