@weasel-js/core 1.9.3 → 1.10.0

package/dist/canvas/layerSlots.js

@@ -8,7 +8,12 @@ var e = [
 function t(e) {
 	return !!e && typeof e == "object" && "layer" in e;
 }
+function n(e) {
+	let n = {};
+	for (let [r, i] of Object.entries(e)) (i === null || t(i)) && (n[r] = i);
+	return n;
+}
 //#endregion
-export { e as STANDARD_SLOTS, t as isCustomEntry };
+export { e as STANDARD_SLOTS, n as builtLayersOf, t as isCustomEntry };
 
 //# sourceMappingURL=layerSlots.js.map

package/dist/canvas/layerSlots.js.map

@@ -1 +1 @@
-{"version":3,"file":"layerSlots.js","names":["STANDARD_SLOTS","isCustomEntry","v"],"sources":["../../src/canvas/layerSlots.ts"],"sourcesContent":["import type { RenderLayer } from '../core/layers/render';\n\n/** Standard slot names — render in this canonical order.\n *  `cellHighlight` is not an anchor for custom layers: it sits between the\n *  grid and the scene, so anchor to one of those. */\n/** @internal */\nexport const STANDARD_SLOTS = [\n  'grid',\n  'cellHighlight',\n  'scene',\n  'selectionOverlay',\n] as const;\n\n/** Names of the slots `<Canvas>` supports out of the box (excluding the implicit cell-highlight overlay). */\nexport type StandardSlotName = Exclude<(typeof STANDARD_SLOTS)[number], 'cellHighlight'>;\n\n/** Custom layer entry — any key not in `STANDARD_SLOTS`. The presence of\n *  `.layer` discriminates this from a slot config. */\nexport interface CustomLayerEntry {\n  layer: RenderLayer<unknown>;\n  /** Insert immediately after the named standard slot or another custom-layer key. */\n  after?: StandardSlotName | (string & {});\n  /** Insert immediately before the named standard slot or another custom-layer key. */\n  before?: StandardSlotName | (string & {});\n}\n\nexport function isCustomEntry(v: unknown): v is CustomLayerEntry {\n  return !!v && typeof v === 'object' && 'layer' in (v as Record<string, unknown>);\n}\n"],"mappings":";AAMA,IAAaA,IAAiB;CAC5B;CACA;CACA;CACA;AACF;AAeA,SAAgBC,EAAc,GAAmC;CAC/D,OAAO,CAAC,CAACC,KAAK,OAAOA,KAAM,YAAY,WAAYA;AACrD"}
+{"version":3,"file":"layerSlots.js","names":["STANDARD_SLOTS","isCustomEntry","v","builtLayersOf","out","key","value","map"],"sources":["../../src/canvas/layerSlots.ts"],"sourcesContent":["import type { RenderLayer } from '../core/layers/render';\nimport type { SelectionOverlayLayerOpts } from 'features/selection/overlay';\nimport type { SceneSlotConfig } from './buildSceneLayer';\n\n/** Standard slot names — render in this canonical order.\n *  `cellHighlight` is not an anchor for custom layers: it sits between the\n *  grid and the scene, so anchor to one of those. */\n/** @internal */\nexport const STANDARD_SLOTS = [\n  'grid',\n  'cellHighlight',\n  'scene',\n  'selectionOverlay',\n] as const;\n\n/** Names of the slots `<Canvas>` supports out of the box (excluding the implicit cell-highlight overlay). */\nexport type StandardSlotName = Exclude<(typeof STANDARD_SLOTS)[number], 'cellHighlight'>;\n\n/** Custom layer entry — any key not in `STANDARD_SLOTS`. The presence of\n *  `.layer` discriminates this from a slot config. */\nexport interface CustomLayerEntry {\n  layer: RenderLayer<unknown>;\n  /** Insert immediately after the named standard slot or another custom-layer key. */\n  after?: StandardSlotName | (string & {});\n  /** Insert immediately before the named standard slot or another custom-layer key. */\n  before?: StandardSlotName | (string & {});\n}\n\nexport function isCustomEntry(v: unknown): v is CustomLayerEntry {\n  return !!v && typeof v === 'object' && 'layer' in (v as Record<string, unknown>);\n}\n\n/** Selection-overlay slot config — passed through to `createSelectionOverlayLayer`,\n *  minus the `getSelection`/`getPose` the canvas wires automatically. */\nexport type SelectionOverlaySlotConfig<TPose> = Omit<\n  SelectionOverlayLayerOpts<TPose>,\n  'getSelection' | 'getPose'\n> & {\n  /** Override the auto-wired pose lookup (overlay-aware → adapter fallback). */\n  poseById?: (id: string) => TPose | null;\n};\n\n/** Per-slot config union. The key narrows it in practice. */\nexport type StandardSlotConfig<TNode extends { id: string }, TPose> =\n  | SceneSlotConfig<TNode, TPose>\n  | SelectionOverlaySlotConfig<TPose>;\n\n/** What may fill one of the canvas's named layer slots: a config the canvas\n *  builds the layer from, a pre-built layer, or `null` to leave the slot\n *  empty. */\nexport type LayerSlotValue<TNode extends { id: string }, TPose> =\n  | StandardSlotConfig<TNode, TPose>\n  | CustomLayerEntry\n  | null;\n\n/** The canvas's render stack, as named slots. The standard slots (grid,\n *  scene, selection overlay, cell highlight) fix where a layer sits in the\n *  stack; scene and selection overlay can be configured, and every one can be\n *  given a layer of your own or switched off. Further keys add custom layers.\n *  `TSceneSlot` is what the scene slot accepts: `<SceneCanvas>` takes a\n *  partial config and fills the rest from its defaults. */\nexport type LayersMap<\n  TNode extends { id: string },\n  TPose,\n  TSceneSlot = SceneSlotConfig<TNode, TPose>,\n> = {\n  /** Grid slot, beneath the scene. Takes a pre-built layer (`{ layer }`) —\n   *  e.g. `createGridLayer` from `@weasel-js/guides` — or `null`. */\n  grid?: CustomLayerEntry | null;\n  /** Scene slot: the config `<SceneCanvas>` builds its layers from, a\n   *  pre-built layer that paints the scene in their place, or `null`. A\n   *  pre-built layer gets no ghost of a node in flight, which needs `drawOne`. */\n  scene?: TSceneSlot | CustomLayerEntry | null;\n  /** Selection-overlay slot: the config `<SceneCanvas>` builds the layer\n   *  from, a pre-built layer that paints in its place, or `null` for no\n   *  selection chrome. */\n  selectionOverlay?: SelectionOverlaySlotConfig<TPose> | CustomLayerEntry | null;\n  /** Cell-highlight overlay slot, drawn immediately after the grid. Takes a\n   *  pre-built layer (`{ layer }`) — e.g. `createCellHighlightLayer` from\n   *  `@weasel-js/guides` — or `null`. */\n  cellHighlight?: CustomLayerEntry | null;\n} & {\n  [customKey: string]: LayerSlotValue<TNode, TPose> | TSceneSlot | undefined;\n};\n\n/** The scene slot once built: its canvas layers, bottom first. Each `key` is\n *  an anchor a custom layer can name (`scene`, or `scene:<layerId>`). */\nexport interface SceneSlotLayers {\n  layers: ReadonlyArray<{ key: string; layer: RenderLayer<unknown> }>;\n}\n\n/** What `<Canvas>` composes: a {@link LayersMap} with every slot already a\n *  layer. `<SceneCanvas>` builds one from its `layers` prop. */\nexport type CanvasLayers = {\n  grid?: CustomLayerEntry | null;\n  cellHighlight?: CustomLayerEntry | null;\n  scene?: SceneSlotLayers | null;\n  selectionOverlay?: CustomLayerEntry | null;\n} & {\n  [customKey: string]: CustomLayerEntry | SceneSlotLayers | null | undefined;\n};\n\n/** The layers of `map` that are already built, in its key order: each\n *  `{ layer }` entry and each `null`. A slot config is left out, for whoever\n *  builds it to put back. */\nexport function builtLayersOf(map: Record<string, unknown>): Record<string, CustomLayerEntry | null> {\n  const out: Record<string, CustomLayerEntry | null> = {};\n  for (const [key, value] of Object.entries(map)) {\n    if (value === null || isCustomEntry(value)) out[key] = value;\n  }\n  return out;\n}\n"],"mappings":";AAQA,IAAaA,IAAiB;CAC5B;CACA;CACA;CACA;AACF;AAeA,SAAgBC,EAAc,GAAmC;CAC/D,OAAO,CAAC,CAACC,KAAK,OAAOA,KAAM,YAAY,WAAYA;AACrD;AA2EA,SAAgBC,EAAc,GAAuE;CACnG,IAAMC,IAA+C,CAAC;CACtD,KAAK,IAAM,CAACC,GAAKC,MAAU,OAAO,QAAQC,CAAG,GAC3C,CAAID,MAAU,QAAQL,EAAcK,CAAK,OAAG,EAAID,KAAOC;CAEzD,OAAOF;AACT"}

package/dist/canvas/nodeShapes/derivedPainter.js

@@ -0,0 +1,34 @@
+import { DEFAULT_SHAPE_FILL as e } from "../../util/paint.js";
+import { derivesPath as t } from "./memo.js";
+import { inkReach as n, resolveNodeFill as r, resolveNodeStroke as i, withAnimatedVertexColors as a } from "./nodePaint.js";
+import { commandFill as o, commandStroke as s } from "@weasel-js/renderer";
+import { boundsOfPath as c } from "@weasel-js/geom";
+//#region src/canvas/nodeShapes/derivedPainter.ts
+var l = {
+	id: "kit:derived",
+	matches: t,
+	paint: (t, n, l) => {
+		let u = l?.derivedPath;
+		if (u == null) return [];
+		let d = c(u), f = t.data, p = i(f?.stroke), m = r(f?.fill, p === null ? e : null), h = m && o(m, d), g = p && s(p, d), _ = {
+			kind: "path",
+			path: u,
+			...h ? { fill: h } : {},
+			...h && f?.vertexColors ? { vertexColors: f.vertexColors } : {},
+			...g ? { stroke: g } : {}
+		};
+		return a([_], l);
+	},
+	silhouette: (e, t, n) => n?.derivedPath ?? null,
+	ink: (t, a, o) => {
+		let s = t.data, c = i(s?.stroke);
+		return {
+			filled: r(s?.fill, c === null ? e : null) !== null,
+			...n(c, o?.scale)
+		};
+	}
+};
+//#endregion
+export { l as DERIVED_PAINTER };
+
+//# sourceMappingURL=derivedPainter.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"derivedPainter.js","names":["DERIVED_PAINTER","derivesPath","path","ctx","box","boundsOfPath","d","node","strokeSpec","resolveNodeStroke","declared","resolveNodeFill","DEFAULT_SHAPE_FILL","fill","commandFill","stroke","commandStroke","cmd","withAnimatedVertexColors","inkReach"],"sources":["../../../src/canvas/nodeShapes/derivedPainter.ts"],"sourcesContent":["import {\n  boundsOfPath\n} from '@weasel-js/geom';\nimport type { Stroke, Fill } from '@weasel-js/paint';\nimport type { NodeShapeEntry } from 'canvas/NodeShape';\nimport { commandFill, commandStroke } from '@weasel-js/renderer';\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport { DEFAULT_SHAPE_FILL } from '../../util/paint';\nimport { derivesPath } from './memo';\nimport { inkReach, withAnimatedVertexColors, resolveNodeFill, resolveNodeStroke } from './nodePaint';\n\n/**\n * Built-in painter for nodes whose geometry is computed from other nodes'\n * poses. The path itself arrives on the paint context — see\n * {@link NodePaintCtx.derivedPath}.\n *\n * Fill and stroke resolve as `kit:path`'s do, but against the **derived path's\n * own bounds**, not the pose. `kit:path` projects its path into the pose frame\n * first, so there the two boxes are the same one; here the path is already\n * absolute and the pose is typically a zero-sized placeholder, which would\n * collapse a box-relative gradient onto a point.\n *\n * Not memoized on {@link PAINT_SLOT} on purpose: that key is `(node, pose,\n * data)` and cannot see `ctx.derivedPath`, so it would serve one caller's\n * commands to a caller that passed a different path.\n *\n * Rotation still comes from the pose — `wrapNodeOutput` turns the output about\n * the pose AABB's center, which for a zero-sized pose is its origin.\n */\nexport const DERIVED_PAINTER: NodeShapeEntry = {\n  id: 'kit:derived',\n  // `dependsOn` alone is not enough: the two fields are independent optionals,\n  // and `kit:add` restores a node with its `dependsOn` intact when its\n  // `derivePath` key is missing from the registry. Claiming that node would paint\n  // nothing where the authored appearance is what the warning promises.\n  matches: derivesPath,\n  paint: (node, _pose, ctx) => {\n    const path = ctx?.derivedPath;\n    if (path == null) return [];\n    const box = boundsOfPath(path);\n    const d = node.data as { fill?: Fill | null; stroke?: Stroke | null; vertexColors?: number[] } | null;\n    const strokeSpec = resolveNodeStroke(d?.stroke);\n    const declared = resolveNodeFill(d?.fill, strokeSpec === null ? DEFAULT_SHAPE_FILL : null);\n    const fill = declared && commandFill(declared, box);\n    const stroke = strokeSpec && commandStroke(strokeSpec, box);\n    const cmd: DrawCommand = {\n      kind: 'path',\n      path,\n      ...(fill ? { fill } : {}),\n      ...(fill && d?.vertexColors ? { vertexColors: d.vertexColors } : {}),\n      ...(stroke ? { stroke } : {}),\n    };\n    return withAnimatedVertexColors([cmd], ctx);\n  },\n  // The derived path *is* the silhouette, and it is already absolute — the\n  // pose is a placeholder, so nothing here can be recovered from it. Without\n  // a `ctx` this reports null, which `shapeCoversPoint` reads as \"no\n  // opinion\": picking then falls back to that zero-sized pose.\n  silhouette: (_node, _pose, ctx) => ctx?.derivedPath ?? null,\n  ink: (node, _pose, ctx) => {\n    const d = node.data as { fill?: Fill | null; stroke?: Stroke | null } | null;\n    const stroke = resolveNodeStroke(d?.stroke);\n    return {\n      filled: resolveNodeFill(d?.fill, stroke === null ? DEFAULT_SHAPE_FILL : null) !== null,\n      ...inkReach(stroke, ctx?.scale),\n    };\n  },\n};\n"],"mappings":";;;;;;AA6BA,IAAaA,IAAkC;CAC7C,IAAI;CAKJ,SAASC;CACT,QAAQ,GAAM,GAAO,MAAQ;EAC3B,IAAMC,IAAOC,GAAK;EAClB,IAAID,KAAQ,MAAM,OAAO,CAAC;EAC1B,IAAME,IAAMC,EAAaH,CAAI,GACvBI,IAAIC,EAAK,MACTC,IAAaC,EAAkBH,GAAG,MAAM,GACxCI,IAAWC,EAAgBL,GAAG,MAAME,MAAe,OAAOI,IAAqB,IAAI,GACnFC,IAAOH,KAAYI,EAAYJ,GAAUN,CAAG,GAC5CW,IAASP,KAAcQ,EAAcR,GAAYJ,CAAG,GACpDa,IAAmB;GACvB,MAAM;GACN;GACA,GAAIJ,IAAO,EAAE,QAAK,IAAI,CAAC;GACvB,GAAIA,KAAQP,GAAG,eAAe,EAAE,cAAcA,EAAE,aAAa,IAAI,CAAC;GAClE,GAAIS,IAAS,EAAE,UAAO,IAAI,CAAC;EAC7B;EACA,OAAOG,EAAyB,CAACD,CAAG,GAAGd,CAAG;CAC5C;CAKA,aAAa,GAAO,GAAO,MAAQA,GAAK,eAAe;CACvD,MAAM,GAAM,GAAO,MAAQ;EACzB,IAAMG,IAAIC,EAAK,MACTQ,IAASN,EAAkBH,GAAG,MAAM;EAC1C,OAAO;GACL,QAAQK,EAAgBL,GAAG,MAAMS,MAAW,OAAOH,IAAqB,IAAI,MAAM;GAClF,GAAGO,EAASJ,GAAQZ,GAAK,KAAK;EAChC;CACF;AACF"}

package/dist/canvas/nodeShapes/imagePainter.js

@@ -0,0 +1,87 @@
+import { paintsPose as e, poseBoxBounds as t } from "./poseBox.js";
+import { getImageBitmap as n, imageStatus as r } from "@weasel-js/renderer";
+import { linePath as i } from "@weasel-js/geom";
+//#region src/canvas/nodeShapes/imagePainter.ts
+function a(e, t) {
+	return {
+		x: e.x * t.width,
+		y: e.y * t.height,
+		w: e.width * t.width,
+		h: e.height * t.height
+	};
+}
+function o(e, t, n) {
+	if (n && n > 0) return {
+		width: Math.abs(e.width) * n / (t?.width || 1),
+		height: Math.abs(e.height) * n / (t?.height || 1)
+	};
+}
+var s = {
+	id: "kit:image",
+	matches: (t) => {
+		if (!e(t.pose)) return !1;
+		let n = t.data?.image?.src;
+		return typeof n == "string" && n.length > 0;
+	},
+	paint: (e, t, s) => {
+		let c = e.data, l = t, u = s?.resolveImage ? s.resolveImage(e) : n(c.image.src, o(l, c.image.source, s?.pixelScale));
+		if (u) return [{
+			kind: "image",
+			image: u,
+			x: l.x,
+			y: l.y,
+			w: l.width,
+			h: l.height,
+			...c.image.opacity === void 0 ? {} : { opacity: c.image.opacity },
+			...c.image.source ? { source: a(c.image.source, u) } : {},
+			...c.image.flipX ? { flipX: !0 } : {},
+			...c.image.flipY ? { flipY: !0 } : {}
+		}];
+		let d = !s?.resolveImage && r(c.image.src) === "error", f = d ? "#d08a8a" : "#bbbbbb", p = [{
+			kind: "path",
+			path: {
+				kind: "rect",
+				x: l.x,
+				y: l.y,
+				width: l.width,
+				height: l.height
+			},
+			stroke: {
+				paint: { color: f },
+				width: 1
+			}
+		}];
+		return d && p.push({
+			kind: "path",
+			path: i({
+				x: l.x,
+				y: l.y
+			}, {
+				x: l.x + l.width,
+				y: l.y + l.height
+			}),
+			stroke: {
+				paint: { color: f },
+				width: 1
+			}
+		}), p;
+	},
+	silhouette: (e, t) => {
+		let n = t;
+		return {
+			kind: "rect",
+			x: n.x,
+			y: n.y,
+			width: n.width,
+			height: n.height
+		};
+	},
+	bounds: (e, n, r) => t(n, c, r)
+}, c = {
+	paint: { color: "#000" },
+	width: 1
+};
+//#endregion
+export { s as IMAGE_PAINTER, c as IMAGE_PLACEHOLDER_STROKE, o as drawnSize, a as sourceInPixels };
+
+//# sourceMappingURL=imagePainter.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"imagePainter.js","names":["sourceInPixels","s","bmp","drawnSize","pixelScale","pose","source","IMAGE_PAINTER","paintsPose","node","src","d","p","ctx","getImageBitmap","error","imageStatus","color","cmds","linePath","poseBoxBounds","IMAGE_PLACEHOLDER_STROKE"],"sources":["../../../src/canvas/nodeShapes/imagePainter.ts"],"sourcesContent":["import {\n  linePath\n} from '@weasel-js/geom';\nimport type { Stroke } from '@weasel-js/paint';\nimport type { NodeShapeEntry } from 'canvas/NodeShape';\nimport type { Node, RectPose } from 'core/scene/types';\nimport {\n  getImageBitmap, imageStatus, type ImageNodeData, type ImageRasterSize,\n} from '@weasel-js/renderer';\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport { paintsPose, poseBoxBounds } from './poseBox';\n\n// ─── Built-in painters ─────────────────────────────────────────────────\n\nexport function sourceInPixels(\n  s: NonNullable<ImageNodeData['image']['source']>,\n  bmp: ImageBitmap,\n): { x: number; y: number; w: number; h: number } {\n  return {\n    x: s.x * bmp.width, y: s.y * bmp.height, w: s.width * bmp.width, h: s.height * bmp.height,\n  };\n}\n\n/** The whole bitmap's size in device pixels when `source` of it fills `pose`. */\nexport function drawnSize(\n  pose: RectPose,\n  source: ImageNodeData['image']['source'],\n  pixelScale: number | undefined,\n): ImageRasterSize | undefined {\n  if (!(pixelScale && pixelScale > 0)) return undefined;\n  return {\n    width: Math.abs(pose.width) * pixelScale / (source?.width || 1),\n    height: Math.abs(pose.height) * pixelScale / (source?.height || 1),\n  };\n}\n\n/** Raster-image painter. Renders `data.image.src` (URL / blob: / data-URI)\n *  via an `ImageDrawCommand` once the bitmap has decoded; until then it paints\n *  a faint placeholder outline so the node stays visible + selectable (a\n *  reddish outline + slash marks a failed load). The decoded bitmap is owned\n *  by `imageCache`, keyed on `src`; the node holds only the serializable `src`.\n *  Registered before `kit:rect-fallback` so image nodes don't fall through. */\nexport const IMAGE_PAINTER: NodeShapeEntry<unknown, RectPose> = {\n  id: 'kit:image',\n  matches: (node) => {\n    if (!paintsPose(node.pose)) return false;\n    const src = (node.data as { image?: { src?: unknown } } | null)?.image?.src;\n    return typeof src === 'string' && src.length > 0;\n  },\n  paint: (node, pose, ctx) => {\n    const d = node.data as ImageNodeData;\n    const p = pose;\n    const bmp = ctx?.resolveImage\n      ? ctx.resolveImage(node as unknown as Node<unknown, string, unknown>)\n      : getImageBitmap(d.image.src, drawnSize(p, d.image.source, ctx?.pixelScale));\n    if (bmp) {\n      return [{\n        kind: 'image',\n        image: bmp,\n        x: p.x, y: p.y, w: p.width, h: p.height,\n        ...(d.image.opacity !== undefined ? { opacity: d.image.opacity } : {}),\n        ...(d.image.source ? { source: sourceInPixels(d.image.source, bmp) } : {}),\n        ...(d.image.flipX ? { flipX: true } : {}),\n        ...(d.image.flipY ? { flipY: true } : {}),\n      }];\n    }\n    // Not ready — faint placeholder (grey while loading, reddish + slash on\n    // error). With a caller-supplied resolver the fallback is deterministic:\n    // always the plain grey outline, no ambient load-status read.\n    const error = ctx?.resolveImage ? false : imageStatus(d.image.src) === 'error';\n    const color = error ? '#d08a8a' : '#bbbbbb';\n    const cmds: DrawCommand[] = [{\n      kind: 'path',\n      path: { kind: 'rect', x: p.x, y: p.y, width: p.width, height: p.height },\n      stroke: { paint: { color }, width: 1 },\n    }];\n    if (error) {\n      cmds.push({\n        kind: 'path',\n        path: linePath({ x: p.x, y: p.y }, { x: p.x + p.width, y: p.y + p.height }),\n        stroke: { paint: { color }, width: 1 },\n      });\n    }\n    return cmds;\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  // The placeholder's 1-unit outline is the only thing that leaves the box.\n  bounds: (_node, pose, ctx) => poseBoxBounds(pose, IMAGE_PLACEHOLDER_STROKE, ctx),\n};\n\nexport const IMAGE_PLACEHOLDER_STROKE: Stroke = { paint: { color: '#000' }, width: 1 };\n"],"mappings":";;;;AAcA,SAAgBA,EACd,GACA,GACgD;CAChD,OAAO;EACL,GAAGC,EAAE,IAAIC,EAAI;EAAO,GAAGD,EAAE,IAAIC,EAAI;EAAQ,GAAGD,EAAE,QAAQC,EAAI;EAAO,GAAGD,EAAE,SAASC,EAAI;CACrF;AACF;AAGA,SAAgBC,EACd,GACA,GACA,GAC6B;CAC7B,IAAMC,KAAcA,IAAa,GACjC,OAAO;EACL,OAAO,KAAK,IAAIC,EAAK,KAAK,IAAID,KAAcE,GAAQ,SAAS;EAC7D,QAAQ,KAAK,IAAID,EAAK,MAAM,IAAID,KAAcE,GAAQ,UAAU;CAClE;AACF;AAQA,IAAaC,IAAmD;CAC9D,IAAI;CACJ,UAAU,MAAS;EACjB,IAAI,CAACC,EAAWC,EAAK,IAAI,GAAG,OAAO;EACnC,IAAMC,IAAOD,EAAK,MAA+C,OAAO;EACxE,OAAO,OAAOC,KAAQ,YAAYA,EAAI,SAAS;CACjD;CACA,QAAQ,GAAM,GAAM,MAAQ;EAC1B,IAAMC,IAAIF,EAAK,MACTG,IAAIP,GACJH,IAAMW,GAAK,eACbA,EAAI,aAAaJ,CAAiD,IAClEK,EAAeH,EAAE,MAAM,KAAKR,EAAUS,GAAGD,EAAE,MAAM,QAAQE,GAAK,UAAU,CAAC;EAC7E,IAAIX,GACF,OAAO,CAAC;GACN,MAAM;GACN,OAAOA;GACP,GAAGU,EAAE;GAAG,GAAGA,EAAE;GAAG,GAAGA,EAAE;GAAO,GAAGA,EAAE;GACjC,GAAID,EAAE,MAAM,YAAY,KAAA,IAA2C,CAAC,IAAhC,EAAE,SAASA,EAAE,MAAM,QAAQ;GAC/D,GAAIA,EAAE,MAAM,SAAS,EAAE,QAAQX,EAAeW,EAAE,MAAM,QAAQT,CAAG,EAAE,IAAI,CAAC;GACxE,GAAIS,EAAE,MAAM,QAAQ,EAAE,OAAO,GAAK,IAAI,CAAC;GACvC,GAAIA,EAAE,MAAM,QAAQ,EAAE,OAAO,GAAK,IAAI,CAAC;EACzC,CAAC;EAKH,IAAMI,IAAQ,IAAK,gBAAuBC,EAAYL,EAAE,MAAM,GAAG,MAAM,SACjEM,IAAQF,IAAQ,YAAY,WAC5BG,IAAsB,CAAC;GAC3B,MAAM;GACN,MAAM;IAAE,MAAM;IAAQ,GAAGN,EAAE;IAAG,GAAGA,EAAE;IAAG,OAAOA,EAAE;IAAO,QAAQA,EAAE;GAAO;GACvE,QAAQ;IAAE,OAAO,EAAE,SAAM;IAAG,OAAO;GAAE;EACvC,CAAC;EAQD,OAPIG,KACFG,EAAK,KAAK;GACR,MAAM;GACN,MAAMC,EAAS;IAAE,GAAGP,EAAE;IAAG,GAAGA,EAAE;GAAE,GAAG;IAAE,GAAGA,EAAE,IAAIA,EAAE;IAAO,GAAGA,EAAE,IAAIA,EAAE;GAAO,CAAC;GAC1E,QAAQ;IAAE,OAAO,EAAE,SAAM;IAAG,OAAO;GAAE;EACvC,CAAC,GAEIM;CACT;CACA,aAAa,GAAO,MAAS;EAC3B,IAAMN,IAAIP;EACV,OAAO;GAAE,MAAM;GAAQ,GAAGO,EAAE;GAAG,GAAGA,EAAE;GAAG,OAAOA,EAAE;GAAO,QAAQA,EAAE;EAAO;CAC1E;CAEA,SAAS,GAAO,GAAM,MAAQQ,EAAcf,GAAMgB,GAA0BR,CAAG;AACjF,GAEaQ,IAAmC;CAAE,OAAO,EAAE,OAAO,OAAO;CAAG,OAAO;AAAE"}

package/dist/canvas/nodeShapes/memo.js

@@ -0,0 +1,9 @@
+//#region src/canvas/nodeShapes/memo.ts
+var e = "shape:paint";
+function t(e) {
+	return (e.dependsOn?.length ?? 0) > 0 && e.derivePath !== void 0;
+}
+//#endregion
+export { e as PAINT_SLOT, t as derivesPath };
+
+//# sourceMappingURL=memo.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"memo.js","names":["PAINT_SLOT","derivesPath","node"],"sources":["../../../src/canvas/nodeShapes/memo.ts"],"sourcesContent":["\n/**\n * Slot for a painter's memoized `paint` output.\n *\n * Distinct from the silhouette slot even though the two mostly invalidate\n * together: the silhouette bakes `pose.rotation` in (paint does not — the\n * render wrap applies it), and paint alone can depend on `NodePaintCtx` and on\n * ambient readiness.\n *\n * **Only for painters that are a pure function of `(node, pose, data)`.**\n * `kit:text` and `kit:image` do not qualify.\n */\nexport const PAINT_SLOT = 'shape:paint';\n\nexport function derivesPath(node: { dependsOn?: readonly unknown[] | 'children'; derivePath?: unknown }): boolean {\n  return (node.dependsOn?.length ?? 0) > 0 && node.derivePath !== undefined;\n}\n"],"mappings":";AAYA,IAAaA,IAAa;AAE1B,SAAgBC,EAAY,GAAsF;CAChH,QAAQC,EAAK,WAAW,UAAU,KAAK,KAAKA,EAAK,eAAe,KAAA;AAClE"}

package/dist/canvas/nodeShapes/nodePaint.js

@@ -0,0 +1,68 @@
+import { bumpNodeMemoGeneration as e } from "../../core/scene/nodeMemo.js";
+import { DEFAULT_SHAPE_FILL as t } from "../../util/paint.js";
+import { paintDrawKindRegistry as n } from "@weasel-js/renderer";
+import { countPathAnchors as r } from "@weasel-js/geom";
+import { markerReach as i, resolveStrokeWidth as a } from "@weasel-js/stroke";
+//#region src/canvas/nodeShapes/nodePaint.ts
+n.subscribe(e);
+function o(e, t) {
+	let n = e === void 0 ? t : e;
+	return n?.paint == null ? null : n;
+}
+function s(e) {
+	return e?.paint == null ? null : e;
+}
+function c(e, t) {
+	if (e === null) return {
+		outset: 0,
+		inset: 0
+	};
+	let n = i(e), r = (t, n) => {
+		switch (e.align ?? "center") {
+			case "inner": return {
+				outset: n,
+				inset: t
+			};
+			case "outer": return {
+				outset: t + n,
+				inset: 0
+			};
+			default: return {
+				outset: t / 2 + n,
+				inset: t / 2
+			};
+		}
+	}, o = e.width ?? 1, s = r(typeof o == "object" ? 0 : a(o, t ?? 1), n.world);
+	if (typeof o != "object" && !(n.px > 0)) return s;
+	let c = r(typeof o == "object" ? o.px : 0, n.px);
+	return {
+		outset: s.outset,
+		inset: s.inset,
+		outsetPx: c.outset,
+		insetPx: c.inset
+	};
+}
+function l(e, t) {
+	let n = t?.vertexColors, i = e[0];
+	if (n === void 0 || i?.kind !== "path") return e;
+	let a = 4 * r(i.path), o = i.fill ? n("fill", i.vertexColors) : void 0, s = i.stroke ? n("stroke", i.stroke.vertexColors) : void 0, c = o?.length === a && o !== i.vertexColors, l = s?.length === a && s !== i.stroke?.vertexColors;
+	return !c && !l ? e : [{
+		...i,
+		...c ? { vertexColors: o } : {},
+		...l ? { stroke: {
+			...i.stroke,
+			vertexColors: s
+		} } : {}
+	}, ...e.slice(1)];
+}
+function u(e) {
+	let n = s(e.stroke), r = o(e.fill, n === null ? t : null);
+	return n === null ? { fill: r } : {
+		fill: r,
+		stroke: n
+	};
+}
+//#endregion
+export { c as inkReach, u as pathPaintOf, o as resolveNodeFill, s as resolveNodeStroke, l as withAnimatedVertexColors };
+
+//# sourceMappingURL=nodePaint.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nodePaint.js","names":["paintDrawKindRegistry","bumpNodeMemoGeneration","resolveNodeFill","declared","fill","fallback","resolveNodeStroke","stroke","inkReach","heads","markerReach","sides","headReach","width","world","resolveStrokeWidth","scale","px","withAnimatedVertexColors","resolve","ctx","body","cmds","expected","countPathAnchors","fillChanged","strokeChanged","pathPaintOf","data","DEFAULT_SHAPE_FILL"],"sources":["../../../src/canvas/nodeShapes/nodePaint.ts"],"sourcesContent":["import type { Paint, Stroke, Fill } from '@weasel-js/paint';\nimport type { NodeInk, NodePaintCtx } from 'canvas/NodeShape';\nimport { countPathAnchors } from '@weasel-js/geom';\nimport { markerReach } from '@weasel-js/stroke';\nimport { resolveStrokeWidth } from '@weasel-js/stroke';\nimport type { DrawCommand, PathDrawCommand } from '@weasel-js/renderer';\nimport { paintDrawKindRegistry } from '@weasel-js/renderer';\nimport { bumpNodeMemoGeneration } from 'core/scene/nodeMemo';\nimport { DEFAULT_SHAPE_FILL } from '../../util/paint';\n\n// The painters memoize a node's paint and resolve a fill's frame inside the\n// memo, so the kind set is ambient state that memo cannot see change.\npaintDrawKindRegistry.subscribe(bumpNodeMemoGeneration);\n\n/**\n * What a node's `data.fill` means to the built-in painters.\n *\n * Its {@link Paint} is used as-is — which is how a gradient or a pattern\n * reaches the renderer without a consumer registering a painter of its own.\n * `null` is an explicit \"no fill\", and so is a fill carrying no `paint`;\n * `undefined` takes the painter's fallback. Write the paint with\n * {@link solid} rather than by hand when all you have is a color.\n */\nexport function resolveNodeFill(\n  fill: Fill | null | undefined,\n  fallback: Fill | null,\n): PaintedFill | null {\n  const declared = fill === undefined ? fallback : fill;\n  return declared?.paint == null ? null : (declared as PaintedFill);\n}\n\n/** A fill that paints — what everything downstream of `resolveNodeFill`\n *  works with. */\nexport type PaintedFill = Fill & { paint: Paint };\n\n/** The stroke a built-in painter should emit, or `null` for \"no stroke\".\n *  `data.stroke` is a whole {@link Stroke} — width, cap, join, dash, miter\n *  limit, and align all reach the renderer. {@link strokeOf} builds one from a\n *  color.\n *\n *  A stroke carrying no `paint` reads as no stroke. The type requires `paint`,\n *  but a document is data, and a stroke assembled a field at a time arrives\n *  here without one; painting it throws out of the painter and takes the whole\n *  frame with it. */\nexport function resolveNodeStroke(stroke: Stroke | null | undefined): PaintedStroke | null {\n  if (stroke?.paint == null) return null;\n  return stroke as PaintedStroke;\n}\n\n/** A stroke that paints — what everything downstream of `resolveNodeStroke`\n *  works with. */\nexport type PaintedStroke = Stroke & { paint: Paint };\n\n/** Per-side grab reach for a resolved stroke: world units for what the\n *  renderer builds in world, screen pixels for what it builds on screen — a\n *  `{ px }` width, and each head by its own size's units. */\nexport function inkReach(\n  stroke: Stroke | null,\n  scale: number | undefined,\n): Pick<NodeInk, 'outset' | 'inset' | 'outsetPx' | 'insetPx'> {\n  if (stroke === null) return { outset: 0, inset: 0 };\n  // A marker paints past the path's own end, and the kit's rule is that\n  // visible chrome is hittable — so the reach has to cover it.\n  const heads = markerReach(stroke);\n  const sides = (width: number, headReach: number) => {\n    switch (stroke.align ?? 'center') {\n      case 'inner': return { outset: headReach, inset: width };\n      case 'outer': return { outset: width + headReach, inset: 0 };\n      default: return { outset: width / 2 + headReach, inset: width / 2 };\n    }\n  };\n  const width = stroke.width ?? 1;\n  const world = sides(typeof width === 'object' ? 0 : resolveStrokeWidth(width, scale ?? 1), heads.world);\n  if (typeof width !== 'object' && !(heads.px > 0)) return world;\n  const px = sides(typeof width === 'object' ? width.px : 0, heads.px);\n  return { outset: world.outset, inset: world.inset, outsetPx: px.outset, insetPx: px.inset };\n}\n\n/** Apply {@link NodePaintCtx.vertexColors} to a path painter's body — its first\n *  command. Applied outside the paint memo, whose key\n *  cannot see an override: `cmds` comes back as-is when nothing changes, and\n *  otherwise as a copy, since a memoized list is not ours to edit. Colors whose\n *  length does not match the path's anchors are dropped. */\nexport function withAnimatedVertexColors(cmds: DrawCommand[], ctx: NodePaintCtx | undefined): DrawCommand[] {\n  const resolve = ctx?.vertexColors;\n  const body = cmds[0];\n  if (resolve === undefined || body?.kind !== 'path') return cmds;\n  const expected = 4 * countPathAnchors(body.path);\n  const fill = body.fill ? resolve('fill', body.vertexColors) : undefined;\n  const stroke = body.stroke ? resolve('stroke', body.stroke.vertexColors) : undefined;\n  const fillChanged = fill?.length === expected && fill !== body.vertexColors;\n  const strokeChanged = stroke?.length === expected && stroke !== body.stroke?.vertexColors;\n  if (!fillChanged && !strokeChanged) return cmds;\n  const next: PathDrawCommand = {\n    ...body,\n    ...(fillChanged ? { vertexColors: fill as number[] } : {}),\n    ...(strokeChanged ? { stroke: { ...body.stroke!, vertexColors: stroke as number[] } } : {}),\n  };\n  return [next, ...cmds.slice(1)];\n}\n\n/** The paint a path node wears, resolved: what an action that turns ink into\n *  geometry reads from a node and tells a consumer to put on a result. */\nexport interface PathPaint {\n  /** `null` is no fill. */\n  fill: Fill | null;\n  /** Absent for no stroke. */\n  stroke?: Stroke;\n}\n\n/** {@link PathPaint} of a node that keeps its paint in `data.fill` and\n *  `data.stroke`, as the built-in path painter draws it: a stroke with no\n *  `paint` is none, and an undeclared fill is the default shape fill unless\n *  the node is stroked. */\nexport function pathPaintOf(data: { fill?: Fill | null; stroke?: Stroke | null }): PathPaint {\n  const stroke = resolveNodeStroke(data.stroke);\n  const fill = resolveNodeFill(data.fill, stroke !== null ? null : DEFAULT_SHAPE_FILL);\n  return stroke !== null ? { fill, stroke } : { fill };\n}\n"],"mappings":";;;;;;AAYAA,EAAsB,UAAUC,CAAsB;AAWtD,SAAgBC,EACd,GACA,GACoB;CACpB,IAAMC,IAAWC,MAAS,KAAA,IAAYC,IAAWD;CACjD,OAAOD,GAAU,SAAS,OAAO,OAAQA;AAC3C;AAeA,SAAgBG,EAAkB,GAAyD;CAEzF,OADIC,GAAQ,SAAS,OAAa,OAC3BA;AACT;AASA,SAAgBC,EACd,GACA,GAC4D;CAC5D,IAAID,MAAW,MAAM,OAAO;EAAE,QAAQ;EAAG,OAAO;CAAE;CAGlD,IAAME,IAAQC,EAAYH,CAAM,GAC1BI,KAAS,GAAe,MAAsB;EAClD,QAAQJ,EAAO,SAAS,UAAxB;GACE,KAAK,SAAS,OAAO;IAAE,QAAQK;IAAW,OAAOC;GAAM;GACvD,KAAK,SAAS,OAAO;IAAE,QAAQA,IAAQD;IAAW,OAAO;GAAE;GAC3D,SAAS,OAAO;IAAE,QAAQC,IAAQ,IAAID;IAAW,OAAOC,IAAQ;GAAE;EACpE;CACF,GACMA,IAAQN,EAAO,SAAS,GACxBO,IAAQH,EAAM,OAAOE,KAAU,WAAW,IAAIE,EAAmBF,GAAOG,KAAS,CAAC,GAAGP,EAAM,KAAK;CACtG,IAAI,OAAOI,KAAU,YAAY,EAAEJ,EAAM,KAAK,IAAI,OAAOK;CACzD,IAAMG,IAAKN,EAAM,OAAOE,KAAU,WAAWA,EAAM,KAAK,GAAGJ,EAAM,EAAE;CACnE,OAAO;EAAE,QAAQK,EAAM;EAAQ,OAAOA,EAAM;EAAO,UAAUG,EAAG;EAAQ,SAASA,EAAG;CAAM;AAC5F;AAOA,SAAgBC,EAAyB,GAAqB,GAA8C;CAC1G,IAAMC,IAAUC,GAAK,cACfC,IAAOC,EAAK;CAClB,IAAIH,MAAY,KAAA,KAAaE,GAAM,SAAS,QAAQ,OAAOC;CAC3D,IAAMC,IAAW,IAAIC,EAAiBH,EAAK,IAAI,GACzCjB,IAAOiB,EAAK,OAAOF,EAAQ,QAAQE,EAAK,YAAY,IAAI,KAAA,GACxDd,IAASc,EAAK,SAASF,EAAQ,UAAUE,EAAK,OAAO,YAAY,IAAI,KAAA,GACrEI,IAAcrB,GAAM,WAAWmB,KAAYnB,MAASiB,EAAK,cACzDK,IAAgBnB,GAAQ,WAAWgB,KAAYhB,MAAWc,EAAK,QAAQ;CAO7E,OANI,CAACI,KAAe,CAACC,IAAsBJ,IAMpC,CAAC;EAJN,GAAGD;EACH,GAAII,IAAc,EAAE,cAAcrB,EAAiB,IAAI,CAAC;EACxD,GAAIsB,IAAgB,EAAE,QAAQ;GAAE,GAAGL,EAAK;GAAS,cAAcd;EAAmB,EAAE,IAAI,CAAC;CAEnF,GAAM,GAAGe,EAAK,MAAM,CAAC,CAAC;AAChC;AAeA,SAAgBK,EAAY,GAAiE;CAC3F,IAAMpB,IAASD,EAAkBsB,EAAK,MAAM,GACtCxB,IAAOF,EAAgB0B,EAAK,MAAMrB,MAAW,OAAcsB,IAAP,IAAyB;CACnF,OAAOtB,MAAW,OAA0B,EAAE,QAAK,IAA1B;EAAE;EAAM;CAAO;AAC1C"}

package/dist/canvas/nodeShapes/pathPainter.js

@@ -0,0 +1,39 @@
+import { nodeMemo as e } from "../../core/scene/nodeMemo.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) => 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: t,
+			...s ? { fill: s } : {},
+			...s && e.vertexColors ? { vertexColors: e.vertexColors } : {},
+			...c ? { stroke: c } : {}
+		}];
+	}), 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, i) => {
+		let a = e.data, { fill: o, stroke: s } = r(a);
+		return {
+			filled: o !== null,
+			...n(s ?? null, i?.scale)
+		};
+	},
+	bounds: (e, t, n) => c(t, i(e.data.stroke), n)
+};
+//#endregion
+export { f as PATH_PAINTER };
+
+//# sourceMappingURL=pathPainter.js.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,20 @@
+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(t) {
+	return t === void 0 || e(t);
+}
+function r(n, r, i) {
+	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,
+		width: Math.abs(n.width) + 2 * a,
+		height: Math.abs(n.height) + 2 * a
+	};
+}
+//#endregion
+export { n as paintsPose, r as poseBoxBounds };
+
+//# sourceMappingURL=poseBox.js.map

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

