@weasel-js/core 1.6.1 → 1.7.1

package/dist/features/ingestion/weaselJsonHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"weaselJsonHandler.js","names":["isMetadataBearingSvg","text","sniffSvgText","extractWeaselClipboardFromSvg","kitWeaselJsonHandler","item","WEASEL_CLIPBOARD_MIME","WEASEL_CLIPBOARD_MIME_WEB","sniffWeaselClipboardText","clipboard","ctx","items","it","nodes","parseWeaselClipboardText","snapshot","result","materializePaste"],"sources":["../../../src/features/ingestion/weaselJsonHandler.ts"],"sourcesContent":["/**\n * The kit's weasel-JSON clipboard content handler.\n *\n * Consumes `application/x-weasel-clipboard+json` payloads (either MIME\n * spelling — Chromium's async-clipboard API round-trips custom formats with\n * a `web ` prefix — plus `text/plain` that sniffs as the wire format, plus\n * `text/plain` SVG carrying the wire format embedded in a `<metadata>`\n * element: Chromium's DOM paste event exposes ONLY `text/plain`, and draw\n * puts metadata-bearing SVG there so draw→draw paste keeps full JSON\n * fidelity) and replays them as a paste through the hosting canvas's\n * adapter: parse →\n * `commitPaste` (fresh ids, cascade offset) → one undoable batch of\n * `InsertOp`s + a selection op. Mirrors `useClipboardOps.paste`'s op\n * construction exactly so OS-arriving pastes and in-memory pastes are\n * indistinguishable in history.\n *\n * Declines (leaving the event un-acted-on) when `ctx.clipboard` is absent\n * (consumer disabled it, or the adapter lacks `commitPaste`) or the payload\n * fails to parse. Note `runIngest` consumes items at *match* time, so\n * \"leave it for other handlers\" is the sniff's job: non-weasel `text/plain`\n * never matches and flows on to lower-priority handlers untouched.\n */\nimport type { NodeId } from 'core/scene/types';\nimport type { ClipboardSnapshot } from 'core/adapters/types';\nimport { materializePaste } from 'interactions/actions/clipboard/materializePaste';\nimport {\n  WEASEL_CLIPBOARD_MIME,\n  WEASEL_CLIPBOARD_MIME_WEB,\n  sniffWeaselClipboardText,\n  parseWeaselClipboardText,\n  extractWeaselClipboardFromSvg,\n} from 'interactions/actions/clipboard/wireFormat';\nimport { dwarn } from '../../debug';\nimport type { ContentHandlerEntry, IngestCtx } from './contentHandlers';\n// Direct module import (not the ./index barrel) to avoid a cycle — the\n// barrel re-exports this handler.\nimport { sniffSvgText } from './svgHandler';\n\n/** text/plain SVG whose `<metadata>` carries a verified weasel payload —\n *  the draw→draw DOM-paste flavor (Chromium exposes only text/plain there).\n *  The `\"weaselClipboard\"` substring guard keeps match cheap on arbitrary\n *  external SVG pastes before the extraction regex runs. */\nconst isMetadataBearingSvg = (text: string): boolean =>\n  text.includes('\"weaselClipboard\"')\n  && sniffSvgText(text)\n  && extractWeaselClipboardFromSvg(text) !== null;\n\nexport const kitWeaselJsonHandler: ContentHandlerEntry = {\n  id: 'kit:weasel-json',\n  // Above the other kit handlers (-100/-90) so weasel payloads never fall\n  // through to the SVG/text paths; still below consumer handlers (default 0).\n  priority: -50,\n  match: (item) =>\n    item.kind === 'string'\n    && (item.mime === WEASEL_CLIPBOARD_MIME\n      || item.mime === WEASEL_CLIPBOARD_MIME_WEB\n      || (item.mime === 'text/plain'\n        && (sniffWeaselClipboardText(item.text) || isMetadataBearingSvg(item.text)))),\n  handle(items, ctx: IngestCtx) {\n    const clipboard = ctx.clipboard;\n    if (!clipboard) {\n      dwarn('clipboard', 'weasel payload arrived but ctx.clipboard is not wired (ingestion.clipboard disabled or absent) — declining');\n      return;\n    }\n    if (!clipboard.adapter.commitPaste) {\n      dwarn('clipboard', 'weasel payload arrived but the clipboard adapter lacks commitPaste — declining');\n      return;\n    }\n    const item = items.find((it) => it.kind === 'string');\n    if (!item || item.kind !== 'string') return;\n    // The metadata-bearing-SVG flavor: unwrap the embedded payload before\n    // parsing. Extraction was already verified at match time, so a null here\n    // is the same inert-decline class as a corrupt custom-MIME payload.\n    const text = sniffSvgText(item.text)\n      ? extractWeaselClipboardFromSvg(item.text)\n      : item.text;\n    if (text === null) {\n      dwarn('clipboard', 'weasel payload vanished from the SVG metadata between match and handle — declining');\n      return;\n    }\n    const nodes = parseWeaselClipboardText(text, clipboard.reviver);\n    if (nodes === null) {\n      dwarn('clipboard', 'weasel payload unusable — declining (see prior warning if the parse threw)');\n      return;\n    }\n    // Shared paste recipe (offset → commitPaste → InsertOps + selection op)\n    // so OS-arriving pastes match useClipboardOps.paste exactly. `ctx.point`\n    // is null for paste, so no dropPoint is threaded — the cascade offset is\n    // the placement.\n    const snapshot: ClipboardSnapshot = { items: nodes };\n    const result = materializePaste(clipboard.adapter, snapshot, {\n      currentSelection: ctx.selection.get(),\n    });\n    if (!result) return;\n    ctx.applyOps(result.ops, 'Paste');\n    ctx.selection.set(result.newIds as NodeId[]);\n    // Flag the shared event ctx so kit:svg's text/plain fallback declines the\n    // SVG flavor of this same copy (draw writes weasel-JSON + SVG together).\n    // WARNING: do not add an `await` earlier in this handle — the flag must\n    // be written before lower-priority handlers' microtasks run.\n    ctx.consumedWeaselPayload = true;\n  },\n};\n"],"mappings":";;;;;AA0CA,IAAMA,KAAwB,MAC5BC,EAAK,SAAS,qBAAmB,KAC9BC,EAAaD,CAAI,KACjBE,EAA8BF,CAAI,MAAM,MAEhCG,IAA4C;CACvD,IAAI;CAGJ,UAAU;CACV,QAAQ,MACNC,EAAK,SAAS,aACVA,EAAK,SAASC,KACbD,EAAK,SAASE,KACbF,EAAK,SAAS,iBACZG,EAAyBH,EAAK,IAAI,KAAKL,EAAqBK,EAAK,IAAI;CAC/E,OAAO,GAAO,GAAgB;EAC5B,IAAMI,IAAYC,EAAI;EACtB,IAAI,CAACD,GAAW;GACd,EAAM,aAAa,4GAA4G;GAC/H;EACF;EACA,IAAI,CAACA,EAAU,QAAQ,aAAa;GAClC,EAAM,aAAa,gFAAgF;GACnG;EACF;EACA,IAAMJ,IAAOM,EAAM,MAAM,MAAOC,EAAG,SAAS,QAAQ;EACpD,IAAI,CAACP,KAAQA,EAAK,SAAS,UAAU;EAIrC,IAAMJ,IAAOC,EAAaG,EAAK,IAAI,IAC/BF,EAA8BE,EAAK,IAAI,IACvCA,EAAK;EACT,IAAIJ,MAAS,MAAM;GACjB,EAAM,aAAa,oFAAoF;GACvG;EACF;EACA,IAAMY,IAAQC,EAAyBb,GAAMQ,EAAU,OAAO;EAC9D,IAAII,MAAU,MAAM;GAClB,EAAM,aAAa,4EAA4E;GAC/F;EACF;EAKA,IAAME,IAA8B,EAAE,OAAOF,EAAM,GAC7CG,IAASC,EAAiBR,EAAU,SAASM,GAAU,EAC3D,kBAAkBL,EAAI,UAAU,IAAI,EACtC,CAAC;EACD,AAAKM,MACLN,EAAI,SAASM,EAAO,KAAK,OAAO,GAChCN,EAAI,UAAU,IAAIM,EAAO,MAAkB,GAK3C,EAAI,wBAAwB;CAC9B;AACF"}

