@weasel-js/core 1.9.4 → 1.10.1

package/dist/canvas/nodeShapes/pathPainter.js

@@ -1,36 +1,37 @@
 import { nodeMemo as e } from "../../core/scene/nodeMemo.js";
-import { commandFill as t, commandStroke as n } from "../../features/patterns/commandPaint.js";
-import { DEFAULT_SHAPE_FILL as r } from "../../util/paint.js";
-import { PAINT_SLOT as i } from "./memo.js";
-import { inkReach as a, resolveNodeFill as o, resolveNodeStroke as s, withAnimatedVertexColors as c } from "./nodePaint.js";
-import { paintsPose as l, poseBoxBounds as u } from "./poseBox.js";
-import { pathInPoseFrame as d } from "../../features/paths/pathInWorld.js";
+import { PAINT_SLOT as t } from "./memo.js";
+import { inkReach as n, pathPaintOf as r, resolveNodeStroke as i, withAnimatedVertexColors as a } from "./nodePaint.js";
+import { DERIVED_PAINTER as o } from "./derivedPainter.js";
+import { paintsPose as s, poseBoxBounds as c } from "./poseBox.js";
+import { commandFill as l, commandStroke as u } from "@weasel-js/renderer";
+import { pathInPoseFrame as d } from "@weasel-js/geom";
 //#region src/canvas/nodeShapes/pathPainter.ts
 var f = {
 	id: "kit:path",
-	matches: (e) => l(e.pose) ? e.data?.path != null : !1,
-	paint: (a, l, u) => c(e(a, i, l, () => {
-		let e = a.data, i = d(e.path, l), c = s(e.stroke), u = c !== null, f = o(e.fill, u ? null : r), p = f && t(f, l), m = c && n(c, l);
+	matches: (e) => s(e.pose) ? e.data?.path != null : !1,
+	paint: (n, i, s) => s?.derivedPath == null ? a(e(n, t, i, () => {
+		let e = n.data, t = d(e.path, i), { fill: a, stroke: o } = r(e), s = a && l(a, i), c = o && u(o, i);
 		return [{
 			kind: "path",
-			path: i,
-			...p ? { fill: p } : {},
-			...p && e.vertexColors ? { vertexColors: e.vertexColors } : {},
-			...m ? { stroke: m } : {}
+			path: t,
+			...s ? { fill: s } : {},
+			...s && e.vertexColors ? { vertexColors: e.vertexColors } : {},
+			...c ? { stroke: c } : {}
 		}];
-	}), u),
-	silhouette: (e, t) => {
-		let n = e.data;
-		return d(n.path, t);
+	}), s) : o.paint(n, i, s),
+	silhouette: (e, t, n) => {
+		if (n?.derivedPath != null) return n.derivedPath;
+		let r = e.data;
+		return d(r.path, t);
 	},
-	ink: (e, t, n) => {
-		let i = e.data, c = s(i.stroke), l = c !== null;
+	ink: (e, t, i) => {
+		let a = e.data, { fill: o, stroke: s } = r(a);
 		return {
-			filled: o(i.fill, l ? null : r) !== null,
-			...a(c, n?.scale)
+			filled: o !== null,
+			...n(s ?? null, i?.scale)
 		};
 	},
-	bounds: (e, t, n) => u(t, s(e.data.stroke), n)
+	bounds: (e, t, n) => c(t, i(e.data.stroke), n)
 };
 //#endregion
 export { f as PATH_PAINTER };

package/dist/canvas/nodeShapes/pathPainter.js.map

@@ -1 +1 @@
-{"version":3,"file":"pathPainter.js","names":["PATH_PAINTER","paintsPose","node","withAnimatedVertexColors","nodeMemo","PAINT_SLOT","pose","d","projected","pathInPoseFrame","strokeSpec","resolveNodeStroke","hasStroke","declared","resolveNodeFill","DEFAULT_SHAPE_FILL","fill","commandFill","stroke","commandStroke","ctx","inkReach","poseBoxBounds"],"sources":["../../../src/canvas/nodeShapes/pathPainter.ts"],"sourcesContent":["import type {\n  Path\n} from '@weasel-js/geom';\nimport type { FillStyle, Stroke } from '@weasel-js/paint';\nimport type { NodeShapeEntry } from 'canvas/NodeShape';\nimport { nodeMemo } from 'core/scene/nodeMemo';\nimport type { RectPose } from 'core/scene/types';\nimport { pathInPoseFrame } from 'features/paths/pathInWorld';\nimport { commandFill, commandStroke } from '../../features/patterns/commandPaint';\nimport type { DrawCommand } from '../../renderer';\nimport { DEFAULT_SHAPE_FILL } from '../../util/paint';\nimport { PAINT_SLOT } from './memo';\nimport { inkReach, withAnimatedVertexColors, resolveNodeFill, resolveNodeStroke } from './nodePaint';\nimport { paintsPose, poseBoxBounds } from './poseBox';\n\n// ─── Built-in painters ─────────────────────────────────────────────────\nexport const PATH_PAINTER: NodeShapeEntry<unknown, RectPose> = {\n  id: 'kit:path',\n  matches: (node) => {\n    if (!paintsPose(node.pose)) return false;\n    const d = node.data as { path?: Path } | null;\n    return d?.path != null;\n  },\n  // Memoized: a pure function of `(data, pose)`, and `pathInPoseFrame`\n  // allocates on every call but the identity (`kind: 'rect'`) branch. See\n  // PAINT_SLOT.\n  paint: (node, pose, ctx) => withAnimatedVertexColors(nodeMemo(node, PAINT_SLOT, pose, () => {\n    const d = node.data as {\n      path: Path;\n      fill?: FillStyle | null;\n      stroke?: Stroke | null;\n      vertexColors?: number[];\n    };\n    const projected = pathInPoseFrame(d.path, pose);\n    const strokeSpec = resolveNodeStroke(d.stroke);\n    const hasStroke = strokeSpec !== null;\n    // An undeclared fill falls back to the default one only if there's no\n    // stroke — otherwise the path is stroke-only (e.g. pencil) and a default\n    // fill would be wrong.\n    const declared = resolveNodeFill(d.fill, hasStroke ? null : DEFAULT_SHAPE_FILL);\n    // The pose is baked into `projected` rather than emitted as a transform,\n    // so a box-relative gradient has to be baked onto the same box here or\n    // it would arrive in the renderer referring to a frame that never exists.\n    const fill = declared && commandFill(declared, pose);\n    const stroke = strokeSpec && commandStroke(strokeSpec, pose);\n    const cmd: DrawCommand = {\n      kind: 'path',\n      path: projected,\n      ...(fill ? { fill } : {}),\n      ...(fill && d.vertexColors ? { vertexColors: d.vertexColors } : {}),\n      ...(stroke ? { stroke } : {}),\n    };\n    return [cmd];\n  }), ctx),\n  silhouette: (node, pose) => {\n    const d = node.data as { path: Path };\n    return pathInPoseFrame(d.path, pose);\n  },\n  // Mirrors the fill/stroke decisions `paint` makes above — same reads, same\n  // 'none' handling, same \"no fill declared and a stroke present means\n  // stroke-only\" fallback. Kept in step with `paint` by\n  // `NodeShape.ink.test.ts`, which asserts the two agree.\n  ink: (node, _pose, ctx) => {\n    const d = node.data as {\n      fill?: FillStyle | null;\n      stroke?: Stroke | null;\n    };\n    const stroke = resolveNodeStroke(d.stroke);\n    const hasStroke = stroke !== null;\n    return {\n      filled: resolveNodeFill(d.fill, hasStroke ? null : DEFAULT_SHAPE_FILL) !== null,\n      ...inkReach(stroke, ctx?.scale),\n    };\n  },\n  // `pathInPoseFrame` fits the path's own bounds to the pose box.\n  bounds: (node, pose, ctx) =>\n    poseBoxBounds(pose, resolveNodeStroke((node.data as { stroke?: Stroke | null }).stroke), ctx),\n};\n"],"mappings":";;;;;;;;AAgBA,IAAaA,IAAkD;CAC7D,IAAI;CACJ,UAAU,MACHC,EAAWC,EAAK,IAAI,IACfA,EAAK,MACL,QAAQ,OAFiB;CAOrC,QAAQ,GAAM,GAAM,MAAQC,EAAyBC,EAASF,GAAMG,GAAYC,SAAY;EAC1F,IAAMC,IAAIL,EAAK,MAMTM,IAAYC,EAAgBF,EAAE,MAAMD,CAAI,GACxCI,IAAaC,EAAkBJ,EAAE,MAAM,GACvCK,IAAYF,MAAe,MAI3BG,IAAWC,EAAgBP,EAAE,MAAMK,IAAY,OAAOG,CAAkB,GAIxEC,IAAOH,KAAYI,EAAYJ,GAAUP,CAAI,GAC7CY,IAASR,KAAcS,EAAcT,GAAYJ,CAAI;EAQ3D,OAAO,CAAC;GANN,MAAM;GACN,MAAME;GACN,GAAIQ,IAAO,EAAE,QAAK,IAAI,CAAC;GACvB,GAAIA,KAAQT,EAAE,eAAe,EAAE,cAAcA,EAAE,aAAa,IAAI,CAAC;GACjE,GAAIW,IAAS,EAAE,UAAO,IAAI,CAAC;EAErB,CAAG;CACb,CAAC,GAAGE,CAAG;CACP,aAAa,GAAM,MAAS;EAC1B,IAAMb,IAAIL,EAAK;EACf,OAAOO,EAAgBF,EAAE,MAAMD,CAAI;CACrC;CAKA,MAAM,GAAM,GAAO,MAAQ;EACzB,IAAMC,IAAIL,EAAK,MAITgB,IAASP,EAAkBJ,EAAE,MAAM,GACnCK,IAAYM,MAAW;EAC7B,OAAO;GACL,QAAQJ,EAAgBP,EAAE,MAAMK,IAAY,OAAOG,CAAkB,MAAM;GAC3E,GAAGM,EAASH,GAAQE,GAAK,KAAK;EAChC;CACF;CAEA,SAAS,GAAM,GAAM,MACnBE,EAAchB,GAAMK,EAAmBT,EAAK,KAAoC,MAAM,GAAGkB,CAAG;AAChG"}
+{"version":3,"file":"pathPainter.js","names":["PATH_PAINTER","paintsPose","node","ctx","withAnimatedVertexColors","nodeMemo","PAINT_SLOT","pose","d","projected","pathInPoseFrame","declared","strokeSpec","pathPaintOf","fill","commandFill","stroke","commandStroke","DERIVED_PAINTER","inkReach","poseBoxBounds","resolveNodeStroke"],"sources":["../../../src/canvas/nodeShapes/pathPainter.ts"],"sourcesContent":["import type {\n  Path\n} from '@weasel-js/geom';\nimport type { Stroke, Fill } from '@weasel-js/paint';\nimport type { NodeShapeEntry } from 'canvas/NodeShape';\nimport { nodeMemo } from 'core/scene/nodeMemo';\nimport type { RectPose } from 'core/scene/types';\nimport { pathInPoseFrame } from '@weasel-js/geom';\nimport { commandFill, commandStroke } from '@weasel-js/renderer';\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport { DERIVED_PAINTER } from './derivedPainter';\nimport { PAINT_SLOT } from './memo';\nimport { inkReach, pathPaintOf, withAnimatedVertexColors, resolveNodeStroke } from './nodePaint';\nimport { paintsPose, poseBoxBounds } from './poseBox';\n\n// ─── Built-in painters ─────────────────────────────────────────────────\nexport const PATH_PAINTER: NodeShapeEntry<unknown, RectPose> = {\n  id: 'kit:path',\n  matches: (node) => {\n    if (!paintsPose(node.pose)) return false;\n    const d = node.data as { path?: Path } | null;\n    return d?.path != null;\n  },\n  // Memoized: a pure function of `(data, pose)`, and `pathInPoseFrame`\n  // allocates on every call but the identity (`kind: 'rect'`) branch. See\n  // PAINT_SLOT.\n  paint: (node, pose, ctx) => ctx?.derivedPath != null\n    // A pose override's path stands in for `data.path`, already where it is drawn.\n    ? DERIVED_PAINTER.paint(node, pose, ctx)\n    : withAnimatedVertexColors(nodeMemo(node, PAINT_SLOT, pose, () => {\n    const d = node.data as {\n      path: Path;\n      fill?: Fill | null;\n      stroke?: Stroke | null;\n      vertexColors?: number[];\n    };\n    const projected = pathInPoseFrame(d.path, pose);\n    const { fill: declared, stroke: strokeSpec } = pathPaintOf(d);\n    // The pose is baked into `projected` rather than emitted as a transform,\n    // so a box-relative gradient has to be baked onto the same box here or\n    // it would arrive in the renderer referring to a frame that never exists.\n    const fill = declared && commandFill(declared, pose);\n    const stroke = strokeSpec && commandStroke(strokeSpec, pose);\n    const cmd: DrawCommand = {\n      kind: 'path',\n      path: projected,\n      ...(fill ? { fill } : {}),\n      ...(fill && d.vertexColors ? { vertexColors: d.vertexColors } : {}),\n      ...(stroke ? { stroke } : {}),\n    };\n    return [cmd];\n  }), ctx),\n  silhouette: (node, pose, ctx) => {\n    if (ctx?.derivedPath != null) return ctx.derivedPath;\n    const d = node.data as { path: Path };\n    return pathInPoseFrame(d.path, pose);\n  },\n  ink: (node, _pose, ctx) => {\n    const d = node.data as {\n      fill?: Fill | null;\n      stroke?: Stroke | null;\n    };\n    const { fill, stroke } = pathPaintOf(d);\n    return { filled: fill !== null, ...inkReach(stroke ?? null, ctx?.scale) };\n  },\n  // `pathInPoseFrame` fits the path's own bounds to the pose box.\n  bounds: (node, pose, ctx) =>\n    poseBoxBounds(pose, resolveNodeStroke((node.data as { stroke?: Stroke | null }).stroke), ctx),\n};\n"],"mappings":";;;;;;;;AAgBA,IAAaA,IAAkD;CAC7D,IAAI;CACJ,UAAU,MACHC,EAAWC,EAAK,IAAI,IACfA,EAAK,MACL,QAAQ,OAFiB;CAOrC,QAAQ,GAAM,GAAM,MAAQC,GAAK,eAAe,OAG5CC,EAAyBC,EAASH,GAAMI,GAAYC,SAAY;EAClE,IAAMC,IAAIN,EAAK,MAMTO,IAAYC,EAAgBF,EAAE,MAAMD,CAAI,GACxC,EAAE,MAAMI,GAAU,QAAQC,MAAeC,EAAYL,CAAC,GAItDM,IAAOH,KAAYI,EAAYJ,GAAUJ,CAAI,GAC7CS,IAASJ,KAAcK,EAAcL,GAAYL,CAAI;EAQ3D,OAAO,CAAC;GANN,MAAM;GACN,MAAME;GACN,GAAIK,IAAO,EAAE,QAAK,IAAI,CAAC;GACvB,GAAIA,KAAQN,EAAE,eAAe,EAAE,cAAcA,EAAE,aAAa,IAAI,CAAC;GACjE,GAAIQ,IAAS,EAAE,UAAO,IAAI,CAAC;EAErB,CAAG;CACb,CAAC,GAAGb,CAAG,IAvBHe,EAAgB,MAAMhB,GAAMK,GAAMJ,CAAG;CAwBzC,aAAa,GAAM,GAAM,MAAQ;EAC/B,IAAIA,GAAK,eAAe,MAAM,OAAOA,EAAI;EACzC,IAAMK,IAAIN,EAAK;EACf,OAAOQ,EAAgBF,EAAE,MAAMD,CAAI;CACrC;CACA,MAAM,GAAM,GAAO,MAAQ;EACzB,IAAMC,IAAIN,EAAK,MAIT,EAAE,SAAM,cAAWW,EAAYL,CAAC;EACtC,OAAO;GAAE,QAAQM,MAAS;GAAM,GAAGK,EAASH,KAAU,MAAMb,GAAK,KAAK;EAAE;CAC1E;CAEA,SAAS,GAAM,GAAM,MACnBiB,EAAcb,GAAMc,EAAmBnB,EAAK,KAAoC,MAAM,GAAGC,CAAG;AAChG"}

package/dist/canvas/nodeShapes/poseBox.js

@@ -1,12 +1,12 @@
-import { strokeReachAt as e } from "../../renderer/cullDrawCommands.js";
-import { isRectPose as t } from "../../interactions/actions/resize/autoPoseDescriptor.js";
+import { isRectPose as e } from "../../core/geometry/autoPoseDescriptor.js";
+import { strokeReachAt as t } from "@weasel-js/renderer";
 //#region src/canvas/nodeShapes/poseBox.ts
-function n(e) {
-	return e === void 0 || t(e);
+function n(t) {
+	return t === void 0 || e(t);
 }
 function r(n, r, i) {
-	if (!t(n)) return null;
-	let a = r ? e(r, i?.scale ?? 1, i?.leastScale) : 0, o = Math.min(n.x, n.x + n.width), s = Math.min(n.y, n.y + n.height);
+	if (!e(n)) return null;
+	let a = r ? t(r, i?.scale ?? 1, i?.leastScale) : 0, o = Math.min(n.x, n.x + n.width), s = Math.min(n.y, n.y + n.height);
 	return {
 		x: o - a,
 		y: s - a,

package/dist/canvas/nodeShapes/poseBox.js.map

@@ -1 +1 @@
-{"version":3,"file":"poseBox.js","names":["paintsPose","pose","isRectPose","poseBoxBounds","reach","stroke","strokeReachAt","ctx","x","y"],"sources":["../../../src/canvas/nodeShapes/poseBox.ts"],"sourcesContent":["import type { Stroke } from '@weasel-js/paint';\nimport type { NodeInkCtx } from 'canvas/NodeShape';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { isRectPose } from 'interactions/actions/resize/autoPoseDescriptor';\nimport { strokeReachAt } from '../../renderer/cullDrawCommands';\n\n/** Whether a built-in painter can read this pose. A node that declares none\n *  passes: the pose is then the caller's argument, not the node's. */\nexport function paintsPose(pose: unknown): boolean {\n  return pose === undefined || isRectPose(pose);\n}\n\n/** The pose rect grown by how far `stroke` can paint outside it — the paint\n *  box of every built-in painter whose geometry the pose box contains. */\nexport function poseBoxBounds(pose: unknown, stroke: Stroke | null, ctx: NodeInkCtx | undefined): Bounds | null {\n  if (!isRectPose(pose)) return null;\n  const reach = stroke ? strokeReachAt(stroke, ctx?.scale ?? 1, ctx?.leastScale) : 0;\n  const x = Math.min(pose.x, pose.x + pose.width);\n  const y = Math.min(pose.y, pose.y + pose.height);\n  return {\n    x: x - reach,\n    y: y - reach,\n    width: Math.abs(pose.width) + 2 * reach,\n    height: Math.abs(pose.height) + 2 * reach,\n  };\n}\n"],"mappings":";;;AAQA,SAAgBA,EAAW,GAAwB;CACjD,OAAOC,MAAS,KAAA,KAAaC,EAAWD,CAAI;AAC9C;AAIA,SAAgBE,EAAc,GAAe,GAAuB,GAA4C;CAC9G,IAAI,CAACD,EAAWD,CAAI,GAAG,OAAO;CAC9B,IAAMG,IAAQC,IAASC,EAAcD,GAAQE,GAAK,SAAS,GAAGA,GAAK,UAAU,IAAI,GAC3EC,IAAI,KAAK,IAAIP,EAAK,GAAGA,EAAK,IAAIA,EAAK,KAAK,GACxCQ,IAAI,KAAK,IAAIR,EAAK,GAAGA,EAAK,IAAIA,EAAK,MAAM;CAC/C,OAAO;EACL,GAAGO,IAAIJ;EACP,GAAGK,IAAIL;EACP,OAAO,KAAK,IAAIH,EAAK,KAAK,IAAI,IAAIG;EAClC,QAAQ,KAAK,IAAIH,EAAK,MAAM,IAAI,IAAIG;CACtC;AACF"}
+{"version":3,"file":"poseBox.js","names":["paintsPose","pose","isRectPose","poseBoxBounds","reach","stroke","strokeReachAt","ctx","x","y"],"sources":["../../../src/canvas/nodeShapes/poseBox.ts"],"sourcesContent":["import type { Stroke } from '@weasel-js/paint';\nimport type { NodeInkCtx } from 'canvas/NodeShape';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { isRectPose } from 'core/geometry/autoPoseDescriptor';\nimport { strokeReachAt } from '@weasel-js/renderer';\n\n/** Whether a built-in painter can read this pose. A node that declares none\n *  passes: the pose is then the caller's argument, not the node's. */\nexport function paintsPose(pose: unknown): boolean {\n  return pose === undefined || isRectPose(pose);\n}\n\n/** The pose rect grown by how far `stroke` can paint outside it — the paint\n *  box of every built-in painter whose geometry the pose box contains. */\nexport function poseBoxBounds(pose: unknown, stroke: Stroke | null, ctx: NodeInkCtx | undefined): Bounds | null {\n  if (!isRectPose(pose)) return null;\n  const reach = stroke ? strokeReachAt(stroke, ctx?.scale ?? 1, ctx?.leastScale) : 0;\n  const x = Math.min(pose.x, pose.x + pose.width);\n  const y = Math.min(pose.y, pose.y + pose.height);\n  return {\n    x: x - reach,\n    y: y - reach,\n    width: Math.abs(pose.width) + 2 * reach,\n    height: Math.abs(pose.height) + 2 * reach,\n  };\n}\n"],"mappings":";;;AAQA,SAAgBA,EAAW,GAAwB;CACjD,OAAOC,MAAS,KAAA,KAAaC,EAAWD,CAAI;AAC9C;AAIA,SAAgBE,EAAc,GAAe,GAAuB,GAA4C;CAC9G,IAAI,CAACD,EAAWD,CAAI,GAAG,OAAO;CAC9B,IAAMG,IAAQC,IAASC,EAAcD,GAAQE,GAAK,SAAS,GAAGA,GAAK,UAAU,IAAI,GAC3EC,IAAI,KAAK,IAAIP,EAAK,GAAGA,EAAK,IAAIA,EAAK,KAAK,GACxCQ,IAAI,KAAK,IAAIR,EAAK,GAAGA,EAAK,IAAIA,EAAK,MAAM;CAC/C,OAAO;EACL,GAAGO,IAAIJ;EACP,GAAGK,IAAIL;EACP,OAAO,KAAK,IAAIH,EAAK,KAAK,IAAI,IAAIG;EAClC,QAAQ,KAAK,IAAIH,EAAK,MAAM,IAAI,IAAIG;CACtC;AACF"}

package/dist/canvas/nodeShapes/rectFallbackPainter.js

@@ -1,13 +1,13 @@
-import { commandFill as e } from "../../features/patterns/commandPaint.js";
-import { DEFAULT_SHAPE_FILL as t } from "../../util/paint.js";
-import { resolveNodeFill as n } from "./nodePaint.js";
-import { paintsPose as r, poseBoxBounds as i } from "./poseBox.js";
+import { DEFAULT_SHAPE_FILL as e } from "../../util/paint.js";
+import { resolveNodeFill as t } from "./nodePaint.js";
+import { paintsPose as n, poseBoxBounds as r } from "./poseBox.js";
+import { commandFill as i } from "@weasel-js/renderer";
 //#region src/canvas/nodeShapes/rectFallbackPainter.ts
 var a = {
 	id: "kit:rect-fallback",
-	matches: (e) => r(e.pose),
-	paint: (r, i) => {
-		let a = r.data, o = i, s = n(a?.fill, t), c = s && e(s, o);
+	matches: (e) => n(e.pose),
+	paint: (n, r) => {
+		let a = n.data, o = r, s = t(a?.fill, e), c = s && i(s, o);
 		return [{
 			kind: "path",
 			path: {
@@ -30,7 +30,7 @@ var a = {
 			height: n.height
 		};
 	},
-	bounds: (e, t) => i(t, null, void 0)
+	bounds: (e, t) => r(t, null, void 0)
 };
 //#endregion
 export { a as RECT_FALLBACK_PAINTER };

package/dist/canvas/nodeShapes/rectFallbackPainter.js.map

@@ -1 +1 @@
-{"version":3,"file":"rectFallbackPainter.js","names":["RECT_FALLBACK_PAINTER","paintsPose","node","d","p","pose","declared","resolveNodeFill","DEFAULT_SHAPE_FILL","fill","commandFill","poseBoxBounds"],"sources":["../../../src/canvas/nodeShapes/rectFallbackPainter.ts"],"sourcesContent":["import type { FillStyle } from '@weasel-js/paint';\nimport type { NodeShapeEntry } from 'canvas/NodeShape';\nimport type { RectPose } from 'core/scene/types';\nimport { commandFill } from '../../features/patterns/commandPaint';\nimport { DEFAULT_SHAPE_FILL } from '../../util/paint';\nimport { resolveNodeFill } from './nodePaint';\nimport { paintsPose, poseBoxBounds } from './poseBox';\n\n// ─── Built-in painters ─────────────────────────────────────────────────\nexport const RECT_FALLBACK_PAINTER: NodeShapeEntry<unknown, RectPose> = {\n  // Last-resort painter — matches any rect-posed node, so it must be\n  // registered last within `'normal'`. Consumers who want a different\n  // fallback should register their own painter at `'high'` priority and let\n  // this one never fire (or unregister it explicitly).\n  id: 'kit:rect-fallback',\n  matches: (node) => paintsPose(node.pose),\n  paint: (node, pose) => {\n    const d = node.data as { fill?: FillStyle | null } | null;\n    const p = pose;\n    const declared = resolveNodeFill(d?.fill, DEFAULT_SHAPE_FILL);\n    const fill = declared && commandFill(declared, p);\n    return [{\n      kind: 'path',\n      path: { kind: 'rect', x: p.x, y: p.y, width: p.width, height: p.height },\n      ...(fill ? { fill } : {}),\n    }];\n  },\n  silhouette: (_node, pose) => {\n    const p = pose;\n    return { kind: 'rect', x: p.x, y: p.y, width: p.width, height: p.height };\n  },\n  bounds: (_node, pose) => poseBoxBounds(pose, null, undefined),\n};\n"],"mappings":";;;;;AASA,IAAaA,IAA2D;CAKtE,IAAI;CACJ,UAAU,MAASC,EAAWC,EAAK,IAAI;CACvC,QAAQ,GAAM,MAAS;EACrB,IAAMC,IAAID,EAAK,MACTE,IAAIC,GACJC,IAAWC,EAAgBJ,GAAG,MAAMK,CAAkB,GACtDC,IAAOH,KAAYI,EAAYJ,GAAUF,CAAC;EAChD,OAAO,CAAC;GACN,MAAM;GACN,MAAM;IAAE,MAAM;IAAQ,GAAGA,EAAE;IAAG,GAAGA,EAAE;IAAG,OAAOA,EAAE;IAAO,QAAQA,EAAE;GAAO;GACvE,GAAIK,IAAO,EAAE,QAAK,IAAI,CAAC;EACzB,CAAC;CACH;CACA,aAAa,GAAO,MAAS;EAC3B,IAAML,IAAIC;EACV,OAAO;GAAE,MAAM;GAAQ,GAAGD,EAAE;GAAG,GAAGA,EAAE;GAAG,OAAOA,EAAE;GAAO,QAAQA,EAAE;EAAO;CAC1E;CACA,SAAS,GAAO,MAASO,EAAcN,GAAM,MAAM,KAAA,CAAS;AAC9D"}
+{"version":3,"file":"rectFallbackPainter.js","names":["RECT_FALLBACK_PAINTER","paintsPose","node","d","p","pose","declared","resolveNodeFill","DEFAULT_SHAPE_FILL","fill","commandFill","poseBoxBounds"],"sources":["../../../src/canvas/nodeShapes/rectFallbackPainter.ts"],"sourcesContent":["import type { Fill } from '@weasel-js/paint';\nimport type { NodeShapeEntry } from 'canvas/NodeShape';\nimport type { RectPose } from 'core/scene/types';\nimport { commandFill } from '@weasel-js/renderer';\nimport { DEFAULT_SHAPE_FILL } from '../../util/paint';\nimport { resolveNodeFill } from './nodePaint';\nimport { paintsPose, poseBoxBounds } from './poseBox';\n\n// ─── Built-in painters ─────────────────────────────────────────────────\nexport const RECT_FALLBACK_PAINTER: NodeShapeEntry<unknown, RectPose> = {\n  // Last-resort painter — matches any rect-posed node, so it must be\n  // registered last within `'normal'`. Consumers who want a different\n  // fallback should register their own painter at `'high'` priority and let\n  // this one never fire (or unregister it explicitly).\n  id: 'kit:rect-fallback',\n  matches: (node) => paintsPose(node.pose),\n  paint: (node, pose) => {\n    const d = node.data as { fill?: Fill | null } | null;\n    const p = pose;\n    const declared = resolveNodeFill(d?.fill, DEFAULT_SHAPE_FILL);\n    const fill = declared && commandFill(declared, p);\n    return [{\n      kind: 'path',\n      path: { kind: 'rect', x: p.x, y: p.y, width: p.width, height: p.height },\n      ...(fill ? { fill } : {}),\n    }];\n  },\n  silhouette: (_node, pose) => {\n    const p = pose;\n    return { kind: 'rect', x: p.x, y: p.y, width: p.width, height: p.height };\n  },\n  bounds: (_node, pose) => poseBoxBounds(pose, null, undefined),\n};\n"],"mappings":";;;;;AASA,IAAaA,IAA2D;CAKtE,IAAI;CACJ,UAAU,MAASC,EAAWC,EAAK,IAAI;CACvC,QAAQ,GAAM,MAAS;EACrB,IAAMC,IAAID,EAAK,MACTE,IAAIC,GACJC,IAAWC,EAAgBJ,GAAG,MAAMK,CAAkB,GACtDC,IAAOH,KAAYI,EAAYJ,GAAUF,CAAC;EAChD,OAAO,CAAC;GACN,MAAM;GACN,MAAM;IAAE,MAAM;IAAQ,GAAGA,EAAE;IAAG,GAAGA,EAAE;IAAG,OAAOA,EAAE;IAAO,QAAQA,EAAE;GAAO;GACvE,GAAIK,IAAO,EAAE,QAAK,IAAI,CAAC;EACzB,CAAC;CACH;CACA,aAAa,GAAO,MAAS;EAC3B,IAAML,IAAIC;EACV,OAAO;GAAE,MAAM;GAAQ,GAAGD,EAAE;GAAG,GAAGA,EAAE;GAAG,OAAOA,EAAE;GAAO,QAAQA,EAAE;EAAO;CAC1E;CACA,SAAS,GAAO,MAASO,EAAcN,GAAM,MAAM,KAAA,CAAS;AAC9D"}

package/dist/canvas/nodeShapes/shapePainter.js

@@ -1,39 +1,39 @@
 import { nodeMemo as e } from "../../core/scene/nodeMemo.js";
-import { commandFill as t, commandStroke as n } from "../../features/patterns/commandPaint.js";
-import { DEFAULT_SHAPE_FILL as r } from "../../util/paint.js";
-import { PAINT_SLOT as i } from "./memo.js";
-import { inkReach as a, resolveNodeFill as o, resolveNodeStroke as s, withAnimatedVertexColors as c } from "./nodePaint.js";
-import { paintsPose as l, poseBoxBounds as u } from "./poseBox.js";
+import { DEFAULT_SHAPE_FILL as t } from "../../util/paint.js";
+import { PAINT_SLOT as n } from "./memo.js";
+import { inkReach as r, resolveNodeFill as i, resolveNodeStroke as a, withAnimatedVertexColors as o } from "./nodePaint.js";
+import { paintsPose as s, poseBoxBounds as c } from "./poseBox.js";
+import { commandFill as l, commandStroke as u } from "@weasel-js/renderer";
 import { ellipsePath as d, regularPolygonPath as f, starPath as p } from "@weasel-js/geom";
 //#region src/canvas/nodeShapes/shapePainter.ts
 var m = {
 	id: "kit:shape",
 	matches: (e) => {
-		if (!l(e.pose)) return !1;
+		if (!s(e.pose)) return !1;
 		let t = e.data?.shape;
 		return t != null && h.has(t);
 	},
-	paint: (a, l, u) => c(e(a, i, l, () => {
-		let e = a.data, i = g(e, l), c = o(e.fill, r), u = c && t(c, l), d = s(e.stroke), f = d && n(d, l);
+	paint: (r, s, c) => o(e(r, n, s, () => {
+		let e = r.data, n = g(e, s), o = i(e.fill, t), c = o && l(o, s), d = a(e.stroke), f = d && u(d, s);
 		return [{
 			kind: "path",
-			path: i,
-			...u ? { fill: u } : {},
+			path: n,
+			...c ? { fill: c } : {},
 			...f ? { stroke: f } : {}
 		}];
-	}), u),
+	}), c),
 	silhouette: (e, t) => {
 		let n = e.data;
 		return g(n, t);
 	},
-	ink: (e, t, n) => {
-		let i = e.data;
+	ink: (e, n, o) => {
+		let s = e.data;
 		return {
-			filled: o(i.fill, r) !== null,
-			...a(s(i.stroke), n?.scale)
+			filled: i(s.fill, t) !== null,
+			...r(a(s.stroke), o?.scale)
 		};
 	},
-	bounds: (e, t, n) => u(t, s(e.data.stroke), n)
+	bounds: (e, t, n) => c(t, a(e.data.stroke), n)
 }, h = /* @__PURE__ */ new Set([
 	"rect",
 	"ellipse",

package/dist/canvas/nodeShapes/shapePainter.js.map

@@ -1 +1 @@
-{"version":3,"file":"shapePainter.js","names":["SHAPE_PAINTER","paintsPose","node","s","SHAPE_KINDS","withAnimatedVertexColors","nodeMemo","PAINT_SLOT","pose","d","path","pathForShape","declaredFill","resolveNodeFill","DEFAULT_SHAPE_FILL","shapeFill","commandFill","strokeSpec","resolveNodeStroke","stroke","commandStroke","ctx","inkReach","poseBoxBounds","ellipsePath","p","cx","cy","r","regularPolygonPath","starPath"],"sources":["../../../src/canvas/nodeShapes/shapePainter.ts"],"sourcesContent":["import {\n  ellipsePath,\n  regularPolygonPath,\n  starPath,\n  type Path\n} from '@weasel-js/geom';\nimport type { FillStyle, Stroke } from '@weasel-js/paint';\nimport type { NodeShapeEntry } from 'canvas/NodeShape';\nimport { nodeMemo } from 'core/scene/nodeMemo';\nimport type { RectPose } from 'core/scene/types';\nimport { commandFill, commandStroke } from '../../features/patterns/commandPaint';\nimport { DEFAULT_SHAPE_FILL } from '../../util/paint';\nimport { PAINT_SLOT } from './memo';\nimport { inkReach, withAnimatedVertexColors, resolveNodeFill, resolveNodeStroke } from './nodePaint';\nimport { paintsPose, poseBoxBounds } from './poseBox';\n\n// ─── Built-in painters ─────────────────────────────────────────────────\n/** Built-in shape dispatcher — matches when `data.shape` names a kit-known\n *  shape kind. Computes both paint and silhouette from the pose so consumer\n *  scenes can declare clipping/rendering directly in JSON without\n *  registering a custom painter. */\nexport const SHAPE_PAINTER: NodeShapeEntry<unknown, RectPose> = {\n  id: 'kit:shape',\n  matches: (node) => {\n    if (!paintsPose(node.pose)) return false;\n    const s = (node.data as { shape?: string } | null)?.shape;\n    return s != null && SHAPE_KINDS.has(s);\n  },\n  // Memoized: a pure function of `(data, pose)`, and `pathForShape` builds a\n  // fresh `Uint8Array` + `Float32Array` for every ellipse, polygon and star.\n  // See PAINT_SLOT.\n  paint: (node, pose, ctx) => withAnimatedVertexColors(nodeMemo(node, PAINT_SLOT, pose, () => {\n    const d = node.data as { shape: string; fill?: FillStyle | null; stroke?: Stroke | null; sides?: number; points?: number };\n    const path = pathForShape(d, pose);\n    const declaredFill = resolveNodeFill(d.fill, DEFAULT_SHAPE_FILL);\n    const shapeFill = declaredFill && commandFill(declaredFill, pose);\n    const strokeSpec = resolveNodeStroke(d.stroke);\n    const stroke = strokeSpec && commandStroke(strokeSpec, pose);\n    return [{\n      kind: 'path',\n      path,\n      ...(shapeFill ? { fill: shapeFill } : {}),\n      ...(stroke ? { stroke } : {}),\n    }];\n  }), ctx),\n  silhouette: (node, pose) => {\n    const d = node.data as { shape: string; sides?: number; points?: number };\n    return pathForShape(d, pose);\n  },\n  // `paint` above emits the default fill when none is declared, so a shape\n  // is filled unless it declares `fill: null` — unlike `kit:path`, it has no\n  // implicit stroke-only form.\n  ink: (node, _pose, ctx) => {\n    const d = node.data as { fill?: FillStyle | null; stroke?: Stroke | null };\n    return {\n      filled: resolveNodeFill(d.fill, DEFAULT_SHAPE_FILL) !== null,\n      ...inkReach(resolveNodeStroke(d.stroke), ctx?.scale),\n    };\n  },\n  // Every shape kind is inscribed in the pose box.\n  bounds: (node, pose, ctx) =>\n    poseBoxBounds(pose, resolveNodeStroke((node.data as { stroke?: Stroke | null }).stroke), ctx),\n};\n\nexport const SHAPE_KINDS = new Set(['rect', 'ellipse', 'polygon', 'star']);\n\nexport function pathForShape(\n  d: { shape: string; sides?: number; points?: number },\n  p: RectPose,\n): Path {\n  switch (d.shape) {\n    case 'ellipse':\n      return ellipsePath(p);\n    case 'polygon': {\n      const cx = p.x + p.width / 2;\n      const cy = p.y + p.height / 2;\n      const r = Math.min(p.width, p.height) / 2;\n      return regularPolygonPath({ x: cx, y: cy }, r, d.sides ?? 6);\n    }\n    case 'star': {\n      const cx = p.x + p.width / 2;\n      const cy = p.y + p.height / 2;\n      const r = Math.min(p.width, p.height) / 2;\n      return starPath({ x: cx, y: cy }, r, d.points ?? 5);\n    }\n    case 'rect':\n    default:\n      return { kind: 'rect', x: p.x, y: p.y, width: p.width, height: p.height };\n  }\n}\n"],"mappings":";;;;;;;;AAqBA,IAAaA,IAAmD;CAC9D,IAAI;CACJ,UAAU,MAAS;EACjB,IAAI,CAACC,EAAWC,EAAK,IAAI,GAAG,OAAO;EACnC,IAAMC,IAAKD,EAAK,MAAoC;EACpD,OAAOC,KAAK,QAAQC,EAAY,IAAID,CAAC;CACvC;CAIA,QAAQ,GAAM,GAAM,MAAQE,EAAyBC,EAASJ,GAAMK,GAAYC,SAAY;EAC1F,IAAMC,IAAIP,EAAK,MACTQ,IAAOC,EAAaF,GAAGD,CAAI,GAC3BI,IAAeC,EAAgBJ,EAAE,MAAMK,CAAkB,GACzDC,IAAYH,KAAgBI,EAAYJ,GAAcJ,CAAI,GAC1DS,IAAaC,EAAkBT,EAAE,MAAM,GACvCU,IAASF,KAAcG,EAAcH,GAAYT,CAAI;EAC3D,OAAO,CAAC;GACN,MAAM;GACN;GACA,GAAIO,IAAY,EAAE,MAAMA,EAAU,IAAI,CAAC;GACvC,GAAII,IAAS,EAAE,UAAO,IAAI,CAAC;EAC7B,CAAC;CACH,CAAC,GAAGE,CAAG;CACP,aAAa,GAAM,MAAS;EAC1B,IAAMZ,IAAIP,EAAK;EACf,OAAOS,EAAaF,GAAGD,CAAI;CAC7B;CAIA,MAAM,GAAM,GAAO,MAAQ;EACzB,IAAMC,IAAIP,EAAK;EACf,OAAO;GACL,QAAQW,EAAgBJ,EAAE,MAAMK,CAAkB,MAAM;GACxD,GAAGQ,EAASJ,EAAkBT,EAAE,MAAM,GAAGY,GAAK,KAAK;EACrD;CACF;CAEA,SAAS,GAAM,GAAM,MACnBE,EAAcf,GAAMU,EAAmBhB,EAAK,KAAoC,MAAM,GAAGmB,CAAG;AAChG,GAEajB,oBAAc,IAAI,IAAI;CAAC;CAAQ;CAAW;CAAW;AAAM,CAAC;AAEzE,SAAgBO,EACd,GACA,GACM;CACN,QAAQF,EAAE,OAAV;EACE,KAAK,WACH,OAAOe,EAAYC,CAAC;EACtB,KAAK,WAAW;GACd,IAAMC,IAAKD,EAAE,IAAIA,EAAE,QAAQ,GACrBE,IAAKF,EAAE,IAAIA,EAAE,SAAS,GACtBG,IAAI,KAAK,IAAIH,EAAE,OAAOA,EAAE,MAAM,IAAI;GACxC,OAAOI,EAAmB;IAAE,GAAGH;IAAI,GAAGC;GAAG,GAAGC,GAAGnB,EAAE,SAAS,CAAC;EAC7D;EACA,KAAK,QAAQ;GACX,IAAMiB,IAAKD,EAAE,IAAIA,EAAE,QAAQ,GACrBE,IAAKF,EAAE,IAAIA,EAAE,SAAS,GACtBG,IAAI,KAAK,IAAIH,EAAE,OAAOA,EAAE,MAAM,IAAI;GACxC,OAAOK,EAAS;IAAE,GAAGJ;IAAI,GAAGC;GAAG,GAAGC,GAAGnB,EAAE,UAAU,CAAC;EACpD;EAEA,SACE,OAAO;GAAE,MAAM;GAAQ,GAAGgB,EAAE;GAAG,GAAGA,EAAE;GAAG,OAAOA,EAAE;GAAO,QAAQA,EAAE;EAAO;CAC5E;AACF"}
+{"version":3,"file":"shapePainter.js","names":["SHAPE_PAINTER","paintsPose","node","s","SHAPE_KINDS","withAnimatedVertexColors","nodeMemo","PAINT_SLOT","pose","d","path","pathForShape","declaredFill","resolveNodeFill","DEFAULT_SHAPE_FILL","shapeFill","commandFill","strokeSpec","resolveNodeStroke","stroke","commandStroke","ctx","inkReach","poseBoxBounds","ellipsePath","p","cx","cy","r","regularPolygonPath","starPath"],"sources":["../../../src/canvas/nodeShapes/shapePainter.ts"],"sourcesContent":["import {\n  ellipsePath,\n  regularPolygonPath,\n  starPath,\n  type Path\n} from '@weasel-js/geom';\nimport type { Stroke, Fill } from '@weasel-js/paint';\nimport type { NodeShapeEntry } from 'canvas/NodeShape';\nimport { nodeMemo } from 'core/scene/nodeMemo';\nimport type { RectPose } from 'core/scene/types';\nimport { commandFill, commandStroke } from '@weasel-js/renderer';\nimport { DEFAULT_SHAPE_FILL } from '../../util/paint';\nimport { PAINT_SLOT } from './memo';\nimport { inkReach, withAnimatedVertexColors, resolveNodeFill, resolveNodeStroke } from './nodePaint';\nimport { paintsPose, poseBoxBounds } from './poseBox';\n\n// ─── Built-in painters ─────────────────────────────────────────────────\n/** Built-in shape dispatcher — matches when `data.shape` names a kit-known\n *  shape kind. Computes both paint and silhouette from the pose so consumer\n *  scenes can declare clipping/rendering directly in JSON without\n *  registering a custom painter. */\nexport const SHAPE_PAINTER: NodeShapeEntry<unknown, RectPose> = {\n  id: 'kit:shape',\n  matches: (node) => {\n    if (!paintsPose(node.pose)) return false;\n    const s = (node.data as { shape?: string } | null)?.shape;\n    return s != null && SHAPE_KINDS.has(s);\n  },\n  // Memoized: a pure function of `(data, pose)`, and `pathForShape` builds a\n  // fresh `Uint8Array` + `Float32Array` for every ellipse, polygon and star.\n  // See PAINT_SLOT.\n  paint: (node, pose, ctx) => withAnimatedVertexColors(nodeMemo(node, PAINT_SLOT, pose, () => {\n    const d = node.data as { shape: string; fill?: Fill | null; stroke?: Stroke | null; sides?: number; points?: number };\n    const path = pathForShape(d, pose);\n    const declaredFill = resolveNodeFill(d.fill, DEFAULT_SHAPE_FILL);\n    const shapeFill = declaredFill && commandFill(declaredFill, pose);\n    const strokeSpec = resolveNodeStroke(d.stroke);\n    const stroke = strokeSpec && commandStroke(strokeSpec, pose);\n    return [{\n      kind: 'path',\n      path,\n      ...(shapeFill ? { fill: shapeFill } : {}),\n      ...(stroke ? { stroke } : {}),\n    }];\n  }), ctx),\n  silhouette: (node, pose) => {\n    const d = node.data as { shape: string; sides?: number; points?: number };\n    return pathForShape(d, pose);\n  },\n  // `paint` above emits the default fill when none is declared, so a shape\n  // is filled unless it declares `fill: null` — unlike `kit:path`, it has no\n  // implicit stroke-only form.\n  ink: (node, _pose, ctx) => {\n    const d = node.data as { fill?: Fill | null; stroke?: Stroke | null };\n    return {\n      filled: resolveNodeFill(d.fill, DEFAULT_SHAPE_FILL) !== null,\n      ...inkReach(resolveNodeStroke(d.stroke), ctx?.scale),\n    };\n  },\n  // Every shape kind is inscribed in the pose box.\n  bounds: (node, pose, ctx) =>\n    poseBoxBounds(pose, resolveNodeStroke((node.data as { stroke?: Stroke | null }).stroke), ctx),\n};\n\nexport const SHAPE_KINDS = new Set(['rect', 'ellipse', 'polygon', 'star']);\n\nexport function pathForShape(\n  d: { shape: string; sides?: number; points?: number },\n  p: RectPose,\n): Path {\n  switch (d.shape) {\n    case 'ellipse':\n      return ellipsePath(p);\n    case 'polygon': {\n      const cx = p.x + p.width / 2;\n      const cy = p.y + p.height / 2;\n      const r = Math.min(p.width, p.height) / 2;\n      return regularPolygonPath({ x: cx, y: cy }, r, d.sides ?? 6);\n    }\n    case 'star': {\n      const cx = p.x + p.width / 2;\n      const cy = p.y + p.height / 2;\n      const r = Math.min(p.width, p.height) / 2;\n      return starPath({ x: cx, y: cy }, r, d.points ?? 5);\n    }\n    case 'rect':\n    default:\n      return { kind: 'rect', x: p.x, y: p.y, width: p.width, height: p.height };\n  }\n}\n"],"mappings":";;;;;;;;AAqBA,IAAaA,IAAmD;CAC9D,IAAI;CACJ,UAAU,MAAS;EACjB,IAAI,CAACC,EAAWC,EAAK,IAAI,GAAG,OAAO;EACnC,IAAMC,IAAKD,EAAK,MAAoC;EACpD,OAAOC,KAAK,QAAQC,EAAY,IAAID,CAAC;CACvC;CAIA,QAAQ,GAAM,GAAM,MAAQE,EAAyBC,EAASJ,GAAMK,GAAYC,SAAY;EAC1F,IAAMC,IAAIP,EAAK,MACTQ,IAAOC,EAAaF,GAAGD,CAAI,GAC3BI,IAAeC,EAAgBJ,EAAE,MAAMK,CAAkB,GACzDC,IAAYH,KAAgBI,EAAYJ,GAAcJ,CAAI,GAC1DS,IAAaC,EAAkBT,EAAE,MAAM,GACvCU,IAASF,KAAcG,EAAcH,GAAYT,CAAI;EAC3D,OAAO,CAAC;GACN,MAAM;GACN;GACA,GAAIO,IAAY,EAAE,MAAMA,EAAU,IAAI,CAAC;GACvC,GAAII,IAAS,EAAE,UAAO,IAAI,CAAC;EAC7B,CAAC;CACH,CAAC,GAAGE,CAAG;CACP,aAAa,GAAM,MAAS;EAC1B,IAAMZ,IAAIP,EAAK;EACf,OAAOS,EAAaF,GAAGD,CAAI;CAC7B;CAIA,MAAM,GAAM,GAAO,MAAQ;EACzB,IAAMC,IAAIP,EAAK;EACf,OAAO;GACL,QAAQW,EAAgBJ,EAAE,MAAMK,CAAkB,MAAM;GACxD,GAAGQ,EAASJ,EAAkBT,EAAE,MAAM,GAAGY,GAAK,KAAK;EACrD;CACF;CAEA,SAAS,GAAM,GAAM,MACnBE,EAAcf,GAAMU,EAAmBhB,EAAK,KAAoC,MAAM,GAAGmB,CAAG;AAChG,GAEajB,oBAAc,IAAI,IAAI;CAAC;CAAQ;CAAW;CAAW;AAAM,CAAC;AAEzE,SAAgBO,EACd,GACA,GACM;CACN,QAAQF,EAAE,OAAV;EACE,KAAK,WACH,OAAOe,EAAYC,CAAC;EACtB,KAAK,WAAW;GACd,IAAMC,IAAKD,EAAE,IAAIA,EAAE,QAAQ,GACrBE,IAAKF,EAAE,IAAIA,EAAE,SAAS,GACtBG,IAAI,KAAK,IAAIH,EAAE,OAAOA,EAAE,MAAM,IAAI;GACxC,OAAOI,EAAmB;IAAE,GAAGH;IAAI,GAAGC;GAAG,GAAGC,GAAGnB,EAAE,SAAS,CAAC;EAC7D;EACA,KAAK,QAAQ;GACX,IAAMiB,IAAKD,EAAE,IAAIA,EAAE,QAAQ,GACrBE,IAAKF,EAAE,IAAIA,EAAE,SAAS,GACtBG,IAAI,KAAK,IAAIH,EAAE,OAAOA,EAAE,MAAM,IAAI;GACxC,OAAOK,EAAS;IAAE,GAAGJ;IAAI,GAAGC;GAAG,GAAGC,GAAGnB,EAAE,UAAU,CAAC;EACpD;EAEA,SACE,OAAO;GAAE,MAAM;GAAQ,GAAGgB,EAAE;GAAG,GAAGA,EAAE;GAAG,OAAOA,EAAE;GAAO,QAAQA,EAAE;EAAO;CAC5E;AACF"}

package/dist/canvas/nodeShapes/textPainter.js

@@ -2,7 +2,7 @@ import { nodeMemo as e } from "../../core/scene/nodeMemo.js";
 import { PAINT_SLOT as t } from "./memo.js";
 import { inkReach as n, resolveNodeStroke as r } from "./nodePaint.js";
 import { paintsPose as i } from "./poseBox.js";
-import { textCommandFromPose as a } from "../../features/text/textCommand.js";
+import { textCommandFromPose as a } from "@weasel-js/renderer";
 import { PATH_L as o, PATH_M as s, PATH_Z as c } from "@weasel-js/geom";
 import { textLineBoxes as l } from "@weasel-js/text";
 //#region src/canvas/nodeShapes/textPainter.ts

package/dist/canvas/nodeShapes/textPainter.js.map

@@ -1 +1 @@
-{"version":3,"file":"textPainter.js","names":["textPoseOf","p","d","resolveNodeStroke","TEXT_PAINTER","paintsPose","node","nodeMemo","PAINT_SLOT","pose","textCommandFromPose","boxes","textLineBoxes","rectsToPath","inkReach","ctx","commands","rects","coords","ci","cmd","r","w","h","PATH_M","x","y","PATH_L","PATH_Z"],"sources":["../../../src/canvas/nodeShapes/textPainter.ts"],"sourcesContent":["import {\n  PATH_L,\n  PATH_M,\n  PATH_Z,\n  type PolygonPath\n} from '@weasel-js/geom';\nimport type { FillStyle, Stroke } from '@weasel-js/paint';\nimport type { StyledRun, TextPose, TextStyle, TextVerticalAlign } from '@weasel-js/text';\nimport { textLineBoxes } from '@weasel-js/text';\nimport type { NodeShapeEntry } from 'canvas/NodeShape';\nimport { nodeMemo } from 'core/scene/nodeMemo';\nimport type { RectPose } from 'core/scene/types';\nimport { textCommandFromPose } from 'features/text/textCommand';\nimport { PAINT_SLOT } from './memo';\nimport { inkReach, resolveNodeStroke } from './nodePaint';\nimport { paintsPose } from './poseBox';\n\n// ─── Built-in painters ─────────────────────────────────────────────────\n\n/** The `data` a `kit:text` node carries. */\nexport interface TextNodeData {\n  text: string;\n  style?: TextStyle;\n  runs?: readonly StyledRun[];\n  fill?: FillStyle | null;\n  stroke?: Stroke | null;\n  verticalAlign?: TextVerticalAlign;\n}\n\n/** A `kit:text` node as the `TextPose` every text consumer reads. The stroke\n *  goes through the same resolver every other node kind's does, so one\n *  carrying no paint is dropped here rather than throwing in the renderer. */\nexport function textPoseOf(d: TextNodeData, p: RectPose): TextPose {\n  return {\n    x: p.x, y: p.y, width: p.width, height: p.height,\n    text: d.text,\n    runs: d.runs as StyledRun[] | undefined,\n    style: d.style,\n    fill: d.fill,\n    stroke: resolveNodeStroke(d.stroke) ?? undefined,\n    verticalAlign: d.verticalAlign,\n  };\n}\n\nexport const TEXT_PAINTER: NodeShapeEntry<unknown, RectPose> = {\n  id: 'kit:text',\n  matches: (node) => {\n    if (!paintsPose(node.pose)) return false;\n    const d = node.data as { text?: string } | null;\n    return d?.text != null;\n  },\n  // Memoized, and not for its own sake — `resolveTextStyle` + `resolveRuns`\n  // are cheap (0.14 ms/frame at 1000 text nodes). It is the enabler: the\n  // renderer's layout cache keys on the `ResolvedRun[]` array identity, and\n  // `layoutRuns` costs 25.9 ms/frame for 200 wrapped paragraphs. Handing back\n  // a fresh runs array per frame would leave that cache missing on every\n  // draw, exactly as a fresh `Path` per frame defeated the mesh cache. Both\n  // resolvers are pure style merging — no font reads — so `(data, pose)` is\n  // the whole key. See PAINT_SLOT.\n  //\n  // `y` is the top of the first line box, not a baseline — see\n  // `TextDrawCommand.y`. Wrap, alignment and run resolution are\n  // `textCommandFromPose`'s, which `createTextLayer`, picking, the caret and\n  // the edit overlay all share.\n  paint: (node, pose) => nodeMemo(node, PAINT_SLOT, pose, () => [\n    textCommandFromPose(textPoseOf(node.data as TextNodeData, pose)),\n  ]),\n  // The pose is a layout box, not a bounding box — \"Away\" in a 300-unit box\n  // leaves most of it empty, and a pose-rect silhouette claims all of it. The\n  // union of the line boxes is what the node actually covers, so picking,\n  // lasso and clipping stop grabbing blank space.\n  //\n  // `null` rather than an empty path when there are no non-blank lines: an\n  // empty text node would otherwise become unpickable, and a caller reading\n  // \"no silhouette\" falls back to the pose rect, which is the behavior an\n  // empty box wants.\n  silhouette: (node, pose) => {\n    const boxes = textLineBoxes(textPoseOf(node.data as TextNodeData, pose));\n    if (boxes.length === 0) return null;\n    return rectsToPath(boxes);\n  },\n  // `filled` is unconditional, `data.fill: null` included: the silhouette\n  // above is line boxes, not glyph ink, so reporting outline-only text as\n  // unfilled would leave it grabbable within a stroke width of a box edge and\n  // nowhere near the letters. The reach still matters — a heavily outlined\n  // glyph was unpickable across the width of its own outline.\n  ink: (node, _pose, ctx) => {\n    const d = node.data as { stroke?: Stroke | null };\n    return { filled: true, ...inkReach(resolveNodeStroke(d.stroke), ctx?.scale) };\n  },\n};\n\n/**\n * Union of axis-aligned rects as one multi-contour `PolygonPath`.\n *\n * Every contour winds the same way, so `'nonzero'` reads overlapping rects as\n * covered rather than punching a hole where two lines happen to overlap —\n * which they do the moment `lineHeight` drops below 1.\n */\nexport function rectsToPath(rects: readonly { x: number; y: number; width: number; height: number }[]): PolygonPath {\n  const commands = new Uint8Array(rects.length * 6);\n  const coords = new Float32Array(rects.length * 10);\n  let ci = 0;\n  let cmd = 0;\n  for (const r of rects) {\n    const { x, y, width: w, height: h } = r;\n    commands[cmd++] = PATH_M; coords[ci++] = x; coords[ci++] = y;\n    commands[cmd++] = PATH_L; coords[ci++] = x + w; coords[ci++] = y;\n    commands[cmd++] = PATH_L; coords[ci++] = x + w; coords[ci++] = y + h;\n    commands[cmd++] = PATH_L; coords[ci++] = x; coords[ci++] = y + h;\n    commands[cmd++] = PATH_L; coords[ci++] = x; coords[ci++] = y;\n    commands[cmd++] = PATH_Z;\n  }\n  return { kind: 'polygon', commands, coords, fillRule: 'nonzero' };\n}\n"],"mappings":";;;;;;;;AAgCA,SAAgBA,EAAW,GAAiB,GAAuB;CACjE,OAAO;EACL,GAAGC,EAAE;EAAG,GAAGA,EAAE;EAAG,OAAOA,EAAE;EAAO,QAAQA,EAAE;EAC1C,MAAMC,EAAE;EACR,MAAMA,EAAE;EACR,OAAOA,EAAE;EACT,MAAMA,EAAE;EACR,QAAQC,EAAkBD,EAAE,MAAM,KAAK,KAAA;EACvC,eAAeA,EAAE;CACnB;AACF;AAEA,IAAaE,IAAkD;CAC7D,IAAI;CACJ,UAAU,MACHC,EAAWC,EAAK,IAAI,IACfA,EAAK,MACL,QAAQ,OAFiB;CAiBrC,QAAQ,GAAM,MAASC,EAASD,GAAME,GAAYC,SAAY,CAC5DC,EAAoBV,EAAWM,EAAK,MAAsBG,CAAI,CAAC,CACjE,CAAC;CAUD,aAAa,GAAM,MAAS;EAC1B,IAAME,IAAQC,EAAcZ,EAAWM,EAAK,MAAsBG,CAAI,CAAC;EAEvE,OADIE,EAAM,WAAW,IAAU,OACxBE,EAAYF,CAAK;CAC1B;CAMA,MAAM,GAAM,GAAO,MAAQ;EACzB,IAAMT,IAAII,EAAK;EACf,OAAO;GAAE,QAAQ;GAAM,GAAGQ,EAASX,EAAkBD,EAAE,MAAM,GAAGa,GAAK,KAAK;EAAE;CAC9E;AACF;AASA,SAAgBF,EAAY,GAAwF;CAClH,IAAMG,IAAW,IAAI,WAAWC,EAAM,SAAS,CAAC,GAC1CC,IAAS,IAAI,aAAaD,EAAM,SAAS,EAAE,GAC7CE,IAAK,GACLC,IAAM;CACV,KAAK,IAAMC,KAAKJ,GAAO;EACrB,IAAM,EAAE,MAAG,MAAG,OAAOK,GAAG,QAAQC,MAAMF;EAMtC,AALA,EAAS,OAASG,GAAQ,EAAO,OAAQC,GAAG,EAAO,OAAQC,GAC3D,EAAS,OAASC,GAAQ,EAAO,OAAQF,IAAIH,GAAG,EAAO,OAAQI,GAC/D,EAAS,OAASC,GAAQ,EAAO,OAAQF,IAAIH,GAAG,EAAO,OAAQI,IAAIH,GACnE,EAAS,OAASI,GAAQ,EAAO,OAAQF,GAAG,EAAO,OAAQC,IAAIH,GAC/D,EAAS,OAASI,GAAQ,EAAO,OAAQF,GAAG,EAAO,OAAQC,GAC3D,EAAS,OAASE;CACpB;CACA,OAAO;EAAE,MAAM;EAAW;EAAU;EAAQ,UAAU;CAAU;AAClE"}
+{"version":3,"file":"textPainter.js","names":["textPoseOf","p","d","resolveNodeStroke","TEXT_PAINTER","paintsPose","node","nodeMemo","PAINT_SLOT","pose","textCommandFromPose","boxes","textLineBoxes","rectsToPath","inkReach","ctx","commands","rects","coords","ci","cmd","r","w","h","PATH_M","x","y","PATH_L","PATH_Z"],"sources":["../../../src/canvas/nodeShapes/textPainter.ts"],"sourcesContent":["import {\n  PATH_L,\n  PATH_M,\n  PATH_Z,\n  type PolygonPath\n} from '@weasel-js/geom';\nimport type { Stroke, Fill } from '@weasel-js/paint';\nimport type { StyledRun, TextPose, TextStyle, TextVerticalAlign } from '@weasel-js/text';\nimport { textLineBoxes } from '@weasel-js/text';\nimport type { NodeShapeEntry } from 'canvas/NodeShape';\nimport { nodeMemo } from 'core/scene/nodeMemo';\nimport type { RectPose } from 'core/scene/types';\nimport { textCommandFromPose } from '@weasel-js/renderer';\nimport { PAINT_SLOT } from './memo';\nimport { inkReach, resolveNodeStroke } from './nodePaint';\nimport { paintsPose } from './poseBox';\n\n/** The `data` a `kit:text` node carries. */\nexport interface TextNodeData {\n  text: string;\n  style?: TextStyle;\n  runs?: readonly StyledRun[];\n  fill?: Fill | null;\n  stroke?: Stroke | null;\n  verticalAlign?: TextVerticalAlign;\n}\n\n/** A `kit:text` node as the `TextPose` every text consumer reads. The stroke\n *  goes through the same resolver every other node kind's does, so one\n *  carrying no paint is dropped here rather than throwing in the renderer. */\nexport function textPoseOf(d: TextNodeData, p: RectPose): TextPose {\n  return {\n    x: p.x, y: p.y, width: p.width, height: p.height,\n    text: d.text,\n    runs: d.runs as StyledRun[] | undefined,\n    style: d.style,\n    fill: d.fill,\n    stroke: resolveNodeStroke(d.stroke) ?? undefined,\n    verticalAlign: d.verticalAlign,\n  };\n}\n\nexport const TEXT_PAINTER: NodeShapeEntry<unknown, RectPose> = {\n  id: 'kit:text',\n  matches: (node) => {\n    if (!paintsPose(node.pose)) return false;\n    const d = node.data as { text?: string } | null;\n    return d?.text != null;\n  },\n  // Memoized because the renderer's layout cache keys on the `ResolvedRun[]` array\n  // identity: a fresh runs array per frame would leave that cache missing on every\n  // draw. Both resolvers are pure style merging — no font reads — so `(data, pose)` is\n  // the whole key. See PAINT_SLOT.\n  //\n  // `y` is the top of the first line box, not a baseline — see `TextDrawCommand.y`.\n  paint: (node, pose) => nodeMemo(node, PAINT_SLOT, pose, () => [\n    textCommandFromPose(textPoseOf(node.data as TextNodeData, pose)),\n  ]),\n  // The pose is a layout box, not a bounding box: the union of the line boxes is what\n  // the node actually covers, so picking, lasso, and clipping stop grabbing blank space.\n  //\n  // `null` rather than an empty path when there are no non-blank lines: a caller\n  // reading \"no silhouette\" falls back to the pose rect, which keeps an empty text\n  // node pickable.\n  silhouette: (node, pose) => {\n    const boxes = textLineBoxes(textPoseOf(node.data as TextNodeData, pose));\n    if (boxes.length === 0) return null;\n    return rectsToPath(boxes);\n  },\n  // `filled` is unconditional, `data.fill: null` included: the silhouette above is line\n  // boxes, not glyph ink, so reporting outline-only text as unfilled would leave it\n  // grabbable within a stroke width of a box edge and nowhere near the letters.\n  ink: (node, _pose, ctx) => {\n    const d = node.data as { stroke?: Stroke | null };\n    return { filled: true, ...inkReach(resolveNodeStroke(d.stroke), ctx?.scale) };\n  },\n};\n\n/**\n * Union of axis-aligned rects as one multi-contour `PolygonPath`.\n *\n * Every contour winds the same way, so `'nonzero'` reads overlapping rects as\n * covered rather than punching a hole where two lines happen to overlap —\n * which they do the moment `lineHeight` drops below 1.\n */\nexport function rectsToPath(rects: readonly { x: number; y: number; width: number; height: number }[]): PolygonPath {\n  const commands = new Uint8Array(rects.length * 6);\n  const coords = new Float32Array(rects.length * 10);\n  let ci = 0;\n  let cmd = 0;\n  for (const r of rects) {\n    const { x, y, width: w, height: h } = r;\n    commands[cmd++] = PATH_M; coords[ci++] = x; coords[ci++] = y;\n    commands[cmd++] = PATH_L; coords[ci++] = x + w; coords[ci++] = y;\n    commands[cmd++] = PATH_L; coords[ci++] = x + w; coords[ci++] = y + h;\n    commands[cmd++] = PATH_L; coords[ci++] = x; coords[ci++] = y + h;\n    commands[cmd++] = PATH_L; coords[ci++] = x; coords[ci++] = y;\n    commands[cmd++] = PATH_Z;\n  }\n  return { kind: 'polygon', commands, coords, fillRule: 'nonzero' };\n}\n"],"mappings":";;;;;;;;AA8BA,SAAgBA,EAAW,GAAiB,GAAuB;CACjE,OAAO;EACL,GAAGC,EAAE;EAAG,GAAGA,EAAE;EAAG,OAAOA,EAAE;EAAO,QAAQA,EAAE;EAC1C,MAAMC,EAAE;EACR,MAAMA,EAAE;EACR,OAAOA,EAAE;EACT,MAAMA,EAAE;EACR,QAAQC,EAAkBD,EAAE,MAAM,KAAK,KAAA;EACvC,eAAeA,EAAE;CACnB;AACF;AAEA,IAAaE,IAAkD;CAC7D,IAAI;CACJ,UAAU,MACHC,EAAWC,EAAK,IAAI,IACfA,EAAK,MACL,QAAQ,OAFiB;CAUrC,QAAQ,GAAM,MAASC,EAASD,GAAME,GAAYC,SAAY,CAC5DC,EAAoBV,EAAWM,EAAK,MAAsBG,CAAI,CAAC,CACjE,CAAC;CAOD,aAAa,GAAM,MAAS;EAC1B,IAAME,IAAQC,EAAcZ,EAAWM,EAAK,MAAsBG,CAAI,CAAC;EAEvE,OADIE,EAAM,WAAW,IAAU,OACxBE,EAAYF,CAAK;CAC1B;CAIA,MAAM,GAAM,GAAO,MAAQ;EACzB,IAAMT,IAAII,EAAK;EACf,OAAO;GAAE,QAAQ;GAAM,GAAGQ,EAASX,EAAkBD,EAAE,MAAM,GAAGa,GAAK,KAAK;EAAE;CAC9E;AACF;AASA,SAAgBF,EAAY,GAAwF;CAClH,IAAMG,IAAW,IAAI,WAAWC,EAAM,SAAS,CAAC,GAC1CC,IAAS,IAAI,aAAaD,EAAM,SAAS,EAAE,GAC7CE,IAAK,GACLC,IAAM;CACV,KAAK,IAAMC,KAAKJ,GAAO;EACrB,IAAM,EAAE,MAAG,MAAG,OAAOK,GAAG,QAAQC,MAAMF;EAMtC,AALA,EAAS,OAASG,GAAQ,EAAO,OAAQC,GAAG,EAAO,OAAQC,GAC3D,EAAS,OAASC,GAAQ,EAAO,OAAQF,IAAIH,GAAG,EAAO,OAAQI,GAC/D,EAAS,OAASC,GAAQ,EAAO,OAAQF,IAAIH,GAAG,EAAO,OAAQI,IAAIH,GACnE,EAAS,OAASI,GAAQ,EAAO,OAAQF,GAAG,EAAO,OAAQC,IAAIH,GAC/D,EAAS,OAASI,GAAQ,EAAO,OAAQF,GAAG,EAAO,OAAQC,GAC3D,EAAS,OAASE;CACpB;CACA,OAAO;EAAE,MAAM;EAAW;EAAU;EAAQ,UAAU;CAAU;AAClE"}

package/dist/canvas/overChildren.js

@@ -0,0 +1,29 @@
+//#region src/canvas/overChildren.ts
+var e = /* @__PURE__ */ new WeakSet();
+function t(t) {
+	let n = {
+		kind: "group",
+		children: t
+	};
+	return e.add(n), n;
+}
+function n(t) {
+	return e.has(t);
+}
+var r = [];
+function i(e) {
+	if (!e.some(n)) return {
+		under: e,
+		over: r
+	};
+	let t = [], i = [];
+	for (let r of e) n(r) ? i.push(...r.children) : t.push(r);
+	return {
+		under: t,
+		over: i
+	};
+}
+//#endregion
+export { n as isOverChildren, t as overChildren, i as splitOverChildren };
+
+//# sourceMappingURL=overChildren.js.map

package/dist/canvas/overChildren.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"overChildren.js","names":["OVER","overChildren","group","cmds","isOverChildren","cmd","NOTHING","splitOverChildren","under","over"],"sources":["../../src/canvas/overChildren.ts"],"sourcesContent":["/**\n * How a painter asks for part of a node's paint to land on top of the node's\n * children: a container's label, a frame's title, a badge. A scene walk draws\n * a node before its children, so anything else a container paints is covered\n * by them.\n */\nimport type { DrawCommand, GroupDrawCommand } from '@weasel-js/renderer';\n\nconst OVER = new WeakSet<object>();\n\n/**\n * `cmds` as one command a scene walk paints after the node's children. Return\n * it among a `drawOne`'s other commands. Outside a scene walk it is an\n * ordinary group, painted where it sits in the list.\n */\nexport function overChildren(cmds: DrawCommand[]): DrawCommand {\n  const group: GroupDrawCommand = { kind: 'group', children: cmds };\n  OVER.add(group);\n  return group;\n}\n\n/** Whether `cmd` came from {@link overChildren}. */\nexport function isOverChildren(cmd: DrawCommand): boolean {\n  return OVER.has(cmd);\n}\n\nconst NOTHING: DrawCommand[] = [];\n\n/** `cmds` as what paints under the node's children and what paints over them.\n *  A list asking for nothing over comes back as `under` itself. */\nexport function splitOverChildren(cmds: DrawCommand[]): { under: DrawCommand[]; over: DrawCommand[] } {\n  if (!cmds.some(isOverChildren)) return { under: cmds, over: NOTHING };\n  const under: DrawCommand[] = [];\n  const over: DrawCommand[] = [];\n  for (const cmd of cmds) {\n    if (isOverChildren(cmd)) over.push(...(cmd as GroupDrawCommand).children);\n    else under.push(cmd);\n  }\n  return { under, over };\n}\n"],"mappings":";AAQA,IAAMA,oBAAO,IAAI,QAAgB;AAOjC,SAAgBC,EAAa,GAAkC;CAC7D,IAAMC,IAA0B;EAAE,MAAM;EAAS,UAAUC;CAAK;CAEhE,OADAH,EAAK,IAAIE,CAAK,GACPA;AACT;AAGA,SAAgBE,EAAe,GAA2B;CACxD,OAAOJ,EAAK,IAAIK,CAAG;AACrB;AAEA,IAAMC,IAAyB,CAAC;AAIhC,SAAgBC,EAAkB,GAAoE;CACpG,IAAI,CAACJ,EAAK,KAAKC,CAAc,GAAG,OAAO;EAAE,OAAOD;EAAM,MAAMG;CAAQ;CACpE,IAAME,IAAuB,CAAC,GACxBC,IAAsB,CAAC;CAC7B,KAAK,IAAMJ,KAAOF,GAChB,AAAIC,EAAeC,CAAG,IAAGI,EAAK,KAAK,GAAIJ,EAAyB,QAAQ,IACnEG,EAAM,KAAKH,CAAG;CAErB,OAAO;EAAE;EAAO;CAAK;AACvB"}

package/dist/canvas/overlayRoleStrokes.js.map

@@ -1 +1 @@
-{"version":3,"file":"overlayRoleStrokes.js","names":["OVERLAY_ROLE_STROKES"],"sources":["../../src/canvas/overlayRoleStrokes.ts"],"sourcesContent":["import type { CommandFill, CommandStroke } from '@weasel-js/paint';\n\n/** How each `polyline` overlay role reads. An action publishes the run and\n *  the word; this table is the whole of the paint, for the dispatcher overlay\n *  and for any tool previewing the same kind of run between gestures. */\nexport const OVERLAY_ROLE_STROKES: Readonly<Record<string, CommandStroke & { paint: CommandFill }>> = {\n  cut: { paint: { color: '#e23b3b' }, width: 1, dash: [6, 4] },\n  connector: { paint: { color: '#7ba7c7' }, width: 2, dash: [4, 4] },\n};\n"],"mappings":";AAKA,IAAaA,IAAyF;CACpG,KAAK;EAAE,OAAO,EAAE,OAAO,UAAU;EAAG,OAAO;EAAG,MAAM,CAAC,GAAG,CAAC;CAAE;CAC3D,WAAW;EAAE,OAAO,EAAE,OAAO,UAAU;EAAG,OAAO;EAAG,MAAM,CAAC,GAAG,CAAC;CAAE;AACnE"}
+{"version":3,"file":"overlayRoleStrokes.js","names":["OVERLAY_ROLE_STROKES"],"sources":["../../src/canvas/overlayRoleStrokes.ts"],"sourcesContent":["import type { CommandPaint, CommandStroke } from '@weasel-js/paint';\n\n/** How each `polyline` overlay role reads. An action publishes the run and\n *  the word; this table is the whole of the paint, for the dispatcher overlay\n *  and for any tool previewing the same kind of run between gestures. */\nexport const OVERLAY_ROLE_STROKES: Readonly<Record<string, CommandStroke & { paint: CommandPaint }>> = {\n  cut: { paint: { color: '#e23b3b' }, width: 1, dash: [6, 4] },\n  connector: { paint: { color: '#7ba7c7' }, width: 2, dash: [4, 4] },\n};\n"],"mappings":";AAKA,IAAaA,IAA0F;CACrG,KAAK;EAAE,OAAO,EAAE,OAAO,UAAU;EAAG,OAAO;EAAG,MAAM,CAAC,GAAG,CAAC;CAAE;CAC3D,WAAW;EAAE,OAAO,EAAE,OAAO,UAAU;EAAG,OAAO;EAAG,MAAM,CAAC,GAAG,CAAC;CAAE;AACnE"}

package/dist/canvas/paintCull.js

@@ -1,16 +1,14 @@
-import { mat3 as e } from "../renderer/math/mat3.js";
-import { viewToMat3 as t } from "../renderer/math/viewToMat3.js";
-import { boundsMissRect as n } from "../renderer/cullDrawCommands.js";
-import { poseFrameOf as r } from "../core/geometry/poseFrame.js";
+import { boundsMissRect as e } from "@weasel-js/renderer";
+import { mat3 as t, poseFrameOf as n, viewToMat3 as r } from "@weasel-js/geom";
 //#region src/canvas/paintCull.ts
 function i(i, a, o) {
-	let s = a, c = t(a);
+	let s = a, c = r(a);
 	return (l, u, d = a) => {
-		d !== s && (s = d, c = t(d));
+		d !== s && (s = d, c = r(d));
 		let f = i(l, u, d);
 		if (!f) return !1;
-		let p = r(u), m = p ? e.multiply(c, e.fromAffine(p)) : c;
-		return n(f, m, o);
+		let p = n(u), m = p ? t.multiply(c, t.fromAffine(p)) : c;
+		return e(f, m, o);
 	};
 }
 //#endregion

package/dist/canvas/paintCull.js.map

@@ -1 +1 @@
-{"version":3,"file":"paintCull.js","names":["paintMissesView","last","view","toScreen","viewToMat3","layerView","b","paintBounds","node","pose","frame","poseFrameOf","mat3","boundsMissRect","rect"],"sources":["../../src/canvas/paintCull.ts"],"sourcesContent":["import type { View } from 'core/viewport/view';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { poseFrameOf } from 'core/geometry/poseFrame';\nimport { boundsMissRect, type CullRect } from '../renderer/cullDrawCommands';\nimport { mat3 } from '../renderer/math/mat3';\nimport { viewToMat3 } from '../renderer/math/viewToMat3';\n\n/** Where a node's paint can reach, before its pose frame — the scene\n *  slot's `paintBounds`. `null` means unknown, and the node is painted. */\nexport type PaintBoundsFn<TNode, TPose> = (node: TNode, pose: TPose, view: View) => Bounds | null;\n\n/**\n * A predicate true for the nodes whose paint cannot reach `rect` (screen\n * pixels) under `view`, by `paintBounds` taken through the pose frame\n * (`poseFrameOf`) `wrapNodeOutput` applies and then the view. A node `paintBounds` cannot\n * bound is never culled.\n */\nexport function paintMissesView<TNode, TPose>(\n  paintBounds: PaintBoundsFn<TNode, TPose>,\n  view: View,\n  rect: CullRect,\n): (node: TNode, pose: TPose, layerView?: View) => boolean {\n  // `layerView` is a parallax plane's own view; planes are few, so one slot\n  // of memo covers a walk that meets them layer by layer.\n  let last = view;\n  let toScreen = viewToMat3(view);\n  return (node, pose, layerView = view) => {\n    if (layerView !== last) { last = layerView; toScreen = viewToMat3(layerView); }\n    const b = paintBounds(node, pose, layerView);\n    if (!b) return false;\n    const frame = poseFrameOf(pose);\n    const m = frame ? mat3.multiply(toScreen, mat3.fromAffine(frame)) : toScreen;\n    return boundsMissRect(b, m, rect);\n  };\n}\n"],"mappings":";;;;;AAiBA,SAAgBA,EACd,GACA,GACA,GACyD;CAGzD,IAAIC,IAAOC,GACPC,IAAWC,EAAWF,CAAI;CAC9B,QAAQ,GAAM,GAAM,IAAYA,MAAS;EACvC,AAAIG,MAAcJ,MAAQ,IAAOI,GAAW,IAAWD,EAAWC,CAAS;EAC3E,IAAMC,IAAIC,EAAYC,GAAMC,GAAMJ,CAAS;EAC3C,IAAI,CAACC,GAAG,OAAO;EACf,IAAMI,IAAQC,EAAYF,CAAI,GACxB,IAAIC,IAAQE,EAAK,SAAST,GAAUS,EAAK,WAAWF,CAAK,CAAC,IAAIP;EACpE,OAAOU,EAAeP,GAAG,GAAGQ,CAAI;CAClC;AACF"}
+{"version":3,"file":"paintCull.js","names":["viewToMat3","mat3","mat3$1","viewToMat3$1","paintMissesView","last","view","toScreen","layerView","b","paintBounds","node","pose","frame","poseFrameOf","boundsMissRect","rect"],"sources":["../../src/canvas/paintCull.ts"],"sourcesContent":["import type { View } from 'core/viewport/view';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { poseFrameOf } from '@weasel-js/geom';\nimport { boundsMissRect, type CullRect } from '@weasel-js/renderer';\nimport { mat3, viewToMat3 } from '@weasel-js/geom';\n\n/** Where a node's paint can reach, before its pose frame — the scene\n *  slot's `paintBounds`. `null` means unknown, and the node is painted. */\nexport type PaintBoundsFn<TNode, TPose> = (node: TNode, pose: TPose, view: View) => Bounds | null;\n\n/**\n * A predicate true for the nodes whose paint cannot reach `rect` (screen\n * pixels) under `view`, by `paintBounds` taken through the pose frame\n * (`poseFrameOf`) `wrapNodeOutput` applies and then the view. A node `paintBounds` cannot\n * bound is never culled.\n */\nexport function paintMissesView<TNode, TPose>(\n  paintBounds: PaintBoundsFn<TNode, TPose>,\n  view: View,\n  rect: CullRect,\n): (node: TNode, pose: TPose, layerView?: View) => boolean {\n  // `layerView` is a parallax plane's own view; planes are few, so one slot\n  // of memo covers a walk that meets them layer by layer.\n  let last = view;\n  let toScreen = viewToMat3(view);\n  return (node, pose, layerView = view) => {\n    if (layerView !== last) { last = layerView; toScreen = viewToMat3(layerView); }\n    const b = paintBounds(node, pose, layerView);\n    if (!b) return false;\n    const frame = poseFrameOf(pose);\n    const m = frame ? mat3.multiply(toScreen, mat3.fromAffine(frame)) : toScreen;\n    return boundsMissRect(b, m, rect);\n  };\n}\n"],"mappings":";;;AAgBA,SAAgBI,EACd,GACA,GACA,GACyD;CAGzD,IAAIC,IAAOC,GACPC,IAAWP,EAAWM,CAAI;CAC9B,QAAQ,GAAM,GAAM,IAAYA,MAAS;EACvC,AAAIE,MAAcH,MAAQ,IAAOG,GAAW,IAAWR,EAAWQ,CAAS;EAC3E,IAAMC,IAAIC,EAAYC,GAAMC,GAAMJ,CAAS;EAC3C,IAAI,CAACC,GAAG,OAAO;EACf,IAAMI,IAAQC,EAAYF,CAAI,GACxB,IAAIC,IAAQZ,EAAK,SAASM,GAAUN,EAAK,WAAWY,CAAK,CAAC,IAAIN;EACpE,OAAOQ,EAAeN,GAAG,GAAGO,CAAI;CAClC;AACF"}

package/dist/{features/cursor → canvas}/paintedCursorLayer.js

@@ -1,6 +1,6 @@
 import { pathFromD as e } from "@weasel-js/geom";
 import { GLYPHS as t, chromeLineWidthScale as n, cursorPaintMatrix as r, cursorPaintOps as i, cursorWorldSize as a } from "@weasel-js/cursor";
-//#region src/features/cursor/paintedCursorLayer.ts
+//#region src/canvas/paintedCursorLayer.ts
 var o = "painted-cursor", s = /* @__PURE__ */ new Map();
 function c(t) {
 	let n = s.get(t);
@@ -10,7 +10,7 @@ function l(e) {
 	return {
 		kind: "path",
 		path: c(e.d),
-		...e.fill === void 0 ? {} : { fill: { color: e.fill } },
+		...e.fill === void 0 ? {} : { fill: { paint: { color: e.fill } } },
 		...e.stroke === void 0 ? {} : { stroke: {
 			paint: { color: e.stroke.color },
 			width: e.stroke.width,

package/dist/canvas/paintedCursorLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paintedCursorLayer.js","names":["PAINTED_CURSOR_LAYER_ID","pathCache","pathFor","p","d","pathFromD","commandFor","op","createPaintedCursorLayer","frame","state","glyph","GLYPHS","cursor","scale","view","worldSized","size","cursorWorldSize","ops","cursorPaintOps","chromeLineWidthScale","a","b","c","e","f","cursorPaintMatrix"],"sources":["../../src/canvas/paintedCursorLayer.ts"],"sourcesContent":["/**\n * The painted tier: draws a cursor glyph into the scene when it is too big,\n * or too tied to the view, to be a CSS `url()` cursor.\n *\n * Screen-space: the glyph is chrome at the pointer, so it must not pan or zoom\n * with the camera. What *does* track the camera is a world-sized glyph's size,\n * and `view.scale` is read for that.\n */\n\nimport { GLYPHS } from '@weasel-js/cursor';\nimport {\n  chromeLineWidthScale,\n  cursorPaintMatrix,\n  cursorPaintOps,\n  cursorWorldSize,\n} from '@weasel-js/cursor';\nimport type { CursorPaintOp } from '@weasel-js/cursor';\nimport type { DrawCommand, PathDrawCommand } from '@weasel-js/renderer';\nimport type { RenderLayer } from 'core/layers/render';\nimport { pathFromD, type Path } from '@weasel-js/geom';\nimport type { PaintedCursorState } from '@weasel-js/cursor';\n\n/** Layer id, so a consumer can order or hide it like any other. */\nexport const PAINTED_CURSOR_LAYER_ID = 'painted-cursor';\n\n/** Handing the renderer the same `Path` object every frame lets its mesh cache hit. */\nconst pathCache = new Map<string, Path>();\nfunction pathFor(d: string): Path {\n  let p = pathCache.get(d);\n  if (p === undefined) {\n    p = pathFromD(d);\n    pathCache.set(d, p);\n  }\n  return p;\n}\n\nfunction commandFor(op: CursorPaintOp): PathDrawCommand {\n  return {\n    kind: 'path',\n    path: pathFor(op.d),\n    ...(op.fill !== undefined ? { fill: { paint: { color: op.fill } } } : {}),\n    ...(op.stroke !== undefined\n      ? {\n          stroke: {\n            paint: { color: op.stroke.color },\n            width: op.stroke.width,\n            cap: 'round' as const,\n            join: 'round' as const,\n          },\n        }\n      : {}),\n  };\n}\n\n/**\n * A screen-space layer that draws the glyph `state` currently holds at the pointer,\n * or nothing when it holds none. `<Canvas>` mounts one over its own state already.\n */\nexport function createPaintedCursorLayer(state: PaintedCursorState): RenderLayer<unknown> {\n  return {\n    id: PAINTED_CURSOR_LAYER_ID,\n    label: 'Painted cursor',\n    space: 'screen',\n    draw: (_data, view) => {\n      const frame = state.current();\n      if (!frame) return [];\n      const { cursor, at } = frame;\n      const glyph = GLYPHS[cursor.glyph];\n      if (!glyph) return [];\n\n      // A world-sized glyph holds its line weight in CSS px while its geometry\n      // grows — a ring at a 400px radius drawn with scaled weight is a filled\n      // blob. A single radius needs one scale factor, so average the axes.\n      const scale = (view.scale.x + view.scale.y) / 2;\n      const worldSized = cursor.worldRadius !== undefined;\n      const size = worldSized\n        ? cursorWorldSize(glyph, cursor.worldRadius as number, scale)\n        : (cursor.size ?? 24);\n      if (!(size > 0) || !Number.isFinite(size)) return [];\n\n      const ops = cursorPaintOps(\n        glyph,\n        worldSized ? { lineWidthScale: chromeLineWidthScale(glyph, size) } : {},\n      );\n      const [a, b, c, d, e, f] = cursorPaintMatrix(glyph, {\n        size,\n        angle: cursor.angle,\n        at,\n      });\n      // Column-major, the layout `GlMat3` documents.\n      const transform = new Float32Array([a, b, 0, c, d, 0, e, f, 1]);\n      const children: DrawCommand[] = ops.map(commandFor);\n      return [{ kind: 'group', transform, children }];\n    },\n  };\n}\n"],"mappings":";;;AAuBA,IAAaA,IAA0B,kBAGjCC,oBAAY,IAAI,IAAkB;AACxC,SAASC,EAAQ,GAAiB;CAChC,IAAIC,IAAIF,EAAU,IAAIG,CAAC;CAKvB,OAJID,MAAM,KAAA,MACR,IAAIE,EAAUD,CAAC,GACfH,EAAU,IAAIG,GAAGD,CAAC,IAEbA;AACT;AAEA,SAASG,EAAW,GAAoC;CACtD,OAAO;EACL,MAAM;EACN,MAAMJ,EAAQK,EAAG,CAAC;EAClB,GAAIA,EAAG,SAAS,KAAA,IAAsD,CAAC,IAA3C,EAAE,MAAM,EAAE,OAAO,EAAE,OAAOA,EAAG,KAAK,EAAE,EAAE;EAClE,GAAIA,EAAG,WAAW,KAAA,IASd,CAAC,IARD,EACE,QAAQ;GACN,OAAO,EAAE,OAAOA,EAAG,OAAO,MAAM;GAChC,OAAOA,EAAG,OAAO;GACjB,KAAK;GACL,MAAM;EACR,EACF;CAEN;AACF;AAMA,SAAgBC,EAAyB,GAAiD;CACxF,OAAO;EACL,IAAIR;EACJ,OAAO;EACP,OAAO;EACP,OAAO,GAAO,MAAS;GACrB,IAAMS,IAAQC,EAAM,QAAQ;GAC5B,IAAI,CAACD,GAAO,OAAO,CAAC;GACpB,IAAM,EAAE,WAAQ,UAAOA,GACjBE,IAAQC,EAAOC,EAAO;GAC5B,IAAI,CAACF,GAAO,OAAO,CAAC;GAKpB,IAAMG,KAASC,EAAK,MAAM,IAAIA,EAAK,MAAM,KAAK,GACxCC,IAAaH,EAAO,gBAAgB,KAAA,GACpCI,IAAOD,IACTE,EAAgBP,GAAOE,EAAO,aAAuBC,CAAK,IACzDD,EAAO,QAAQ;GACpB,IAAI,EAAEI,IAAO,MAAM,CAAC,OAAO,SAASA,CAAI,GAAG,OAAO,CAAC;GAEnD,IAAME,IAAMC,EACVT,GACAK,IAAa,EAAE,gBAAgBK,EAAqBV,GAAOM,CAAI,EAAE,IAAI,CAAC,CACxE,GACM,CAACK,GAAGC,GAAGC,GAAGpB,GAAGqB,GAAGC,KAAKC,EAAkBhB,GAAO;IAClD;IACA,OAAOE,EAAO;IACd;GACF,CAAC;GAID,OAAO,CAAC;IAAE,MAAM;IAAS,WAAA,IAFH,aAAa;KAACS;KAAGC;KAAG;KAAGC;KAAGpB;KAAG;KAAGqB;KAAGC;KAAG;IAAC,CAEpC;IAAW,UADJP,EAAI,IAAIb,CACJ;GAAS,CAAC;EAChD;CACF;AACF"}

package/dist/canvas/pickReach.js

@@ -0,0 +1,23 @@
+//#region src/canvas/pickReach.ts
+function e(e, t, n, r, i, a, o) {
+	let s = (r, i) => {
+		let a = o.clipOf(i);
+		return a === null || r.clipAdmits(o.carry(a, i.layer, e.layer), e, t, n);
+	}, c = a && r.inCopy !== void 0 ? i() : null;
+	if (c === null || !c.some((e) => o.copiesOf(e).length > 0)) return r.hits(e, t, n) ? (c ?? i()).every((e) => s(r, e)) : !1;
+	let l = [...c].reverse(), u = (r, i) => {
+		if (r === l.length) return i.hits(e, t, n);
+		let a = l[r];
+		if (s(i, a) && u(r + 1, i)) return !0;
+		for (let e of o.copiesOf(a)) {
+			let t = i.inCopy?.(e);
+			if (t !== void 0 && s(t, a) && u(r + 1, t)) return !0;
+		}
+		return !1;
+	};
+	return u(0, r);
+}
+//#endregion
+export { e as reaches };
+
+//# sourceMappingURL=pickReach.js.map

package/dist/canvas/pickReach.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pickReach.js","names":["reaches","admits","clip","look","ancestor","query","node","pose","derived","parents","copying","q","parentsOf","a","outermostFirst","from","i","m","inCopy"],"sources":["../../src/canvas/pickReach.ts"],"sourcesContent":["import type { Affine, Path } from '@weasel-js/geom';\nimport type { PickCandidate, PickQuery } from './pickWalk';\n\n/** What {@link reaches} needs from the walk, each memoized per walk there. */\nexport interface ReachLookups<TPose> {\n  /** An ancestor's own clip, or null. */\n  clipOf(ancestor: PickCandidate<TPose>): Path | null;\n  /** The maps from world into the source frame of each copy `ancestor` draws:\n   *  the inverses of its `copiesFromPose`. Empty when it draws none. */\n  copiesOf(ancestor: PickCandidate<TPose>): readonly Affine[];\n  /** A clip carried from its container's plane into the node's. */\n  carry(clip: Path, fromLayer: string | undefined, toLayer: string | undefined): Path;\n}\n\n/**\n * Whether `q` lands on `node` anywhere it is painted: as authored, or in any\n * copy an ancestor draws of it. `parents` is innermost first.\n *\n * A copy is the clipped content transformed, so the query is carried into the\n * copy's source frame before the copying container's own clip is asked, and\n * every clip below it is asked in that frame too.\n *\n * `parents` is called only when the answer needs it — always when\n * `copying` says some container in the walk draws copies, otherwise only\n * after the node hits as authored.\n */\nexport function reaches<TPose>(\n  node: PickCandidate<TPose>,\n  pose: TPose,\n  derived: Path | null | undefined,\n  q: PickQuery<TPose>,\n  parentsOf: () => readonly PickCandidate<TPose>[],\n  copying: boolean,\n  look: ReachLookups<TPose>,\n): boolean {\n  const admits = (query: PickQuery<TPose>, ancestor: PickCandidate<TPose>): boolean => {\n    const clip = look.clipOf(ancestor);\n    return clip === null\n      || query.clipAdmits(look.carry(clip, ancestor.layer, node.layer), node, pose, derived);\n  };\n\n  const parents = copying && q.inCopy !== undefined ? parentsOf() : null;\n  if (parents === null || !parents.some((a) => look.copiesOf(a).length > 0)) {\n    if (!q.hits(node, pose, derived)) return false;\n    return (parents ?? parentsOf()).every((a) => admits(q, a));\n  }\n\n  const outermostFirst = [...parents].reverse();\n  const from = (i: number, query: PickQuery<TPose>): boolean => {\n    if (i === outermostFirst.length) return query.hits(node, pose, derived);\n    const ancestor = outermostFirst[i];\n    if (admits(query, ancestor) && from(i + 1, query)) return true;\n    for (const m of look.copiesOf(ancestor)) {\n      const inCopy = query.inCopy?.(m);\n      if (inCopy !== undefined && admits(inCopy, ancestor) && from(i + 1, inCopy)) return true;\n    }\n    return false;\n  };\n  return from(0, q);\n}\n"],"mappings":";AA0BA,SAAgBA,EACd,GACA,GACA,GACA,GACA,GACA,GACA,GACS;CACT,IAAMC,KAAU,GAAyB,MAA4C;EACnF,IAAMC,IAAOC,EAAK,OAAOC,CAAQ;EACjC,OAAOF,MAAS,QACXG,EAAM,WAAWF,EAAK,MAAMD,GAAME,EAAS,OAAOE,EAAK,KAAK,GAAGA,GAAMC,GAAMC,CAAO;CACzF,GAEMC,IAAUC,KAAWC,EAAE,WAAW,KAAA,IAAYC,EAAU,IAAI;CAClE,IAAIH,MAAY,QAAQ,CAACA,EAAQ,MAAM,MAAMN,EAAK,SAASU,CAAC,CAAC,CAAC,SAAS,CAAC,GAEtE,OADKF,EAAE,KAAKL,GAAMC,GAAMC,CAAO,KACvBC,KAAWG,EAAU,EAAA,CAAG,OAAO,MAAMX,EAAOU,GAAGE,CAAC,CAAC,IADhB;CAI3C,IAAMC,IAAiB,CAAC,GAAGL,CAAO,CAAC,CAAC,QAAQ,GACtCM,KAAQ,GAAW,MAAqC;EAC5D,IAAIC,MAAMF,EAAe,QAAQ,OAAOT,EAAM,KAAKC,GAAMC,GAAMC,CAAO;EACtE,IAAMJ,IAAWU,EAAeE;EAChC,IAAIf,EAAOI,GAAOD,CAAQ,KAAKW,EAAKC,IAAI,GAAGX,CAAK,GAAG,OAAO;EAC1D,KAAK,IAAMY,KAAKd,EAAK,SAASC,CAAQ,GAAG;GACvC,IAAMc,IAASb,EAAM,SAASY,CAAC;GAC/B,IAAIC,MAAW,KAAA,KAAajB,EAAOiB,GAAQd,CAAQ,KAAKW,EAAKC,IAAI,GAAGE,CAAM,GAAG,OAAO;EACtF;EACA,OAAO;CACT;CACA,OAAOH,EAAK,GAAGJ,CAAC;AAClB"}