@@ -0,0 +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 '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

@@ -0,0 +1,38 @@
+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) => 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: {
+				kind: "rect",
+				x: o.x,
+				y: o.y,
+				width: o.width,
+				height: o.height
+			},
+			...c ? { fill: c } : {}
+		}];
+	},
+	silhouette: (e, t) => {
+		let n = t;
+		return {
+			kind: "rect",
+			x: n.x,
+			y: n.y,
+			width: n.width,
+			height: n.height
+		};
+	},
+	bounds: (e, t) => r(t, null, void 0)
+};
+//#endregion
+export { a as RECT_FALLBACK_PAINTER };
+
+//# sourceMappingURL=rectFallbackPainter.js.map

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

@@ -0,0 +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 { 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

@@ -0,0 +1,72 @@
+import { nodeMemo as e } from "../../core/scene/nodeMemo.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 (!s(e.pose)) return !1;
+		let t = e.data?.shape;
+		return t != null && h.has(t);
+	},
+	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: n,
+			...c ? { fill: c } : {},
+			...f ? { stroke: f } : {}
+		}];
+	}), c),
+	silhouette: (e, t) => {
+		let n = e.data;
+		return g(n, t);
+	},
+	ink: (e, n, o) => {
+		let s = e.data;
+		return {
+			filled: i(s.fill, t) !== null,
+			...r(a(s.stroke), o?.scale)
+		};
+	},
+	bounds: (e, t, n) => c(t, a(e.data.stroke), n)
+}, h = /* @__PURE__ */ new Set([
+	"rect",
+	"ellipse",
+	"polygon",
+	"star"
+]);
+function g(e, t) {
+	switch (e.shape) {
+		case "ellipse": return d(t);
+		case "polygon": {
+			let n = t.x + t.width / 2, r = t.y + t.height / 2, i = Math.min(t.width, t.height) / 2;
+			return f({
+				x: n,
+				y: r
+			}, i, e.sides ?? 6);
+		}
+		case "star": {
+			let n = t.x + t.width / 2, r = t.y + t.height / 2, i = Math.min(t.width, t.height) / 2;
+			return p({
+				x: n,
+				y: r
+			}, i, e.points ?? 5);
+		}
+		default: return {
+			kind: "rect",
+			x: t.x,
+			y: t.y,
+			width: t.width,
+			height: t.height
+		};
+	}
+}
+//#endregion
+export { h as SHAPE_KINDS, m as SHAPE_PAINTER, g as pathForShape };
+
+//# sourceMappingURL=shapePainter.js.map

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