package/dist/features/longPress/longPressFeedback.js

@@ -0,0 +1,96 @@
+import { accentColorOf as e } from "../../canvas/accentColor.js";
+import { ellipsePath as t, polylineFromPoints as n } from "@weasel-js/geom";
+//#region src/features/longPress/longPressFeedback.ts
+var r = "long-press-feedback", i = 64, a = .3, o = () => performance.now();
+function s() {
+	return typeof matchMedia == "function" && matchMedia("(prefers-reduced-motion: reduce)").matches;
+}
+function c(e, t, r, a) {
+	let o = Math.max(1, Math.ceil(i * a)), s = [];
+	for (let n = 0; n <= o; n++) {
+		let i = n / o * a * Math.PI * 2;
+		s.push({
+			x: e + r * Math.sin(i),
+			y: t - r * Math.cos(i)
+		});
+	}
+	return n(s);
+}
+function l(e, n, r) {
+	return t({
+		x: e - r,
+		y: n - r,
+		width: 2 * r,
+		height: 2 * r
+	});
+}
+var u = (e) => e?.viewId ?? null;
+function d(t = {}) {
+	let n = t.id ?? r, i = t.radius ?? 22, d = t.width ?? 3, f = t.delay ?? 120, p, m = "", h = !1, g = () => {
+		let e = p?.get();
+		return !!e && e.armed;
+	};
+	return {
+		id: n,
+		eligibility: { always: !0 },
+		overlay: {
+			id: n,
+			label: "Long-press feedback",
+			space: "screen",
+			draw: (e) => {
+				let t = p?.get();
+				if (!p || !t || !t.armed || u(e) !== null) return [];
+				let n = o();
+				if (n - t.startedAt < f) return [];
+				let { x: r, y: s } = t.local, g = (e) => ({
+					paint: {
+						color: m,
+						...e === void 0 ? {} : { opacity: e }
+					},
+					width: { px: d },
+					cap: "round"
+				});
+				return h ? [{
+					kind: "path",
+					path: l(r, s, i),
+					stroke: g()
+				}] : [{
+					kind: "path",
+					path: l(r, s, i),
+					stroke: g(a)
+				}, {
+					kind: "path",
+					path: c(r, s, i, p.progress(n)),
+					stroke: g()
+				}];
+			}
+		},
+		attach: (n, r) => {
+			let i = r.get("longPress");
+			if (!i) return () => {};
+			p = i;
+			let a, c = () => {
+				clearTimeout(a), a = void 0;
+				let r = i.get();
+				if (r?.armed) {
+					m = typeof t.color == "function" ? t.color() : t.color ?? e(n.element), h = t.reducedMotion === "auto" || t.reducedMotion === void 0 ? s() : t.reducedMotion;
+					let i = f - (o() - r.startedAt);
+					h && i > 0 && (a = setTimeout(() => {
+						n.requestRedraw();
+					}, i));
+				}
+				n.requestRedraw();
+			}, l = i.subscribe(c);
+			return c(), () => {
+				l(), clearTimeout(a), p = void 0, n.requestRedraw();
+			};
+		},
+		afterPaint: (e) => {
+			!h && g() && e.requestFrame();
+		}
+	};
+}
+//#endregion
+export { r as LONG_PRESS_FEEDBACK_ID, d as createLongPressFeedbackContribution };
+
+//# sourceMappingURL=longPressFeedback.js.map