@@ -0,0 +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 { 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

@@ -0,0 +1,55 @@
+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 "@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
+function u(e, t) {
+	return {
+		x: t.x,
+		y: t.y,
+		width: t.width,
+		height: t.height,
+		text: e.text,
+		runs: e.runs,
+		style: e.style,
+		fill: e.fill,
+		stroke: r(e.stroke) ?? void 0,
+		verticalAlign: e.verticalAlign
+	};
+}
+var d = {
+	id: "kit:text",
+	matches: (e) => i(e.pose) ? e.data?.text != null : !1,
+	paint: (n, r) => e(n, t, r, () => [a(u(n.data, r))]),
+	silhouette: (e, t) => {
+		let n = l(u(e.data, t));
+		return n.length === 0 ? null : f(n);
+	},
+	ink: (e, t, i) => {
+		let a = e.data;
+		return {
+			filled: !0,
+			...n(r(a.stroke), i?.scale)
+		};
+	}
+};
+function f(e) {
+	let t = new Uint8Array(e.length * 6), n = new Float32Array(e.length * 10), r = 0, i = 0;
+	for (let a of e) {
+		let { x: e, y: l, width: u, height: d } = a;
+		t[i++] = s, n[r++] = e, n[r++] = l, t[i++] = o, n[r++] = e + u, n[r++] = l, t[i++] = o, n[r++] = e + u, n[r++] = l + d, t[i++] = o, n[r++] = e, n[r++] = l + d, t[i++] = o, n[r++] = e, n[r++] = l, t[i++] = c;
+	}
+	return {
+		kind: "polygon",
+		commands: t,
+		coords: n,
+		fillRule: "nonzero"
+	};
+}
+//#endregion
+export { d as TEXT_PAINTER, f as rectsToPath, u as textPoseOf };
+
+//# sourceMappingURL=textPainter.js.map

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

@@ -0,0 +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 { 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/overlayRoleStrokes.js.map

@@ -1 +1 @@
-{"version":3,"file":"overlayRoleStrokes.js","names":["OVERLAY_ROLE_STROKES"],"sources":["../../src/canvas/overlayRoleStrokes.ts"],"sourcesContent":["import type { Stroke } 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, Stroke>> = {\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,IAAyD;CACpE,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,20 +1,17 @@
-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 { poseRotationOf as r } from "../core/geometry/poseRotation.js";
-import { rotationMatrixAbout as i } from "./poseRotation.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 a(a, o, s) {
-	let c = o, l = t(o);
-	return (u, d, f = o) => {
-		f !== c && (c = f, l = t(f));
-		let p = a(u, d, f);
-		if (!p) return !1;
-		let m = r(d), h = m ? e.multiply(l, i(m.cx, m.cy, m.rotation)) : l;
-		return n(p, h, s);
+function i(i, a, o) {
+	let s = a, c = r(a);
+	return (l, u, d = a) => {
+		d !== s && (s = d, c = r(d));
+		let f = i(l, u, d);
+		if (!f) return !1;
+		let p = n(u), m = p ? t.multiply(c, t.fromAffine(p)) : c;
+		return e(f, m, o);
 	};
 }
 //#endregion
-export { a as paintMissesView };
+export { i as paintMissesView };
 
 //# sourceMappingURL=paintCull.js.map