package/dist/features/longPress/longPressFeedback.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"longPressFeedback.js","names":["LONG_PRESS_FEEDBACK_ID","RING_SEGMENTS","TRACK_OPACITY","nowMs","prefersReducedMotion","arcPath","n","t","pts","i","a","cx","cy","polylineFromPoints","circlePath","ellipsePath","viewIdOf","data","createLongPressFeedbackContribution","id","opts","radius","width","delay","state","color","reduced","showing","p","now","stroke","opacity","x","y","store","deps","appear","onChange","accentColorOf","api","wait","offStore","ctx"],"sources":["../../../src/features/longPress/longPressFeedback.ts"],"sourcesContent":["/**\n * The default \"press is registering\" feedback for a touch or pen long-press: a\n * ring around the press point that fills over the hold. It reads the `longPress`\n * dep the gesture dispatcher publishes, so it shows only for a press some\n * binding would fire on, and disappears when the press fires, moves past the\n * drag threshold, lifts, or is canceled.\n */\nimport type { LongPressState } from '@weasel-js/routing';\nimport type { RenderLayer } from 'core/layers/render';\nimport { ellipsePath, polylineFromPoints, type Path } from '@weasel-js/geom';\nimport type { DrawCommand } from '../../renderer';\nimport type { CanvasExtensionApi } from '../../canvas/canvasExtension';\nimport type { ContributionDepReader, SurfaceContribution } from '../../canvas/surfaceContribution';\nimport { accentColorOf } from '../../canvas/accentColor';\n\n/** Entry and layer id of the default feedback, so a host can find or order it. */\nexport const LONG_PRESS_FEEDBACK_ID = 'long-press-feedback';\n\n/** Options for {@link createLongPressFeedbackContribution}. */\nexport interface LongPressFeedbackOptions {\n  /** Entry and layer id. Default {@link LONG_PRESS_FEEDBACK_ID}. */\n  id?: string;\n  /** Ring radius in CSS pixels. Default 22 — clear of a fingertip. */\n  radius?: number;\n  /** Ring stroke width in CSS pixels. Default 3. */\n  width?: number;\n  /** Ring color. Default the theme's `--wzl-accent`, read off the canvas\n   *  element when each press starts. */\n  color?: string | (() => string);\n  /** How long a press is held before the ring appears, in ms, so an ordinary\n   *  tap shows nothing. Default 120. */\n  delay?: number;\n  /** `true` shows a static full ring instead of one that fills, and runs no\n   *  frame loop. Default `'auto'`: follow `prefers-reduced-motion`, read when\n   *  each press starts. */\n  reducedMotion?: boolean | 'auto';\n}\n\nconst RING_SEGMENTS = 64;\nconst TRACK_OPACITY = 0.3;\n\nconst nowMs = (): number => performance.now();\n\nfunction prefersReducedMotion(): boolean {\n  return typeof matchMedia === 'function'\n    && matchMedia('(prefers-reduced-motion: reduce)').matches;\n}\n\n/** An open arc from 12 o'clock, clockwise on a y-down screen, through `t` of a turn. */\nfunction arcPath(cx: number, cy: number, r: number, t: number): Path {\n  const n = Math.max(1, Math.ceil(RING_SEGMENTS * t));\n  const pts: { x: number; y: number }[] = [];\n  for (let i = 0; i <= n; i++) {\n    const a = (i / n) * t * Math.PI * 2;\n    pts.push({ x: cx + r * Math.sin(a), y: cy - r * Math.cos(a) });\n  }\n  return polylineFromPoints(pts);\n}\n\nfunction circlePath(cx: number, cy: number, r: number): Path {\n  return ellipsePath({ x: cx - r, y: cy - r, width: 2 * r, height: 2 * r });\n}\n\nconst viewIdOf = (data: unknown): string | null =>\n  (data as { viewId?: string | null } | null)?.viewId ?? null;\n\n/**\n * The default long-press feedback, as one entry. `<SceneCanvas>` installs it\n * unless `longPress={{ feedback: false }}`; pass a contribution of your own there to\n * replace it — it reads the same `longPress` dep this one does.\n */\nexport function createLongPressFeedbackContribution(\n  opts: LongPressFeedbackOptions = {},\n): SurfaceContribution {\n  const id = opts.id ?? LONG_PRESS_FEEDBACK_ID;\n  const radius = opts.radius ?? 22;\n  const width = opts.width ?? 3;\n  const delay = opts.delay ?? 120;\n\n  let state: LongPressState | undefined;\n  let color = '';\n  let reduced = false;\n\n  const showing = (): boolean => {\n    const p = state?.get();\n    return !!p && p.armed;\n  };\n\n  const layer: RenderLayer<unknown> = {\n    id,\n    label: 'Long-press feedback',\n    space: 'screen',\n    draw: (data): DrawCommand[] => {\n      const p = state?.get();\n      // Screen space is the whole canvas, so the root pass draws the ring\n      // wherever the press routed; a view pass drawing it too would double it.\n      if (!state || !p || !p.armed || viewIdOf(data) !== null) return [];\n      const now = nowMs();\n      if (now - p.startedAt < delay) return [];\n      const { x, y } = p.local;\n      const stroke = (opacity?: number) => ({\n        paint: { color, ...(opacity !== undefined ? { opacity } : {}) },\n        width: { px: width },\n        cap: 'round' as const,\n      });\n      if (reduced) return [{ kind: 'path', path: circlePath(x, y, radius), stroke: stroke() }];\n      return [\n        { kind: 'path', path: circlePath(x, y, radius), stroke: stroke(TRACK_OPACITY) },\n        { kind: 'path', path: arcPath(x, y, radius, state.progress(now)), stroke: stroke() },\n      ];\n    },\n  };\n\n  const attach = (api: CanvasExtensionApi, deps: ContributionDepReader): (() => void) => {\n    const store = deps.get('longPress');\n    if (!store) return () => {};\n    state = store;\n    let appear: ReturnType<typeof setTimeout> | undefined;\n\n    const onChange = (): void => {\n      clearTimeout(appear);\n      appear = undefined;\n      const p = store.get();\n      if (p?.armed) {\n        color = typeof opts.color === 'function' ? opts.color() : (opts.color ?? accentColorOf(api.element));\n        reduced = opts.reducedMotion === 'auto' || opts.reducedMotion === undefined\n          ? prefersReducedMotion()\n          : opts.reducedMotion;\n        // A static ring changes once, when it appears; nothing needs frames.\n        const wait = delay - (nowMs() - p.startedAt);\n        if (reduced && wait > 0) appear = setTimeout(() => { api.requestRedraw(); }, wait);\n      }\n      api.requestRedraw();\n    };\n\n    const offStore = store.subscribe(onChange);\n    onChange();\n    return () => {\n      offStore();\n      clearTimeout(appear);\n      state = undefined;\n      api.requestRedraw();\n    };\n  };\n\n  return {\n    id,\n    eligibility: { always: true },\n    overlay: layer,\n    attach,\n    // The filling ring asks for the next frame from each painted one while it shows.\n    afterPaint: (ctx) => {\n      if (!reduced && showing()) ctx.requestFrame();\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/features/meshPaint/bake.js

@@ -0,0 +1,79 @@
+import { resolveColor as e } from "../../renderer/math/color.js";
+import { evalPatch as t, isValidPatch as n, patchBounds as r } from "./surface.js";
+import { lerpColorArray as i } from "@weasel-js/paint";
+//#region src/features/meshPaint/bake.ts
+var a = 256, o = 10;
+function s(e) {
+	return Math.max(24, Math.ceil(e / o));
+}
+function c(e) {
+	let t = Infinity, i = Infinity, a = -Infinity, o = -Infinity;
+	for (let s of e) {
+		if (!n(s)) continue;
+		let e = r(s);
+		t = Math.min(t, e.x), i = Math.min(i, e.y), a = Math.max(a, e.x + e.width), o = Math.max(o, e.y + e.height);
+	}
+	return !Number.isFinite(t) || a <= t || o <= i ? null : {
+		x: t,
+		y: i,
+		width: a - t,
+		height: o - i
+	};
+}
+function l(e, t, n, r) {
+	let a = i(e[0], e[1], t, r), o = i(e[3], e[2], t, r);
+	return i(a, o, n, r);
+}
+function u(r, i = "rgb", o = a) {
+	let u = c(r);
+	if (!u) return null;
+	let f = new Uint8ClampedArray(o * o * 4), p = s(o), m = (e) => ({
+		x: (e.x - u.x) / u.width * (o - 1) + .5,
+		y: (e.y - u.y) / u.height * (o - 1) + .5
+	});
+	for (let a of r) {
+		if (!n(a)) continue;
+		let r = a.colors.map((t) => e(t));
+		for (let e = 0; e < p; e++) for (let n = 0; n < p; n++) {
+			let s = e / p, c = (e + 1) / p, u = n / p, h = (n + 1) / p, g = [
+				{
+					at: m(t(a, s, u)),
+					color: l(r, s, u, i)
+				},
+				{
+					at: m(t(a, c, u)),
+					color: l(r, c, u, i)
+				},
+				{
+					at: m(t(a, c, h)),
+					color: l(r, c, h, i)
+				},
+				{
+					at: m(t(a, s, h)),
+					color: l(r, s, h, i)
+				}
+			];
+			d(f, o, g[0], g[1], g[2]), d(f, o, g[0], g[2], g[3]);
+		}
+	}
+	return {
+		pixels: f,
+		size: o,
+		box: u
+	};
+}
+function d(e, t, n, r, i) {
+	let a = Math.max(0, Math.floor(Math.min(n.at.x, r.at.x, i.at.x))), o = Math.min(t - 1, Math.ceil(Math.max(n.at.x, r.at.x, i.at.x))), s = Math.max(0, Math.floor(Math.min(n.at.y, r.at.y, i.at.y))), c = Math.min(t - 1, Math.ceil(Math.max(n.at.y, r.at.y, i.at.y)));
+	if (o < a || c < s) return;
+	let l = (r.at.x - n.at.x) * (i.at.y - n.at.y) - (i.at.x - n.at.x) * (r.at.y - n.at.y);
+	if (!(Math.abs(l) < 1e-9)) for (let u = s; u <= c; u++) for (let s = a; s <= o; s++) {
+		let a = s + .5, o = u + .5, c = ((r.at.x - a) * (i.at.y - o) - (i.at.x - a) * (r.at.y - o)) / l, d = ((i.at.x - a) * (n.at.y - o) - (n.at.x - a) * (i.at.y - o)) / l, f = 1 - c - d;
+		if (c < -1e-6 || d < -1e-6 || f < -1e-6) continue;
+		let p = (u * t + s) * 4;
+		for (let t = 0; t < 4; t++) e[p + t] = (c * n.color[t] + d * r.color[t] + f * i.color[t]) * 255;
+	}
+}
+//#endregion
+export { a as MESH_BAKE_SIZE, u as bakeMesh, c as meshBounds };
+
+//# sourceMappingURL=bake.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bake.js","names":["MESH_BAKE_SIZE","TEXELS_PER_CELL","gridFor","size","meshBounds","minX","minY","maxX","maxY","patch","patches","isValidPatch","b","patchBounds","colorAt","bottom","lerpColorArray","corners","u","space","top","v","bakeMesh","box","pixels","grid","toTexel","p","resolveColor","c","i","j","u0","u1","v0","v1","quad","evalPatch","fillTriangle","a","area","y","x","px","py","w0","w1","w2","k","ch"],"sources":["../../../src/features/meshPaint/bake.ts"],"sourcesContent":["/**\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 '../../renderer/math/color';\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"],"mappings":"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"}

package/dist/features/meshPaint/bakeCache.js

@@ -0,0 +1,59 @@
+import { MESH_BAKE_SIZE as e } from "./bake.js";
+//#region src/features/meshPaint/bakeCache.ts
+var t = 32, n = 2048, r = 67108864, i = 256;
+function a(r, i) {
+	let a = Math.min(n, o(i));
+	return Number.isNaN(r) ? Math.min(e, a) : r <= t ? Math.min(t, a) : r >= a ? a : Math.min(a, 2 ** Math.ceil(Math.log2(r)));
+}
+function o(e) {
+	return e >= 1 ? Number.isFinite(e) ? 2 ** Math.floor(Math.log2(e)) : n : t;
+}
+var s = class {
+	free;
+	budgetBytes;
+	maxEntries;
+	byPaint = /* @__PURE__ */ new WeakMap();
+	order = /* @__PURE__ */ new Set();
+	held = 0;
+	constructor(e, t = r, n = i) {
+		this.free = e, this.budgetBytes = t, this.maxEntries = n;
+	}
+	get bytes() {
+		return this.held;
+	}
+	get size() {
+		return this.order.size;
+	}
+	get(e, t) {
+		let n = this.byPaint.get(e)?.get(t);
+		if (n) return this.order.delete(n), this.order.add(n), n.value;
+	}
+	set(e, t, n) {
+		let r = this.byPaint.get(e);
+		r || (r = /* @__PURE__ */ new Map(), this.byPaint.set(e, r));
+		let i = r.get(t);
+		i && this.drop(i);
+		let a = {
+			value: n,
+			size: t,
+			bySize: r
+		};
+		r.set(t, a), this.order.add(a), this.held += t * t * 4, this.evict(a);
+	}
+	clear() {
+		for (let e of [...this.order]) this.drop(e);
+	}
+	evict(e) {
+		for (let t of this.order) {
+			if (this.held <= this.budgetBytes && this.order.size <= this.maxEntries) return;
+			t !== e && this.drop(t);
+		}
+	}
+	drop(e) {
+		this.order.delete(e) && (e.bySize.delete(e.size), this.held -= e.size * e.size * 4, this.free(e.value));
+	}
+};
+//#endregion
+export { r as MESH_BAKE_CACHE_BYTES, i as MESH_BAKE_CACHE_ENTRIES, n as MESH_BAKE_MAX, t as MESH_BAKE_MIN, s as MeshBakeCache, a as meshBakeSize };
+
+//# sourceMappingURL=bakeCache.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bakeCache.js","names":["MESH_BAKE_MIN","MESH_BAKE_MAX","MESH_BAKE_CACHE_BYTES","MESH_BAKE_CACHE_ENTRIES","meshBakeSize","ceiling","floorPow2","maxTextureSize","devicePx","MESH_BAKE_SIZE","n","MeshBakeCache","free","budgetBytes","maxEntries","entry","paint","size","bySize","old","keep"],"sources":["../../../src/features/meshPaint/bakeCache.ts"],"sourcesContent":["/**\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"],"mappings":";;AAcA,IAAaA,IAAgB,IAIhBC,IAAgB,MAIhBC,IAAwB,UAIxBC,IAA0B;AAQvC,SAAgBC,EAAa,GAAkB,GAAgC;CAC7E,IAAMC,IAAU,KAAK,IAAIJ,GAAeK,EAAUC,CAAc,CAAC;CAIjE,OAHI,OAAO,MAAMC,CAAQ,IAAU,KAAK,IAAIC,GAAgBJ,CAAO,IAC/DG,KAAYR,IAAsB,KAAK,IAAIA,GAAeK,CAAO,IACjEG,KAAYH,IAAgBA,IACzB,KAAK,IAAIA,GAAS,KAAK,KAAK,KAAK,KAAK,KAAKG,CAAQ,CAAC,CAAC;AAC9D;AAEA,SAASF,EAAU,GAAmB;CAGpC,OAFMI,KAAK,IACN,OAAO,SAASA,CAAC,IACf,KAAK,KAAK,MAAM,KAAK,KAAKA,CAAC,CAAC,IADHT,IADVD;AAGxB;AAiBA,IAAaW,IAAb,MAA8B;CAOT;CACA;CACA;CARnB,0BAA2B,IAAI,QAAuC;CAEtE,wBAAyB,IAAI,IAAc;CAC3C,OAAe;CAEf,YACE,GACA,IAAuCT,GACvC,IAAsCC,GACtC;EADiB,AAFA,KAAA,OAAAS,GACA,KAAA,cAAAC,GACA,KAAA,aAAAC;CAChB;CAGH,IAAI,QAAgB;EAAE,OAAO,KAAK;CAAM;CAGxC,IAAI,OAAe;EAAE,OAAO,KAAK,MAAM;CAAM;CAE7C,IAAI,GAAe,GAA6B;EAC9C,IAAMC,IAAQ,KAAK,QAAQ,IAAIC,CAAK,CAAC,EAAE,IAAIC,CAAI;EAC/C,IAAKF,GAGL,OAFA,KAAK,MAAM,OAAOA,CAAK,GACvB,KAAK,MAAM,IAAIA,CAAK,GACbA,EAAM;CACf;CAEA,IAAI,GAAe,GAAc,GAAgB;EAC/C,IAAIG,IAAS,KAAK,QAAQ,IAAIF,CAAK;EACnC,AAAKE,MACH,oBAAS,IAAI,IAAI,GACjB,KAAK,QAAQ,IAAIF,GAAOE,CAAM;EAEhC,IAAMC,IAAMD,EAAO,IAAID,CAAI;EAC3B,AAAIE,KAAK,KAAK,KAAKA,CAAG;EACtB,IAAMJ,IAAkB;GAAE;GAAO;GAAM;EAAO;EAI9C,AAHAG,EAAO,IAAID,GAAMF,CAAK,GACtB,KAAK,MAAM,IAAIA,CAAK,GACpB,KAAK,QAAQE,IAAOA,IAAO,GAC3B,KAAK,MAAMF,CAAK;CAClB;CAGA,QAAc;EACZ,KAAK,IAAMA,KAAS,CAAC,GAAG,KAAK,KAAK,GAAG,KAAK,KAAKA,CAAK;CACtD;CAIA,MAAc,GAAsB;EAClC,KAAK,IAAMA,KAAS,KAAK,OAAO;GAC9B,IAAI,KAAK,QAAQ,KAAK,eAAe,KAAK,MAAM,QAAQ,KAAK,YAAY;GACzE,AAAIA,MAAUK,KAAM,KAAK,KAAKL,CAAK;EACrC;CACF;CAEA,KAAa,GAAuB;EAClC,AAAK,KAAK,MAAM,OAAOA,CAAK,MAC5BA,EAAM,OAAO,OAAOA,EAAM,IAAI,GAC9B,KAAK,QAAQA,EAAM,OAAOA,EAAM,OAAO,GACvC,KAAK,KAAKA,EAAM,KAAK;CACvB;AACF"}

package/dist/features/meshPaint/handles.js

@@ -0,0 +1,86 @@
+import { isTensorPatch as e, isValidPatch as t } from "./surface.js";
+//#region src/features/meshPaint/handles.ts
+var n = [
+	12,
+	15,
+	14,
+	13
+];
+function r(e) {
+	return e >= 12 ? "interior" : e % 3 == 0 ? "corner" : "control";
+}
+function i(e, t) {
+	return Math.abs(e - t) <= 1e-9 * Math.max(1, Math.abs(e), Math.abs(t));
+}
+function a(e, t) {
+	return i(e.x, t.x) && i(e.y, t.y);
+}
+function o(e) {
+	let n = [];
+	return e.patches.forEach((e, i) => {
+		t(e) && e.points.forEach((e, t) => {
+			let o = r(t), s = n.find((t) => t.kind === o && a(t.at, e));
+			s ? s.refs.push({
+				patch: i,
+				index: t
+			}) : n.push({
+				id: `${i}:${t}`,
+				kind: o,
+				at: e,
+				refs: [{
+					patch: i,
+					index: t
+				}]
+			});
+		});
+	}), n;
+}
+function s(t, r) {
+	let i = r / 3, a = [r + 1, (r + 11) % 12];
+	return e(t) && a.push(n[i]), a;
+}
+function c(e, t, n) {
+	let r = n.x - t.at.x, i = n.y - t.at.y, a = /* @__PURE__ */ new Map();
+	for (let { patch: e, index: r } of t.refs) a.set(`${e}:${r}`, n);
+	if (t.kind === "corner") for (let { patch: n, index: o } of t.refs) for (let t of s(e.patches[n], o)) {
+		let o = `${n}:${t}`;
+		if (a.has(o)) continue;
+		let s = e.patches[n].points[t];
+		a.set(o, {
+			x: s.x + r,
+			y: s.y + i
+		});
+	}
+	return {
+		...e,
+		patches: e.patches.map((e, t) => ({
+			...e,
+			points: e.points.map((e, n) => a.get(`${t}:${n}`) ?? e)
+		}))
+	};
+}
+function l(e) {
+	let n = [], r = [];
+	for (let i of e.patches) {
+		if (!t(i)) continue;
+		let e = i.points;
+		for (let t = 0; t < 4; t++) {
+			let a = t * 3;
+			n.push([
+				e[a],
+				e[a + 1],
+				e[a + 2],
+				e[(a + 3) % 12]
+			]);
+			for (let t of s(i, a)) r.push([e[a], e[t]]);
+		}
+	}
+	return {
+		edges: n,
+		arms: r
+	};
+}
+//#endregion
+export { l as meshGuides, o as meshHandles, c as moveMeshHandle };
+
+//# sourceMappingURL=handles.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handles.js","names":["INTERIOR_OF_CORNER","kindOf","index","near","a","b","same","meshHandles","handles","mesh","isValidPatch","patch","kind","twin","h","at","p","carriedBy","k","corner","carried","isTensorPatch","moveMeshHandle","dx","to","handle","dy","placed","key","from","i","point","meshGuides","edges","arms"],"sources":["../../../src/features/meshPaint/handles.ts"],"sourcesContent":["/**\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"],"mappings":"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"}