@weasel-js/core 1.9.4 → 1.10.1

package/dist/features/paths/anchors.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"anchors.js","names":["pathToAnchors","path","anchors","closed","current","forEachSegment","commands","coords","cmd","PATH_M","ci","PATH_L","PATH_C","prev","PATH_Q","handle","PATH_Z","foldClosingCurve","sub","first","last","anchorsToPath","b","PathBuilder","s","i","cur","c1","c2","SMOOTH_THRESHOLD","isAnchorSmooth","a","inDX","inDY","outDX","outDY","inLen","outLen","cross","countPathAnchors","cmds","n","c","segmentEnds","segIdx","isStraightSegment","nearestOnSegment","p1","p2","hit","nearestOnLine","x","y","nearestOnCubic","nearestSegmentT","bestD2","best","segCount","ends","wx","wy"],"sources":["../../../src/features/paths/anchors.ts"],"sourcesContent":["/**\n * Counts the path anchors used by the per-anchor coloring surface. An\n * \"anchor\" is the destination point of a path command: M, L, C, Q each\n * contribute one (the (x, y) where the pen ends up); Z contributes none\n * (it closes back to the subpath's first M). RectPath has four implicit\n * anchors — the corners — matching its M/L/L/L/Z stroke tessellation.\n *\n * Consumers use this to size their per-anchor color array; the renderer\n * uses it to validate the array length in dev builds.\n */\n\nimport {\n  PATH_C,\n  PATH_L,\n  PATH_M,\n  PATH_Q,\n  PATH_Z,\n  type Path,\n  type PolygonPath,\n  forEachSegment,\n  nearestOnCubic,\n  nearestOnLine,\n  PathBuilder,\n} from '@weasel-js/geom';\n\n/** One anchor of an editable path: its on-curve point plus the two control\n *  handles that shape the segments either side of it. Handles are in the same\n *  space as the point, and absent when the adjoining segment is straight. */\nexport interface PenAnchor {\n  x: number;\n  y: number;\n  inHandle?: { x: number; y: number };\n  outHandle?: { x: number; y: number };\n}\n\n/**\n * Derive a per-subpath anchor model from a PolygonPath. Subpaths split on\n * every `M` command; a subpath is closed iff it ends with `Z`.\n *\n * Cubic-segment control points become the outHandle of the previous anchor\n * and the inHandle of the next anchor. A closed subpath whose last curve ends\n * exactly on its first point holds that point twice; the two are one anchor,\n * and the curve's second control is that anchor's inHandle. Quadratic segments are upgraded to\n * cubics (each control reused for both adjacent handles) — this loses no\n * geometry. Linear segments produce anchors with no handles.\n */\nexport function pathToAnchors(\n  path: PolygonPath,\n): { anchors: PenAnchor[][]; closed: boolean[] } {\n  const { commands, coords } = path;\n  const anchors: PenAnchor[][] = [];\n  const closed: boolean[] = [];\n  let current: PenAnchor[] | null = null;\n\n  forEachSegment(commands, coords, (cmd, ci) => {\n    switch (cmd) {\n      case PATH_M: {\n        if (current) { anchors.push(current); closed.push(false); }\n        current = [{ x: coords[ci], y: coords[ci + 1] }];\n        break;\n      }\n      case PATH_L: {\n        if (!current) throw new Error('pathToAnchors: L without prior M');\n        current.push({ x: coords[ci], y: coords[ci + 1] });\n        break;\n      }\n      case PATH_C: {\n        if (!current) throw new Error('pathToAnchors: C without prior M');\n        const prev = current[current.length - 1];\n        prev.outHandle = { x: coords[ci], y: coords[ci + 1] };\n        current.push({\n          x: coords[ci + 4], y: coords[ci + 5],\n          inHandle: { x: coords[ci + 2], y: coords[ci + 3] },\n        });\n        break;\n      }\n      case PATH_Q: {\n        if (!current) throw new Error('pathToAnchors: Q without prior M');\n        // Quadratic → cubic: handle is the same control point on both sides.\n        const handle = { x: coords[ci], y: coords[ci + 1] };\n        const prev = current[current.length - 1];\n        prev.outHandle = handle;\n        current.push({ x: coords[ci + 2], y: coords[ci + 3], inHandle: { ...handle } });\n        break;\n      }\n      case PATH_Z: {\n        if (current) {\n          foldClosingCurve(current);\n          anchors.push(current);\n          closed.push(true);\n          current = null;\n        }\n        break;\n      }\n      default:\n        throw new Error(`pathToAnchors: unknown command ${cmd}`);\n    }\n  });\n  if (current) { anchors.push(current); closed.push(false); }\n  return { anchors, closed };\n}\n\n/** Merge a closing curve's end anchor into the subpath's first anchor when\n *  the two coincide. */\nfunction foldClosingCurve(sub: PenAnchor[]): void {\n  if (sub.length < 2) return;\n  const first = sub[0];\n  const last = sub[sub.length - 1];\n  if (!last.inHandle || last.x !== first.x || last.y !== first.y) return;\n  sub.pop();\n  first.inHandle = last.inHandle;\n}\n\n/**\n * Serialize the per-subpath anchor model back to a PolygonPath. Inverse of\n * `pathToAnchors`. Curve-vs-line decision per segment:\n *   - Both adjacent handles absent → straight L segment.\n *   - Either handle present → C segment, with missing handles defaulting to\n *     the anchor point itself (degenerate but valid; renders as a near-line).\n */\nexport function anchorsToPath(\n  anchors: PenAnchor[][],\n  closed: boolean[],\n): PolygonPath {\n  const b = new PathBuilder();\n  for (let s = 0; s < anchors.length; s++) {\n    const sub = anchors[s];\n    if (sub.length === 0) continue;\n    b.moveTo(sub[0].x, sub[0].y);\n    for (let i = 1; i < sub.length; i++) {\n      const prev = sub[i - 1];\n      const cur = sub[i];\n      const hasHandle = prev.outHandle != null || cur.inHandle != null;\n      if (!hasHandle) {\n        b.lineTo(cur.x, cur.y);\n      } else {\n        const c1 = prev.outHandle ?? { x: prev.x, y: prev.y };\n        const c2 = cur.inHandle ?? { x: cur.x, y: cur.y };\n        b.curveTo(c1.x, c1.y, c2.x, c2.y, cur.x, cur.y);\n      }\n    }\n    if (closed[s]) {\n      // Bridge last → first if they have curve handles; either way emit Z.\n      const last = sub[sub.length - 1];\n      const first = sub[0];\n      const hasHandle = last.outHandle != null || first.inHandle != null;\n      if (hasHandle) {\n        const c1 = last.outHandle ?? { x: last.x, y: last.y };\n        const c2 = first.inHandle ?? { x: first.x, y: first.y };\n        b.curveTo(c1.x, c1.y, c2.x, c2.y, first.x, first.y);\n      }\n      b.close();\n    }\n  }\n  return b.build();\n}\n\nconst SMOOTH_THRESHOLD = 0.001;\n\n/**\n * Returns true if the anchor's in-handle and out-handle are collinear with\n * the anchor point, indicating \"smooth\" (mirror-drag) behavior. Detected via\n * the magnitude of the normalized cross product of the two handle vectors.\n *\n * Edge cases:\n *   - Missing in or out handle → false (corner by definition).\n *   - Either handle at zero distance from anchor → false.\n */\nexport function isAnchorSmooth(a: PenAnchor): boolean {\n  if (!a.inHandle || !a.outHandle) return false;\n  const inDX = a.inHandle.x - a.x;\n  const inDY = a.inHandle.y - a.y;\n  const outDX = a.outHandle.x - a.x;\n  const outDY = a.outHandle.y - a.y;\n  const inLen = Math.hypot(inDX, inDY);\n  const outLen = Math.hypot(outDX, outDY);\n  if (inLen === 0 || outLen === 0) return false;\n  // For collinear handles on opposite sides of the anchor, the cross product\n  // of the two handle vectors should be zero. Normalize by both magnitudes.\n  const cross = (inDX * outDY - inDY * outDX) / (inLen * outLen);\n  return Math.abs(cross) < SMOOTH_THRESHOLD;\n}\n\n/** How many anchors a path has. Matches the per-anchor arrays the renderer\n *  expects for `vertexColors`. */\nexport function countPathAnchors(path: Path): number {\n  if (path.kind === 'rect') return 4;\n  const cmds = path.commands;\n  let n = 0;\n  for (let i = 0; i < cmds.length; i++) {\n    const c = cmds[i];\n    if (c === PATH_M || c === PATH_L || c === PATH_C || c === PATH_Q) n++;\n  }\n  return n;\n}\n\n/** The segment `(sub, segIdx)` as its two end anchors, or null when it\n *  doesn't exist. `segIdx === sub.length - 1` names a closed subpath's\n *  closing segment, which runs from the last anchor back to the first. */\nexport function segmentEnds(\n  anchors: readonly PenAnchor[][],\n  closed: readonly boolean[] | undefined,\n  sub: number,\n  segIdx: number,\n): { a: PenAnchor; b: PenAnchor } | null {\n  const s = anchors[sub];\n  if (!s || segIdx < 0) return null;\n  if (segIdx + 1 < s.length) return { a: s[segIdx], b: s[segIdx + 1] };\n  if (closed?.[sub] && s.length > 1 && segIdx === s.length - 1) return { a: s[segIdx], b: s[0] };\n  return null;\n}\n\n/** Whether the segment from `a` to `b` is a straight line (no handles). */\nexport function isStraightSegment(a: PenAnchor, b: PenAnchor): boolean {\n  return a.outHandle == null && b.inHandle == null;\n}\n\n/** Nearest parameter on one segment to `(x, y)`, with its squared distance.\n *  A straight segment is parameterized by arc length (`t` is the fraction of\n *  the way from `a` to `b`), matching how {@link insertAnchorOnSegment}\n *  splits one. */\nfunction nearestOnSegment(a: PenAnchor, b: PenAnchor, x: number, y: number): { t: number; d2: number } {\n  const p1 = a.outHandle ?? a;\n  const p2 = b.inHandle ?? b;\n  const hit = isStraightSegment(a, b)\n    ? nearestOnLine(x, y, a.x, a.y, b.x, b.y)\n    : nearestOnCubic(x, y, a.x, a.y, p1.x, p1.y, p2.x, p2.y, b.x, b.y);\n  return { t: hit.t, d2: hit.dist * hit.dist };\n}\n\n/** The segment of a decoded path nearest `(wx, wy)`, and the parameter `t`\n *  on it closest to that point. Pass `closed` (from `pathToAnchors`) to\n *  include each closed subpath's closing segment, reported as\n *  `segIdx === sub.length - 1`. `t` spans `[0, 1]`, endpoints included.\n *  Returns `null` only when there are no segments. */\nexport function nearestSegmentT(\n  anchors: PenAnchor[][],\n  wx: number,\n  wy: number,\n  closed?: readonly boolean[],\n): { sub: number; segIdx: number; t: number } | null {\n  let bestD2 = Infinity;\n  let best: { sub: number; segIdx: number; t: number } | null = null;\n  for (let s = 0; s < anchors.length; s++) {\n    const segCount = anchors[s].length - (closed?.[s] ? 0 : 1);\n    for (let i = 0; i < segCount; i++) {\n      const ends = segmentEnds(anchors, closed, s, i);\n      if (!ends) continue;\n      const hit = nearestOnSegment(ends.a, ends.b, wx, wy);\n      if (hit.d2 < bestD2) {\n        bestD2 = hit.d2;\n        best = { sub: s, segIdx: i, t: hit.t };\n      }\n    }\n  }\n  return best;\n}\n"],"mappings":"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"}

package/dist/features/paths/booleans.js

@@ -1,2 +0,0 @@
-import { pathCrop as e, pathDivide as t, pathExclude as n, pathIntersect as r, pathSubtract as i, pathUnion as a, trianglesToPath as o } from "@weasel-js/geom/booleans";
-export { e as pathCrop, t as pathDivide, n as pathExclude, r as pathIntersect, i as pathSubtract, a as pathUnion, o as trianglesToPath };

package/dist/features/paths/markerCommands.js

@@ -1,149 +0,0 @@
-import { coordsOutOfMetric as e, polylineIntoMetric as t } from "./tessellate/metric.js";
-import { getMarker as n } from "../../core/strokeMarkers.js";
-import { markerKeyOf as r, resolveMarkerSize as i } from "../../core/markerInset.js";
-import { markerSites as a } from "./markerSites.js";
-import { commandFill as o } from "../patterns/commandPaint.js";
-import { boundsOfPath as s } from "@weasel-js/geom";
-import { extractPolylines as c } from "@weasel-js/geom/tessellate";
-//#region src/features/paths/markerCommands.ts
-function l(e, t) {
-	let n = e, r = Math.cos(t.angle), i = Math.sin(t.angle), a = new Float32Array(n.coords.length);
-	for (let e = 0; e < n.coords.length; e += 2) {
-		let o = n.coords[e], s = n.coords[e + 1];
-		a[e] = t.x + o * r - s * i, a[e + 1] = t.y + o * i + s * r;
-	}
-	return {
-		kind: "polygon",
-		commands: n.commands,
-		coords: a,
-		fillRule: n.fillRule
-	};
-}
-function u(e, t, n, r) {
-	let i = e ?? n;
-	if (i !== "none") return i === "line" ? t.paint : o(i, s(r)) ?? void 0;
-}
-function d(o, s, u, d, f = {}) {
-	let p = {
-		start: s.markerStart,
-		mid: s.markerMid,
-		end: s.markerEnd
-	};
-	if (p.start === void 0 && p.mid === void 0 && p.end === void 0) return [];
-	let m = /* @__PURE__ */ new Map();
-	for (let e of [
-		"start",
-		"mid",
-		"end"
-	]) {
-		if (p[e] === void 0) continue;
-		let t = f[e], n = m.get(t);
-		n === void 0 && m.set(t, n = {
-			start: !1,
-			mid: !1,
-			end: !1
-		}), n[e] = !0;
-	}
-	let h = [];
-	for (let f of c(o, { flattenTolerance: d })) for (let [o, c] of m) {
-		let d = o ? {
-			...f,
-			points: f.points.slice()
-		} : f;
-		o && t(d, o.metric);
-		for (let t of a(d, c)) {
-			let a = p[t.role];
-			if (a === void 0) continue;
-			let c = n(r(a));
-			if (c === void 0) continue;
-			let d = i(a, u), f = c.orient === void 0 || c.orient === "auto" ? t.angle : c.orient, m = l(c.path({
-				size: d,
-				stroke: s
-			}), {
-				...t,
-				angle: f
-			});
-			o && e(m.coords, o.metric), h.push(o ? {
-				entry: c,
-				size: d,
-				path: m,
-				space: o
-			} : {
-				entry: c,
-				size: d,
-				path: m
-			});
-		}
-	}
-	return h;
-}
-function f(e, t) {
-	let n = [];
-	for (let { entry: r, path: i, size: a, space: o } of e) {
-		let e = u(r.fill, t, "line", i), s = r.outline ? r.outline.width * a : 0, c = r.outline ? {
-			paint: u(r.outline.paint, t, "line", i),
-			width: o ? { px: s * o.pxPerUnit } : s
-		} : null;
-		(e !== void 0 || c !== null && c.paint !== void 0) && n.push({
-			kind: "path",
-			path: i,
-			...e ? { fill: e } : {},
-			...c && c.paint ? { stroke: {
-				paint: c.paint,
-				width: c.width,
-				cap: "round",
-				join: "round"
-			} } : {}
-		});
-	}
-	return n;
-}
-function p(e, t) {
-	if (e.reads === void 0) return null;
-	let n = "";
-	for (let r of e.reads) n += `${JSON.stringify(t[r]) ?? ""}|`;
-	return n;
-}
-var m = 64, h = /* @__PURE__ */ new WeakMap(), g = /* @__PURE__ */ new WeakMap();
-function _(e, t) {
-	let n = s(e.path({
-		size: 1,
-		stroke: t
-	}));
-	return Math.max(Math.abs(n.x), Math.abs(n.x + n.width), Math.abs(n.y), Math.abs(n.y + n.height)) + (e.outline ? e.outline.width / 2 : 0);
-}
-function v(e, t) {
-	let n = p(e, t);
-	if (n === null) {
-		let n = g.get(e);
-		n === void 0 && g.set(e, n = /* @__PURE__ */ new WeakMap());
-		let r = n.get(t);
-		return r === void 0 && n.set(t, r = _(e, t)), r;
-	}
-	let r = h.get(e);
-	r === void 0 && h.set(e, r = /* @__PURE__ */ new Map());
-	let i = r.get(n);
-	return i === void 0 && (r.size >= m && r.clear(), r.set(n, i = _(e, t))), i;
-}
-function y(e) {
-	let t = {
-		world: 0,
-		px: 0
-	}, i = e.width ?? 1;
-	for (let a of [
-		e.markerStart,
-		e.markerMid,
-		e.markerEnd
-	]) {
-		if (a === void 0) continue;
-		let o = n(r(a));
-		if (o === void 0) continue;
-		let s = typeof a == "string" || a.size === void 0 ? i : a.size, c = v(o, e);
-		typeof s == "number" ? t.world = Math.max(t.world, c * s) : t.px = Math.max(t.px, c * s.px);
-	}
-	return t;
-}
-//#endregion
-export { f as headCommands, d as markerHeads, y as markerReach, p as markerReadsKey };
-
-//# sourceMappingURL=markerCommands.js.map

package/dist/features/paths/markerCommands.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"markerCommands.js","names":["placed","src","path","cos","site","sin","coords","i","x","y","resolvePaint","v","p","fallback","stroke","commandFill","boundsOfPath","head","markerHeads","refs","groups","role","space","spaces","want","out","pl","extractPolylines","inSpace","polylineIntoMetric","markerSites","ref","entry","getMarker","markerKeyOf","size","resolveMarkerSize","strokeWidth","angle","coordsOutOfMetric","headCommands","heads","fill","width","outline","markerReadsKey","key","field","READINGS_PER_ENTRY","REACH_BY_READING","REACH_BY_STROKE","measureUnitReach","b","unitReach","byStroke","reach","byReading","markerReach","unit"],"sources":["../../../src/features/paths/markerCommands.ts"],"sourcesContent":["/**\n * Turning a stroke's markers into draw commands.\n *\n * Separate `PathDrawCommand`s rather than triangles appended to the stroke\n * ribbon: an entry may carry a fill and an outline at once, or a paint that\n * differs from the line's, neither of which one mesh can express — and folding\n * them in would drag the whole marker vocabulary into the ribbon cache key.\n */\n\nimport type { CommandFill, CommandStroke, MarkerRef, Stroke } from '@weasel-js/paint';\nimport { type Path, type PolygonPath, boundsOfPath } from '@weasel-js/geom';\nimport type { PathDrawCommand } from '../../renderer/DrawCommand';\nimport { getMarker, type MarkerEntry, type MarkerPaint } from '../../core/strokeMarkers';\nimport { markerKeyOf, resolveMarkerSize } from '../../core/markerInset';\nimport { extractPolylines } from '@weasel-js/geom/tessellate';\nimport { markerSites, type MarkerSite } from './markerSites';\nimport { commandFill } from '../patterns/commandPaint';\nimport {\n  coordsOutOfMetric, polylineIntoMetric, type ScreenSpace, type StrokeSpaces,\n} from './tessellate/metric';\n\n/** Rotate + translate a marker's geometry onto its site. */\nfunction placed(path: Path, site: MarkerSite): PolygonPath {\n  const src = path as PolygonPath;\n  const cos = Math.cos(site.angle);\n  const sin = Math.sin(site.angle);\n  const coords = new Float32Array(src.coords.length);\n  for (let i = 0; i < src.coords.length; i += 2) {\n    const x = src.coords[i], y = src.coords[i + 1];\n    coords[i] = site.x + x * cos - y * sin;\n    coords[i + 1] = site.y + x * sin + y * cos;\n  }\n  return { kind: 'polygon', commands: src.commands, coords, fillRule: src.fillRule };\n}\n\n/** A marker's own paint is resolved against its head's box, as a node's is\n *  against the node's. */\nfunction resolvePaint(\n  p: MarkerPaint | undefined, stroke: CommandStroke, fallback: MarkerPaint, head: PolygonPath,\n): CommandFill | undefined {\n  const v = p ?? fallback;\n  if (v === 'none') return undefined;\n  if (v === 'line') return stroke.paint;\n  return commandFill(v, boundsOfPath(head)) ?? undefined;\n}\n\n/** One head's placed geometry, before any paint is applied. */\nexport interface MarkerHead {\n  readonly entry: MarkerEntry;\n  readonly path: PolygonPath;\n  readonly size: number;\n  /** Where it was built, when not in world — `size` is in this space's units. */\n  readonly space?: ScreenSpace;\n}\n\n/**\n * Every marker head for `path` under `stroke`, placed but unpainted.\n * `strokeWidth` is the already width-resolved stroke width; `flattenTolerance`\n * matches what the ribbon used, so heads land on the same flattened vertices\n * the stroke did. A head `spaces` puts in a screen space is placed and sized\n * there and comes back in world units, so it meets the line it caps.\n */\nexport function markerHeads(\n  path: Path,\n  stroke: Stroke,\n  strokeWidth: number,\n  flattenTolerance: number | undefined,\n  spaces: StrokeSpaces = {},\n): MarkerHead[] {\n  const refs = { start: stroke.markerStart, mid: stroke.markerMid, end: stroke.markerEnd };\n  if (refs.start === undefined && refs.mid === undefined && refs.end === undefined) return [];\n\n  // Heads sharing a space share one pass over the polyline mapped into it.\n  const groups = new Map<ScreenSpace | undefined, { start: boolean; mid: boolean; end: boolean }>();\n  for (const role of ['start', 'mid', 'end'] as const) {\n    if (refs[role] === undefined) continue;\n    const space = spaces[role];\n    let want = groups.get(space);\n    if (want === undefined) groups.set(space, (want = { start: false, mid: false, end: false }));\n    want[role] = true;\n  }\n\n  const out: MarkerHead[] = [];\n  for (const pl of extractPolylines(path, { flattenTolerance })) {\n    for (const [space, want] of groups) {\n      const inSpace = space ? { ...pl, points: pl.points.slice() } : pl;\n      if (space) polylineIntoMetric(inSpace, space.metric);\n      for (const site of markerSites(inSpace, want)) {\n        const ref: MarkerRef | undefined = refs[site.role];\n        if (ref === undefined) continue;\n        const entry = getMarker(markerKeyOf(ref));\n        if (entry === undefined) continue;\n        const size = resolveMarkerSize(ref, strokeWidth);\n        const angle = entry.orient === undefined || entry.orient === 'auto' ? site.angle : entry.orient;\n        const head = placed(entry.path({ size, stroke }), { ...site, angle });\n        if (space) coordsOutOfMetric(head.coords, space.metric);\n        out.push(space ? { entry, size, path: head, space } : { entry, size, path: head });\n      }\n    }\n  }\n  return out;\n}\n\n/** `heads` as draw commands in `stroke`'s paint. A head whose fill and outline\n *  both resolve to no paint is dropped. */\nexport function headCommands(heads: readonly MarkerHead[], stroke: CommandStroke): PathDrawCommand[] {\n  const out: PathDrawCommand[] = [];\n  for (const { entry, path, size, space } of heads) {\n    const fill = resolvePaint(entry.fill, stroke, 'line', path);\n    // A head built in a screen space is in world once placed, but its outline\n    // width is still in that space's units — so it goes out as the screen\n    // width it stands for, and is stroked as exactly as the line.\n    const width = entry.outline ? entry.outline.width * size : 0;\n    const outline = entry.outline\n      ? { paint: resolvePaint(entry.outline.paint, stroke, 'line', path), width: space ? { px: width * space.pxPerUnit } : width }\n      : null;\n    if (fill === undefined && (outline === null || outline.paint === undefined)) continue;\n    out.push({\n      kind: 'path',\n      path,\n      ...(fill ? { fill } : {}),\n      ...(outline && outline.paint\n        ? { stroke: { paint: outline.paint, width: outline.width, cap: 'round', join: 'round' } }\n        : {}),\n    });\n  }\n  return out;\n}\n\n/** Every marker command for `path` under `stroke`; see {@link markerHeads}. */\nexport function markerDrawCommands(\n  path: Path,\n  stroke: CommandStroke,\n  strokeWidth: number,\n  flattenTolerance: number | undefined,\n): PathDrawCommand[] {\n  return headCommands(markerHeads(path, stroke, strokeWidth, flattenTolerance), stroke);\n}\n\n/**\n * A key for the stroke fields `entry`'s geometry reads, or `null` when the\n * entry does not say which it reads and only the stroke's identity can stand\n * in for them.\n */\nexport function markerReadsKey(entry: MarkerEntry, stroke: Stroke): string | null {\n  if (entry.reads === undefined) return null;\n  let key = '';\n  for (const field of entry.reads) key += `${JSON.stringify(stroke[field]) ?? ''}|`;\n  return key;\n}\n\n/** Distinct stroke readings kept per entry before its map is dropped. */\nconst READINGS_PER_ENTRY = 64;\n\n/** Each entry's farthest reach from its anchor at `size` 1, outline included,\n *  per value of the fields it reads — or per stroke object, when it does not\n *  say which. */\nconst REACH_BY_READING = new WeakMap<MarkerEntry, Map<string, number>>();\nconst REACH_BY_STROKE = new WeakMap<MarkerEntry, WeakMap<Stroke, number>>();\n\nfunction measureUnitReach(entry: MarkerEntry, stroke: Stroke): number {\n  const b = boundsOfPath(entry.path({ size: 1, stroke }));\n  return Math.max(Math.abs(b.x), Math.abs(b.x + b.width), Math.abs(b.y), Math.abs(b.y + b.height))\n    + (entry.outline ? entry.outline.width / 2 : 0);\n}\n\nfunction unitReach(entry: MarkerEntry, stroke: Stroke): number {\n  const key = markerReadsKey(entry, stroke);\n  if (key === null) {\n    let byStroke = REACH_BY_STROKE.get(entry);\n    if (byStroke === undefined) REACH_BY_STROKE.set(entry, (byStroke = new WeakMap()));\n    let reach = byStroke.get(stroke);\n    if (reach === undefined) byStroke.set(stroke, (reach = measureUnitReach(entry, stroke)));\n    return reach;\n  }\n  let byReading = REACH_BY_READING.get(entry);\n  if (byReading === undefined) REACH_BY_READING.set(entry, (byReading = new Map()));\n  let reach = byReading.get(key);\n  if (reach === undefined) {\n    if (byReading.size >= READINGS_PER_ENTRY) byReading.clear();\n    byReading.set(key, (reach = measureUnitReach(entry, stroke)));\n  }\n  return reach;\n}\n\n/**\n * How far `stroke`'s markers can paint from the vertex each sits on, split by\n * where each is built: `world` in world units for a head with a world size,\n * `px` in screen pixels for one with a `{ px }` size. A head with no size\n * takes the stroke width, and with it the width's units. Culling and a path\n * node's grab reach both measure through here.\n */\nexport function markerReach(stroke: Stroke): { world: number; px: number } {\n  const reach = { world: 0, px: 0 };\n  const width = stroke.width ?? 1;\n  for (const ref of [stroke.markerStart, stroke.markerMid, stroke.markerEnd]) {\n    if (ref === undefined) continue;\n    const entry = getMarker(markerKeyOf(ref));\n    if (entry === undefined) continue;\n    const size = typeof ref === 'string' || ref.size === undefined ? width : ref.size;\n    const unit = unitReach(entry, stroke);\n    if (typeof size === 'number') reach.world = Math.max(reach.world, unit * size);\n    else reach.px = Math.max(reach.px, unit * size.px);\n  }\n  return reach;\n}\n"],"mappings":"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"}

package/dist/features/paths/markerSites.js

@@ -1,59 +0,0 @@
-//#region src/features/paths/markerSites.ts
-var e = 1e-9;
-function t(t, n, r) {
-	let i = t.points[r * 2] - t.points[n * 2], a = t.points[r * 2 + 1] - t.points[n * 2 + 1], o = Math.hypot(i, a);
-	return o < e ? null : {
-		x: i / o,
-		y: a / o
-	};
-}
-function n(e, n, r) {
-	for (let i = n + 1; i < r; i++) if (t(e, n, i)) return i;
-	return -1;
-}
-function r(e, n) {
-	for (let r = n - 1; r >= 0; r--) if (t(e, r, n)) return r;
-	return -1;
-}
-function i(i, a) {
-	let o = [], s = i.points.length / 2;
-	if (s < 2) return o;
-	if (a.start && !i.closed) {
-		let e = n(i, 0, s), r = e >= 0 ? t(i, 0, e) : null;
-		r && o.push({
-			x: i.points[0],
-			y: i.points[1],
-			angle: Math.atan2(-r.y, -r.x),
-			role: "start"
-		});
-	}
-	if (a.mid) {
-		let a = i.anchorA, c = i.anchorB, l = i.anchorT;
-		if (a && c && l) for (let u = 1; u < s - 1; u++) {
-			if (a[u] !== c[u] || l[u] !== 0) continue;
-			let d = r(i, u), f = n(i, u, s);
-			if (d < 0 || f < 0) continue;
-			let p = t(i, d, u), m = t(i, u, f), h = p.x + m.x, g = p.y + m.y;
-			Math.hypot(h, g) < e && (h = p.x, g = p.y), o.push({
-				x: i.points[u * 2],
-				y: i.points[u * 2 + 1],
-				angle: Math.atan2(g, h),
-				role: "mid"
-			});
-		}
-	}
-	if (a.end && !i.closed) {
-		let e = s - 1, n = r(i, e), a = n >= 0 ? t(i, n, e) : null;
-		a && o.push({
-			x: i.points[e * 2],
-			y: i.points[e * 2 + 1],
-			angle: Math.atan2(a.y, a.x),
-			role: "end"
-		});
-	}
-	return o;
-}
-//#endregion
-export { i as markerSites };
-
-//# sourceMappingURL=markerSites.js.map

package/dist/features/paths/markerSites.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"markerSites.js","names":["EPS","dir","dx","pl","j","i","dy","len","nextDistinct","k","n","prevDistinct","markerSites","out","want","d","A","B","T","p","q","inDir","outDir","bx","by","last"],"sources":["../../../src/features/paths/markerSites.ts"],"sourcesContent":["/**\n * Where a stroke's markers sit and which way they point.\n *\n * Computed from the *untrimmed* polyline: trimming moves the endpoint, and a\n * marker anchors to where the line was authored to end, not to where the\n * ribbon was cut.\n */\n\nimport type { Polyline } from '@weasel-js/geom/tessellate';\n\n/** One marker placement, in the polyline's own coordinates. */\nexport interface MarkerSite {\n  x: number;\n  y: number;\n  /** Radians. The direction the marker's +X axis should point — outward at a\n   *  start or end, along the bisector at an interior vertex. */\n  angle: number;\n  role: 'start' | 'mid' | 'end';\n}\n\n/** Which marker roles to place. `start` and `end` are ignored on a closed polyline. */\nexport interface MarkerSiteRequest {\n  start: boolean;\n  mid: boolean;\n  end: boolean;\n}\n\nconst EPS = 1e-9;\n\n/** Unit direction from point `i` to point `j`, or null if they coincide. */\nfunction dir(pl: Polyline, i: number, j: number): { x: number; y: number } | null {\n  const dx = pl.points[j * 2] - pl.points[i * 2];\n  const dy = pl.points[j * 2 + 1] - pl.points[i * 2 + 1];\n  const len = Math.hypot(dx, dy);\n  if (len < EPS) return null;\n  return { x: dx / len, y: dy / len };\n}\n\n/** The first index after `i` whose point differs from `i`'s. */\nfunction nextDistinct(pl: Polyline, i: number, n: number): number {\n  for (let k = i + 1; k < n; k++) if (dir(pl, i, k)) return k;\n  return -1;\n}\nfunction prevDistinct(pl: Polyline, i: number): number {\n  for (let k = i - 1; k >= 0; k--) if (dir(pl, k, i)) return k;\n  return -1;\n}\n\n/**\n * Where each requested marker sits on `pl` and the angle it points at.\n * Mid sites fall only on authored vertices, never on flattened curve samples,\n * and need the polyline to carry anchor data; without it no mid sites are returned.\n */\nexport function markerSites(pl: Polyline, want: MarkerSiteRequest): MarkerSite[] {\n  const out: MarkerSite[] = [];\n  const n = pl.points.length / 2;\n  if (n < 2) return out;\n\n  if (want.start && !pl.closed) {\n    const j = nextDistinct(pl, 0, n);\n    const d = j >= 0 ? dir(pl, 0, j) : null;\n    if (d) {\n      // Reversed, so a start head points away from the line body the way an\n      // end head does. SVG spells this `auto-start-reverse`; here it is the\n      // only behavior.\n      out.push({ x: pl.points[0], y: pl.points[1], angle: Math.atan2(-d.y, -d.x), role: 'start' });\n    }\n  }\n\n  if (want.mid) {\n    const A = pl.anchorA, B = pl.anchorB, T = pl.anchorT;\n    if (A && B && T) {\n      for (let i = 1; i < n - 1; i++) {\n        // An authored anchor, not a flattened curve sample.\n        if (A[i] !== B[i] || T[i] !== 0) continue;\n        const p = prevDistinct(pl, i);\n        const q = nextDistinct(pl, i, n);\n        if (p < 0 || q < 0) continue;\n        const inDir = dir(pl, p, i)!;\n        const outDir = dir(pl, i, q)!;\n        let bx = inDir.x + outDir.x;\n        let by = inDir.y + outDir.y;\n        // A 180° reversal leaves no bisector; fall back to the arriving direction.\n        if (Math.hypot(bx, by) < EPS) { bx = inDir.x; by = inDir.y; }\n        out.push({ x: pl.points[i * 2], y: pl.points[i * 2 + 1], angle: Math.atan2(by, bx), role: 'mid' });\n      }\n    }\n  }\n\n  if (want.end && !pl.closed) {\n    const last = n - 1;\n    const p = prevDistinct(pl, last);\n    const d = p >= 0 ? dir(pl, p, last) : null;\n    if (d) {\n      out.push({ x: pl.points[last * 2], y: pl.points[last * 2 + 1], angle: Math.atan2(d.y, d.x), role: 'end' });\n    }\n  }\n\n  return out;\n}\n"],"mappings":";AA2BA,IAAMA,IAAM;AAGZ,SAASC,EAAI,GAAc,GAAW,GAA4C;CAChF,IAAMC,IAAKC,EAAG,OAAOC,IAAI,KAAKD,EAAG,OAAOE,IAAI,IACtCC,IAAKH,EAAG,OAAOC,IAAI,IAAI,KAAKD,EAAG,OAAOE,IAAI,IAAI,IAC9CE,IAAM,KAAK,MAAML,GAAII,CAAE;CAE7B,OADIC,IAAMP,IAAY,OACf;EAAE,GAAGE,IAAKK;EAAK,GAAGD,IAAKC;CAAI;AACpC;AAGA,SAASC,EAAa,GAAc,GAAW,GAAmB;CAChE,KAAK,IAAIC,IAAIJ,IAAI,GAAGI,IAAIC,GAAG,KAAK,IAAIT,EAAIE,GAAIE,GAAGI,CAAC,GAAG,OAAOA;CAC1D,OAAO;AACT;AACA,SAASE,EAAa,GAAc,GAAmB;CACrD,KAAK,IAAIF,IAAIJ,IAAI,GAAGI,KAAK,GAAG,KAAK,IAAIR,EAAIE,GAAIM,GAAGJ,CAAC,GAAG,OAAOI;CAC3D,OAAO;AACT;AAOA,SAAgBG,EAAY,GAAc,GAAuC;CAC/E,IAAMC,IAAoB,CAAC,GACrBH,IAAIP,EAAG,OAAO,SAAS;CAC7B,IAAIO,IAAI,GAAG,OAAOG;CAElB,IAAIC,EAAK,SAAS,CAACX,EAAG,QAAQ;EAC5B,IAAMC,IAAII,EAAaL,GAAI,GAAGO,CAAC,GACzBK,IAAIX,KAAK,IAAIH,EAAIE,GAAI,GAAGC,CAAC,IAAI;EACnC,AAAIW,KAIFF,EAAI,KAAK;GAAE,GAAGV,EAAG,OAAO;GAAI,GAAGA,EAAG,OAAO;GAAI,OAAO,KAAK,MAAM,CAACY,EAAE,GAAG,CAACA,EAAE,CAAC;GAAG,MAAM;EAAQ,CAAC;CAE/F;CAEA,IAAID,EAAK,KAAK;EACZ,IAAME,IAAIb,EAAG,SAASc,IAAId,EAAG,SAASe,IAAIf,EAAG;EAC7C,IAAIa,KAAKC,KAAKC,GACZ,KAAK,IAAIb,IAAI,GAAGA,IAAIK,IAAI,GAAG,KAAK;GAE9B,IAAIM,EAAEX,OAAOY,EAAEZ,MAAMa,EAAEb,OAAO,GAAG;GACjC,IAAMc,IAAIR,EAAaR,GAAIE,CAAC,GACtBe,IAAIZ,EAAaL,GAAIE,GAAGK,CAAC;GAC/B,IAAIS,IAAI,KAAKC,IAAI,GAAG;GACpB,IAAMC,IAAQpB,EAAIE,GAAIgB,GAAGd,CAAC,GACpBiB,IAASrB,EAAIE,GAAIE,GAAGe,CAAC,GACvBG,IAAKF,EAAM,IAAIC,EAAO,GACtBE,IAAKH,EAAM,IAAIC,EAAO;GAG1B,AADI,KAAK,MAAMC,GAAIC,CAAE,IAAIxB,MAAO,IAAKqB,EAAM,GAAG,IAAKA,EAAM,IACzDR,EAAI,KAAK;IAAE,GAAGV,EAAG,OAAOE,IAAI;IAAI,GAAGF,EAAG,OAAOE,IAAI,IAAI;IAAI,OAAO,KAAK,MAAMmB,GAAID,CAAE;IAAG,MAAM;GAAM,CAAC;EACnG;CAEJ;CAEA,IAAIT,EAAK,OAAO,CAACX,EAAG,QAAQ;EAC1B,IAAMsB,IAAOf,IAAI,GACXS,IAAIR,EAAaR,GAAIsB,CAAI,GACzBV,IAAII,KAAK,IAAIlB,EAAIE,GAAIgB,GAAGM,CAAI,IAAI;EACtC,AAAIV,KACFF,EAAI,KAAK;GAAE,GAAGV,EAAG,OAAOsB,IAAO;GAAI,GAAGtB,EAAG,OAAOsB,IAAO,IAAI;GAAI,OAAO,KAAK,MAAMV,EAAE,GAAGA,EAAE,CAAC;GAAG,MAAM;EAAM,CAAC;CAE7G;CAEA,OAAOF;AACT"}

package/dist/features/paths/markers.js

@@ -1,95 +0,0 @@
-import { PATH_L as e, PATH_M as t, PATH_Z as n, rectToContour as r } from "@weasel-js/geom";
-//#region src/features/paths/markers.ts
-function i(r, i, a, o = 32) {
-	let s = new Uint8Array(o + 1), c = new Float32Array(o * 2);
-	s[0] = t, c[0] = r + a, c[1] = i;
-	for (let t = 1; t < o; t++) {
-		s[t] = e;
-		let n = t / o * Math.PI * 2;
-		c[t * 2] = r + a * Math.cos(n), c[t * 2 + 1] = i + a * Math.sin(n);
-	}
-	return s[o] = n, {
-		kind: "polygon",
-		commands: s,
-		coords: c,
-		fillRule: "nonzero"
-	};
-}
-function a(r, i, a) {
-	let o = a / 2, s = r - o, c = i - o, l = r + o, u = i + o;
-	return {
-		kind: "polygon",
-		commands: new Uint8Array([
-			t,
-			e,
-			e,
-			e,
-			n
-		]),
-		coords: new Float32Array([
-			s,
-			c,
-			l,
-			c,
-			l,
-			u,
-			s,
-			u
-		]),
-		fillRule: "nonzero"
-	};
-}
-function o(i, a, o, s) {
-	return {
-		kind: "polygon",
-		commands: new Uint8Array([
-			t,
-			e,
-			e,
-			e,
-			n
-		]),
-		coords: Float32Array.from(r(i, a, o, s)),
-		fillRule: "nonzero"
-	};
-}
-function s(r, i, a, s, c, l = 8) {
-	let u = Math.max(0, Math.min(c, Math.min(a, s) / 2));
-	if (u === 0) return o(r, i, a, s);
-	let d = Math.PI / 2, f = [
-		[
-			r + u,
-			i + u,
-			Math.PI
-		],
-		[
-			r + a - u,
-			i + u,
-			-d
-		],
-		[
-			r + a - u,
-			i + s - u,
-			0
-		],
-		[
-			r + u,
-			i + s - u,
-			d
-		]
-	], p = l + 1, m = f.length * p, h = new Uint8Array(m + 1), g = new Float32Array(m * 2), _ = 0;
-	for (let [n, r, i] of f) for (let a = 0; a <= l; a++) {
-		let o = i + a / l * d;
-		h[_] = _ === 0 ? t : e, g[_ * 2] = n + u * Math.cos(o), g[_ * 2 + 1] = r + u * Math.sin(o), _++;
-	}
-	return h[m] = n, {
-		kind: "polygon",
-		commands: h,
-		coords: g,
-		fillRule: "nonzero"
-	};
-}
-//#endregion
-export { i as circlePath, o as rectMarkerPath, s as roundRectPath, a as squarePath };
-
-//# sourceMappingURL=markers.js.map

package/dist/features/paths/markers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"markers.js","names":["circlePath","cmds","segments","coords","PATH_M","cx","r","cy","i","PATH_L","theta","PATH_Z","squarePath","half","size","x0","y0","x1","y1","rectMarkerPath","rectToContour","x","y","width","height","roundRectPath","radius","HALF_PI","corners","perCorner","cornerSamples","count","start","s"],"sources":["../../../src/features/paths/markers.ts"],"sourcesContent":["/**\n * Ergonomic builders for tiny shape paths used by chrome / overlays / markers.\n *\n * These don't expand the `DrawCommand` union — they all return `PolygonPath`,\n * which `PathDrawCommand.path` already accepts. The wins are:\n *   - One place owns the math (`circlePath`'s segment loop, `squarePath`'s\n *     corner unrolling), so consumers don't reinvent it.\n *   - Default segment counts can be tuned in one place if \"circles look\n *     facety\" feedback ever surfaces.\n *\n * Not appropriate for *user-drawn* shapes (those have a pose and live in the\n * scene). Use these for selection chrome, anchor markers, rubber-band rects,\n * and similar transient/decorative geometry.\n */\n\nimport { PATH_L, PATH_M, PATH_Z, type PolygonPath, rectToContour } from '@weasel-js/geom';\n\n/**\n * N-segment polygon approximation of a circle. Default 32 segments → max\n * radial deviation of ≈0.005·r (≈0.05 px at r=10). Bump higher for large\n * filled circles where the facets become visible; the default is fine for\n * the handle-dot / anchor-dot scale we use everywhere.\n */\nexport function circlePath(cx: number, cy: number, r: number, segments = 32): PolygonPath {\n  const cmds = new Uint8Array(segments + 1);\n  const coords = new Float32Array(segments * 2);\n  cmds[0] = PATH_M;\n  coords[0] = cx + r;\n  coords[1] = cy;\n  for (let i = 1; i < segments; i++) {\n    cmds[i] = PATH_L;\n    const theta = (i / segments) * Math.PI * 2;\n    coords[i * 2] = cx + r * Math.cos(theta);\n    coords[i * 2 + 1] = cy + r * Math.sin(theta);\n  }\n  cmds[segments] = PATH_Z;\n  return { kind: 'polygon', commands: cmds, coords, fillRule: 'nonzero' };\n}\n\n/** Axis-aligned square centred at (cx, cy) with side length `size`. */\nexport function squarePath(cx: number, cy: number, size: number): PolygonPath {\n  const half = size / 2;\n  const x0 = cx - half, y0 = cy - half;\n  const x1 = cx + half, y1 = cy + half;\n  return {\n    kind: 'polygon',\n    commands: new Uint8Array([PATH_M, PATH_L, PATH_L, PATH_L, PATH_Z]),\n    coords: new Float32Array([x0, y0, x1, y0, x1, y1, x0, y1]),\n    fillRule: 'nonzero',\n  };\n}\n\n/** Axis-aligned rectangle. Top-left at (x, y), width/height as given. */\nexport function rectMarkerPath(x: number, y: number, width: number, height: number): PolygonPath {\n  return {\n    kind: 'polygon',\n    commands: new Uint8Array([PATH_M, PATH_L, PATH_L, PATH_L, PATH_Z]),\n    coords: Float32Array.from(rectToContour(x, y, width, height)),\n    fillRule: 'nonzero',\n  };\n}\n\n/**\n * Axis-aligned rounded rectangle. Top-left at (x, y); `r` is clamped to half\n * the shorter side. Each corner is `cornerSamples` line segments, matching\n * `circlePath`'s polygonal approximation — the default 8 gives the same\n * angular resolution as `circlePath`'s 32.\n */\nexport function roundRectPath(\n  x: number,\n  y: number,\n  width: number,\n  height: number,\n  r: number,\n  cornerSamples = 8,\n): PolygonPath {\n  const radius = Math.max(0, Math.min(r, Math.min(width, height) / 2));\n  if (radius === 0) return rectMarkerPath(x, y, width, height);\n\n  const HALF_PI = Math.PI / 2;\n  // Corner centers paired with the arc's start angle, walked clockwise in\n  // screen space from the top-left.\n  const corners: Array<[number, number, number]> = [\n    [x + radius, y + radius, Math.PI],\n    [x + width - radius, y + radius, -HALF_PI],\n    [x + width - radius, y + height - radius, 0],\n    [x + radius, y + height - radius, HALF_PI],\n  ];\n\n  const perCorner = cornerSamples + 1;\n  const count = corners.length * perCorner;\n  const cmds = new Uint8Array(count + 1);\n  const coords = new Float32Array(count * 2);\n  let i = 0;\n  for (const [cx, cy, start] of corners) {\n    for (let s = 0; s <= cornerSamples; s++) {\n      const theta = start + (s / cornerSamples) * HALF_PI;\n      cmds[i] = i === 0 ? PATH_M : PATH_L;\n      coords[i * 2] = cx + radius * Math.cos(theta);\n      coords[i * 2 + 1] = cy + radius * Math.sin(theta);\n      i++;\n    }\n  }\n  cmds[count] = PATH_Z;\n  return { kind: 'polygon', commands: cmds, coords, fillRule: 'nonzero' };\n}\n"],"mappings":";;AAuBA,SAAgBA,EAAW,GAAY,GAAY,GAAW,IAAW,IAAiB;CACxF,IAAMC,IAAO,IAAI,WAAWC,IAAW,CAAC,GAClCC,IAAS,IAAI,aAAaD,IAAW,CAAC;CAG5C,AAFA,EAAK,KAAKE,GACV,EAAO,KAAKC,IAAKC,GACjB,EAAO,KAAKC;CACZ,KAAK,IAAIC,IAAI,GAAGA,IAAIN,GAAU,KAAK;EACjC,EAAKM,KAAKC;EACV,IAAMC,IAASF,IAAIN,IAAY,KAAK,KAAK;EAEzC,AADA,EAAOM,IAAI,KAAKH,IAAKC,IAAI,KAAK,IAAII,CAAK,GACvC,EAAOF,IAAI,IAAI,KAAKD,IAAKD,IAAI,KAAK,IAAII,CAAK;CAC7C;CAEA,OADA,EAAKR,KAAYS,GACV;EAAE,MAAM;EAAW,UAAUV;EAAM;EAAQ,UAAU;CAAU;AACxE;AAGA,SAAgBW,EAAW,GAAY,GAAY,GAA2B;CAC5E,IAAMC,IAAOC,IAAO,GACdC,IAAKV,IAAKQ,GAAMG,IAAKT,IAAKM,GAC1BI,IAAKZ,IAAKQ,GAAMK,IAAKX,IAAKM;CAChC,OAAO;EACL,MAAM;EACN,UAAU,IAAI,WAAW;GAACT;GAAQK;GAAQA;GAAQA;GAAQE;EAAM,CAAC;EACjE,QAAQ,IAAI,aAAa;GAACI;GAAIC;GAAIC;GAAID;GAAIC;GAAIC;GAAIH;GAAIG;EAAE,CAAC;EACzD,UAAU;CACZ;AACF;AAGA,SAAgBC,EAAe,GAAW,GAAW,GAAe,GAA6B;CAC/F,OAAO;EACL,MAAM;EACN,UAAU,IAAI,WAAW;GAACf;GAAQK;GAAQA;GAAQA;GAAQE;EAAM,CAAC;EACjE,QAAQ,aAAa,KAAKS,EAAcC,GAAGC,GAAGC,GAAOC,CAAM,CAAC;EAC5D,UAAU;CACZ;AACF;AAQA,SAAgBC,EACd,GACA,GACA,GACA,GACA,GACA,IAAgB,GACH;CACb,IAAMC,IAAS,KAAK,IAAI,GAAG,KAAK,IAAIpB,GAAG,KAAK,IAAIiB,GAAOC,CAAM,IAAI,CAAC,CAAC;CACnE,IAAIE,MAAW,GAAG,OAAOP,EAAeE,GAAGC,GAAGC,GAAOC,CAAM;CAE3D,IAAMG,IAAU,KAAK,KAAK,GAGpBC,IAA2C;EAC/C;GAACP,IAAIK;GAAQJ,IAAII;GAAQ,KAAK;EAAE;EAChC;GAACL,IAAIE,IAAQG;GAAQJ,IAAII;GAAQ,CAACC;EAAO;EACzC;GAACN,IAAIE,IAAQG;GAAQJ,IAAIE,IAASE;GAAQ;EAAC;EAC3C;GAACL,IAAIK;GAAQJ,IAAIE,IAASE;GAAQC;EAAO;CAC3C,GAEME,IAAYC,IAAgB,GAC5BC,IAAQH,EAAQ,SAASC,GACzB5B,IAAO,IAAI,WAAW8B,IAAQ,CAAC,GAC/B5B,IAAS,IAAI,aAAa4B,IAAQ,CAAC,GACrCvB,IAAI;CACR,KAAK,IAAM,CAACH,GAAIE,GAAIyB,MAAUJ,GAC5B,KAAK,IAAIK,IAAI,GAAGA,KAAKH,GAAe,KAAK;EACvC,IAAMpB,IAAQsB,IAASC,IAAIH,IAAiBH;EAI5C,AAHA,EAAKnB,KAAKA,MAAM,IAAIJ,IAASK,GAC7B,EAAOD,IAAI,KAAKH,IAAKqB,IAAS,KAAK,IAAIhB,CAAK,GAC5C,EAAOF,IAAI,IAAI,KAAKD,IAAKmB,IAAS,KAAK,IAAIhB,CAAK,GAChD;CACF;CAGF,OADA,EAAKqB,KAASpB,GACP;EAAE,MAAM;EAAW,UAAUV;EAAM;EAAQ,UAAU;CAAU;AACxE"}

package/dist/features/paths/nearestAnchor.js

@@ -1,36 +0,0 @@
-import { scaleDelta as e } from "../../core/viewport/pxExtent.js";
-import { pathToAnchors as t } from "./anchors.js";
-//#region src/features/paths/nearestAnchor.ts
-function n(n, r, i, a, o) {
-	let s = null, c = i * i;
-	for (let { id: i, path: l } of n) {
-		let { anchors: n, closed: u } = t(l);
-		for (let t = 0; t < n.length; t++) {
-			let l = n[t];
-			for (let n = 0; n < l.length; n++) {
-				let d = l[n], f = e(d.x - r.x, d.y - r.y, a), p = f.x * f.x + f.y * f.y;
-				if (p > c || s !== null && p === c) continue;
-				let m = u[t] ? null : n === l.length - 1 ? "last" : n === 0 ? "first" : null, h = {
-					id: i,
-					sub: t,
-					idx: n,
-					x: d.x,
-					y: d.y,
-					end: m
-				};
-				(!o || o(h)) && (s = h, c = p);
-			}
-		}
-	}
-	return s;
-}
-function r(e) {
-	return e.map((e) => {
-		let { inHandle: t, outHandle: n, ...r } = e, i = { ...r };
-		return n && (i.inHandle = { ...n }), t && (i.outHandle = { ...t }), i;
-	}).reverse();
-}
-//#endregion
-export { n as nearestPathAnchor, r as reverseAnchors };
-
-//# sourceMappingURL=nearestAnchor.js.map

package/dist/features/paths/nearestAnchor.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"nearestAnchor.js","names":["nearestPathAnchor","best","bestD2","px","paths","pathToAnchors","path","sub","anchors","list","idx","a","s","scaleDelta","point","scale","d2","end","closed","hit","accept","reverseAnchors","rest","r","outHandle","inHandle"],"sources":["../../../src/features/paths/nearestAnchor.ts"],"sourcesContent":["/**\n * Anchor lookup across several paths, measured on screen: which existing\n * anchor is nearest a point, and whether it ends an open subpath. Feeds the\n * pen's anchor snapping and its pick-up of an open path's endpoint.\n */\n\nimport { scaleDelta, type Scale2 } from 'core/viewport/pxExtent';\nimport { pathToAnchors, type PenAnchor } from './anchors';\nimport type { PolygonPath } from '@weasel-js/geom';\n\n/** An existing anchor found near a point. */\nexport interface PathAnchorHit {\n  /** The id the path was supplied under. */\n  id: string;\n  /** Subpath index, then anchor index within that subpath. */\n  sub: number;\n  idx: number;\n  x: number;\n  y: number;\n  /** Which end of an open subpath this anchor is, or null when it is an\n   *  interior anchor or its subpath is closed. A lone anchor reads `'last'`. */\n  end: 'first' | 'last' | null;\n}\n\n/**\n * The anchor nearest `point` within a screen-space circle of radius `px`,\n * across every subpath of every path in `paths`. Paths and `point` share one\n * world frame; `scale` is the view's, so the radius stays round under\n * non-uniform zoom. `accept` narrows the candidates (endpoints only, say).\n * Ties go to the earlier path, so pass paths front-to-back.\n */\nexport function nearestPathAnchor(\n  paths: Iterable<{ id: string; path: PolygonPath }>,\n  point: { x: number; y: number },\n  px: number,\n  scale: Scale2,\n  accept?: (hit: PathAnchorHit) => boolean,\n): PathAnchorHit | null {\n  let best: PathAnchorHit | null = null;\n  let bestD2 = px * px;\n  for (const { id, path } of paths) {\n    const { anchors, closed } = pathToAnchors(path);\n    for (let sub = 0; sub < anchors.length; sub++) {\n      const list = anchors[sub];\n      for (let idx = 0; idx < list.length; idx++) {\n        const a = list[idx];\n        const s = scaleDelta(a.x - point.x, a.y - point.y, scale);\n        const d2 = s.x * s.x + s.y * s.y;\n        if (d2 > bestD2 || (best !== null && d2 === bestD2)) continue;\n        const end = closed[sub]\n          ? null\n          : idx === list.length - 1 ? 'last' : idx === 0 ? 'first' : null;\n        const hit: PathAnchorHit = { id, sub, idx, x: a.x, y: a.y, end };\n        if (accept && !accept(hit)) continue;\n        best = hit;\n        bestD2 = d2;\n      }\n    }\n  }\n  return best;\n}\n\n/** Reverse a subpath's direction without changing its shape: the anchor\n *  order flips and each anchor's in and out handles trade places. */\nexport function reverseAnchors<A extends PenAnchor>(anchors: readonly A[]): A[] {\n  return anchors.map((a) => {\n    const { inHandle, outHandle, ...rest } = a;\n    const r = { ...rest } as A;\n    if (outHandle) r.inHandle = { ...outHandle };\n    if (inHandle) r.outHandle = { ...inHandle };\n    return r;\n  }).reverse();\n}\n"],"mappings":";;;AA+BA,SAAgBA,EACd,GACA,GACA,GACA,GACA,GACsB;CACtB,IAAIC,IAA6B,MAC7BC,IAASC,IAAKA;CAClB,KAAK,IAAM,EAAE,OAAI,aAAUC,GAAO;EAChC,IAAM,EAAE,YAAS,cAAWC,EAAcC,CAAI;EAC9C,KAAK,IAAIC,IAAM,GAAGA,IAAMC,EAAQ,QAAQ,KAAO;GAC7C,IAAMC,IAAOD,EAAQD;GACrB,KAAK,IAAIG,IAAM,GAAGA,IAAMD,EAAK,QAAQ,KAAO;IAC1C,IAAME,IAAIF,EAAKC,IACTE,IAAIC,EAAWF,EAAE,IAAIG,EAAM,GAAGH,EAAE,IAAIG,EAAM,GAAGC,CAAK,GAClDC,IAAKJ,EAAE,IAAIA,EAAE,IAAIA,EAAE,IAAIA,EAAE;IAC/B,IAAII,IAAKd,KAAWD,MAAS,QAAQe,MAAOd,GAAS;IACrD,IAAMe,IAAMC,EAAOX,KACf,OACAG,MAAQD,EAAK,SAAS,IAAI,SAASC,MAAQ,IAAI,UAAU,MACvDS,IAAqB;KAAE;KAAI;KAAK;KAAK,GAAGR,EAAE;KAAG,GAAGA,EAAE;KAAG;IAAI;IAC/D,CAAI,MAAWS,EAAOD,CAAG,OACzB,IAAOA,GACP,IAASH;GACX;EACF;CACF;CACA,OAAOf;AACT;AAIA,SAAgBoB,EAAoC,GAA4B;CAC9E,OAAOb,EAAQ,KAAK,MAAM;EACxB,IAAM,EAAE,aAAU,cAAW,GAAGc,MAASX,GACnCY,IAAI,EAAE,GAAGD,EAAK;EAGpB,OAFIE,MAAW,EAAE,WAAW,EAAE,GAAGA,EAAU,IACvCC,MAAU,EAAE,YAAY,EAAE,GAAGA,EAAS,IACnCF;CACT,CAAC,CAAC,CAAC,QAAQ;AACb"}

package/dist/features/paths/pathInWorld.js

@@ -1,41 +0,0 @@
-import { poseFrameInverseOf as e, poseFrameOf as t } from "../../core/geometry/poseFrame.js";
-import { applyToPoint as n, boundsOfPath as r, boxToBox as i, transformPath as a, translatePath as o } from "@weasel-js/geom";
-//#region src/features/paths/pathInWorld.ts
-function s(e, t) {
-	if (e.kind === "rect") return e.x === t.x && e.y === t.y && e.width === t.width && e.height === t.height ? e : {
-		kind: "rect",
-		x: t.x,
-		y: t.y,
-		width: t.width,
-		height: t.height
-	};
-	let n = r(e);
-	if (n.x === t.x && n.y === t.y && n.width === t.width && n.height === t.height) return e;
-	let o = i(n.x, n.y, n.width, n.height, t.x, t.y, t.width, t.height);
-	return a(e, o);
-}
-function c(e, n) {
-	let r = s(e, n), i = t(n);
-	return i ? a(r, i) : r;
-}
-function l(i, s) {
-	let c = e(i), l = c && t(i), u = c ? a(s, c) : s, d = r(u), f = o(u, -d.x, -d.y), p = d.x, m = d.y;
-	if (l) {
-		let [e, t] = n(l, d.x + d.width / 2, d.y + d.height / 2);
-		p = e - d.width / 2, m = t - d.height / 2;
-	}
-	return {
-		pose: {
-			...i,
-			x: p,
-			y: m,
-			width: d.width,
-			height: d.height
-		},
-		path: f
-	};
-}
-//#endregion
-export { s as pathInPoseFrame, c as pathInWorld, l as worldEditToStorage };
-
-//# sourceMappingURL=pathInWorld.js.map

package/dist/features/paths/pathInWorld.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"pathInWorld.js","names":["pathInPoseFrame","path","pose","b","boundsOfPath","m","boxToBox","transformPath","pathInWorld","local","frame","poseFrameOf","worldEditToStorage","back","poseFrameInverseOf","unrotated","worldPath","aligned","translatePath","x","y","cx","cy","applyToPoint"],"sources":["../../../src/features/paths/pathInWorld.ts"],"sourcesContent":["/**\n * Project a leaf path from its source frame into world coordinates given a\n * `{x, y, width, height, rotation?}` pose. Two transforms compose, in this\n * order:\n *\n *   1. Translate so the path's source AABB origin lands at `pose.x, pose.y`.\n *   2. If `pose.rotation` is nonzero, rotate every coord about the unrotated\n *      AABB center — i.e. `(pose.x + pose.width/2, pose.y + pose.height/2)`,\n *      matching `SceneCanvas.rotateAroundAABBCenter` so the baked geometry\n *      lines up with what the renderer draws.\n *\n * RectPaths can't carry rotation as-is (they're axis-aligned by definition);\n * a non-zero `pose.rotation` on a rect promotes the result to a polygon so\n * the four corners are baked into world coords. Callers that need to keep\n * the rect fast-path can pre-check `pose.rotation` themselves.\n *\n * Used by adapters that need true world geometry — most notably boolean ops,\n * where operating on the unrotated source path produces wrong shapes.\n */\n\nimport {\n  applyToPoint,\n  boxToBox,\n  boundsOfPath,\n  type Path,\n  type PolygonPath,\n  translatePath,\n  transformPath,\n} from '@weasel-js/geom';\nimport { poseFrameInverseOf, poseFrameOf, type PoseLinear } from 'core/geometry/poseFrame';\n\n/** Subset of pose fields this helper consumes. Matches the kit's auto-rotate\n *  convention (`SceneCanvas.defaultDrawOne`): `x/y/width/height` define an\n *  AABB whose unrotated center is the rotation pivot. */\nexport interface PathInWorldPose {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n  rotation?: number;\n  transform?: PoseLinear;\n}\n\n/**\n * Project a stored path into the pose's **local frame** — translate (and, for\n * rects, rebase to the pose's `width`/`height`) so the path's AABB origin sits\n * at the pose origin. This is translate-only: it does NOT apply\n * `pose.rotation`. Callers that want the fully world-positioned (rotated) path\n * should use `pathInWorld`, which composes this with the rotation wrap.\n *\n * Rects rebase onto the pose's `width`/`height` because resize updates the pose,\n * not the stored `RectPath` — so the live size lives on the pose. Honoring it\n * here keeps this in lockstep with the renderer (`SceneCanvas` paints the rect\n * at `pose.width/height`); otherwise world-space consumers (slice, booleans,\n * release-compound) would operate on the stale pre-resize dimensions.\n *\n * Used by the local seams: the default painter (paint + silhouette), and as the\n * building block `pathInWorld`/`findShapeSilhouette` rotate on top of.\n */\nexport function pathInPoseFrame(path: Path, pose: PathInWorldPose): Path {\n  if (path.kind === 'rect') {\n    if (\n      path.x === pose.x && path.y === pose.y\n      && path.width === pose.width && path.height === pose.height\n    ) return path;\n    return { kind: 'rect', x: pose.x, y: pose.y, width: pose.width, height: pose.height };\n  }\n  // Polygon: rebase the path's own AABB into the pose box via a box→box affine.\n  // Identity when the bounds already equal the pose box (geometry already tracks\n  // the pose) — behavior-preserving there; for geometry-in-data nodes whose pose\n  // box was resized independently, it scales the contents to fill the box,\n  // fixing the anchor bug.\n  const b = boundsOfPath(path);\n  if (b.x === pose.x && b.y === pose.y && b.width === pose.width && b.height === pose.height) {\n    return path;\n  }\n  const m = boxToBox(b.x, b.y, b.width, b.height, pose.x, pose.y, pose.width, pose.height);\n  return transformPath(path, m);\n}\n\n/**\n * Bake `pose` into `path`'s coordinates so the returned path is positioned\n * in world space. Returns a fresh `Path` instance; never mutates inputs.\n */\nexport function pathInWorld(path: Path, pose: PathInWorldPose): Path {\n  // Step 1: project into the pose's local frame (translate; rebase rect dims).\n  // Shares `pathInPoseFrame` with the renderer so world geometry never diverges\n  // from what's painted — notably for resized rects (pose dims, not path dims).\n  const local = pathInPoseFrame(path, pose);\n\n  // Step 2: apply the pose's frame about its AABB center, if any: its\n  // rotation and its `transform`, composed by `poseFrameOf` as the renderer's\n  // wrap composes them. `transformPath` handles the rect->polygon promotion\n  // and bezier control points.\n  const frame = poseFrameOf(pose);\n  if (!frame) return local;\n  return transformPath(local, frame) as PolygonPath;\n}\n\n/**\n * Inverse of `pathInWorld` for a path in **world** space: the stored path\n * in the pose's own frame plus the pose that draws it there. Takes the path\n * back through the pose's frame (`poseFrameOf`), so the pose's `rotation`\n * and `transform` are preserved, then fits the pose's AABB fields to the\n * result. The new box's center is placed where the old frame carries it,\n * since the pivot moves with the box: `pathInWorld(result.path, result.pose)`\n * reproduces `worldPath` whether or not its bounds changed.\n *\n * Generic in the pose type so consumer-defined pose fields (including\n * `rotation`) survive the round-trip. Used by the anchor-edit commit, its\n * live preview, and the default slice dep.\n */\nexport function worldEditToStorage<P extends PathInWorldPose>(\n  pose: P,\n  worldPath: PolygonPath,\n): { pose: P; path: PolygonPath };\nexport function worldEditToStorage<P extends PathInWorldPose>(pose: P, worldPath: Path): { pose: P; path: Path };\nexport function worldEditToStorage<P extends PathInWorldPose>(\n  pose: P,\n  worldPath: Path,\n): { pose: P; path: Path } {\n  // A singular `transform` has no way back, and the path is stored as drawn.\n  const back = poseFrameInverseOf(pose);\n  const frame = back && poseFrameOf(pose);\n  const unrotated = back ? transformPath(worldPath, back) : worldPath;\n  const b = boundsOfPath(unrotated);\n  const aligned = translatePath(unrotated, -b.x, -b.y);\n  let x = b.x, y = b.y;\n  if (frame) {\n    const [cx, cy] = applyToPoint(frame, b.x + b.width / 2, b.y + b.height / 2);\n    x = cx - b.width / 2;\n    y = cy - b.height / 2;\n  }\n  return {\n    pose: { ...pose, x, y, width: b.width, height: b.height },\n    path: aligned,\n  };\n}\n"],"mappings":";;;AA2DA,SAAgBA,EAAgB,GAAY,GAA6B;CACvE,IAAIC,EAAK,SAAS,QAKhB,OAHEA,EAAK,MAAMC,EAAK,KAAKD,EAAK,MAAMC,EAAK,KAClCD,EAAK,UAAUC,EAAK,SAASD,EAAK,WAAWC,EAAK,SAC9CD,IACF;EAAE,MAAM;EAAQ,GAAGC,EAAK;EAAG,GAAGA,EAAK;EAAG,OAAOA,EAAK;EAAO,QAAQA,EAAK;CAAO;CAOtF,IAAMC,IAAIC,EAAaH,CAAI;CAC3B,IAAIE,EAAE,MAAMD,EAAK,KAAKC,EAAE,MAAMD,EAAK,KAAKC,EAAE,UAAUD,EAAK,SAASC,EAAE,WAAWD,EAAK,QAClF,OAAOD;CAET,IAAMI,IAAIC,EAASH,EAAE,GAAGA,EAAE,GAAGA,EAAE,OAAOA,EAAE,QAAQD,EAAK,GAAGA,EAAK,GAAGA,EAAK,OAAOA,EAAK,MAAM;CACvF,OAAOK,EAAcN,GAAMI,CAAC;AAC9B;AAMA,SAAgBG,EAAY,GAAY,GAA6B;CAInE,IAAMC,IAAQT,EAAgBC,GAAMC,CAAI,GAMlCQ,IAAQC,EAAYT,CAAI;CAE9B,OADKQ,IACEH,EAAcE,GAAOC,CAAK,IADdD;AAErB;AAoBA,SAAgBG,EACd,GACA,GACyB;CAEzB,IAAMC,IAAOC,EAAmBZ,CAAI,GAC9BQ,IAAQG,KAAQF,EAAYT,CAAI,GAChCa,IAAYF,IAAON,EAAcS,GAAWH,CAAI,IAAIG,GACpDb,IAAIC,EAAaW,CAAS,GAC1BE,IAAUC,EAAcH,GAAW,CAACZ,EAAE,GAAG,CAACA,EAAE,CAAC,GAC/CgB,IAAIhB,EAAE,GAAGiB,IAAIjB,EAAE;CACnB,IAAIO,GAAO;EACT,IAAM,CAACW,GAAIC,KAAMC,EAAab,GAAOP,EAAE,IAAIA,EAAE,QAAQ,GAAGA,EAAE,IAAIA,EAAE,SAAS,CAAC;EAE1E,AADA,IAAIkB,IAAKlB,EAAE,QAAQ,GACnB,IAAImB,IAAKnB,EAAE,SAAS;CACtB;CACA,OAAO;EACL,MAAM;GAAE,GAAGD;GAAM;GAAG;GAAG,OAAOC,EAAE;GAAO,QAAQA,EAAE;EAAO;EACxD,MAAMc;CACR;AACF"}

package/dist/features/paths/poseDescriptor.js

@@ -1,39 +0,0 @@
-import { boundsOfPath as e, boxToBox as t, transformPath as n, translatePath as r } from "@weasel-js/geom";
-//#region src/features/paths/poseDescriptor.ts
-var i = {
-	getBounds: (t) => e(t),
-	remapBounds: (e, r, i) => n(e, t(r.x, r.y, r.width, r.height, i.x, i.y, i.width, i.height)),
-	fromBounds: (e) => ({
-		kind: "rect",
-		x: e.x,
-		y: e.y,
-		width: e.width,
-		height: e.height
-	}),
-	translate: (e, t, n) => r(e, t, n),
-	lerp: (e, t, n) => {
-		if (e.kind === "rect" && t.kind === "rect") return {
-			kind: "rect",
-			x: e.x + (t.x - e.x) * n,
-			y: e.y + (t.y - e.y) * n,
-			width: e.width + (t.width - e.width) * n,
-			height: e.height + (t.height - e.height) * n
-		};
-		if (e.kind === "polygon" && t.kind === "polygon" && e.coords.length === t.coords.length) {
-			let r = new Float32Array(e.coords.length);
-			for (let i = 0; i < e.coords.length; i++) r[i] = e.coords[i] + (t.coords[i] - e.coords[i]) * n;
-			return {
-				kind: "polygon",
-				commands: e.commands,
-				coords: r,
-				fillRule: e.fillRule
-			};
-		}
-		throw Error("pathPoseDescriptor.lerp: incompatible path shapes");
-	},
-	supportsRotation: () => !1
-};
-//#endregion
-export { i as pathPoseDescriptor };
-
-//# sourceMappingURL=poseDescriptor.js.map

package/dist/features/paths/poseDescriptor.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"poseDescriptor.js","names":["pathPoseDescriptor","boundsOfPath","path","transformPath","boxToBox","src","dst","b","translatePath","dx","dy","a","t","next"],"sources":["../../../src/features/paths/poseDescriptor.ts"],"sourcesContent":["import {\n  boxToBox,\n  boundsOfPath,\n  translatePath,\n  transformPath,\n  type Path,\n} from '@weasel-js/geom';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\n\n/**\n * `PoseDescriptor` for `Path` poses — wires `useResize` to operate\n * on `Path` directly. `getBounds` defers to the same `boundsOfPath` kernel\n * the rest of the kit uses.\n *\n * `remapBounds` mirrors `scalePathToBounds` but takes `src` explicitly: the\n * resize hook knows the group's origin AABB and uses it for every leaf,\n * instead of each leaf scaling against its own AABB (which would ignore\n * group context).\n */\nexport const pathPoseDescriptor: PoseDescriptor<Path> = {\n  getBounds: (path) => boundsOfPath(path),\n  remapBounds: (path, src, dst) => transformPath(\n    path,\n    boxToBox(src.x, src.y, src.width, src.height, dst.x, dst.y, dst.width, dst.height),\n  ),\n  fromBounds: (b) => ({ kind: 'rect', x: b.x, y: b.y, width: b.width, height: b.height }),\n  translate: (path, dx, dy) => translatePath(path, dx, dy),\n  lerp: (a, b, t) => {\n    if (a.kind === 'rect' && b.kind === 'rect') {\n      return {\n        kind: 'rect',\n        x: a.x + (b.x - a.x) * t,\n        y: a.y + (b.y - a.y) * t,\n        width: a.width + (b.width - a.width) * t,\n        height: a.height + (b.height - a.height) * t,\n      };\n    }\n    if (a.kind === 'polygon' && b.kind === 'polygon' && a.coords.length === b.coords.length) {\n      const next = new Float32Array(a.coords.length);\n      for (let i = 0; i < a.coords.length; i++) {\n        next[i] = a.coords[i] + (b.coords[i] - a.coords[i]) * t;\n      }\n      return { kind: 'polygon', commands: a.commands, coords: next, fillRule: a.fillRule };\n    }\n    throw new Error('pathPoseDescriptor.lerp: incompatible path shapes');\n  },\n  // Path poses carry no x/y/width/height/rotation fields — the kit's\n  // `wrapWithPoseRotation` helper has nothing to bind a rotation to, and\n  // `remapBounds` would drop a synthetic rotation field on every commit.\n  // Returning false here hides the rotation affordance for Path consumers\n  // so the rotate cursor doesn't appear without a working interaction.\n  supportsRotation: () => false,\n};\n"],"mappings":";;AAmBA,IAAaA,IAA2C;CACtD,YAAY,MAASC,EAAaC,CAAI;CACtC,cAAc,GAAM,GAAK,MAAQC,EAC/BD,GACAE,EAASC,EAAI,GAAGA,EAAI,GAAGA,EAAI,OAAOA,EAAI,QAAQC,EAAI,GAAGA,EAAI,GAAGA,EAAI,OAAOA,EAAI,MAAM,CACnF;CACA,aAAa,OAAO;EAAE,MAAM;EAAQ,GAAGC,EAAE;EAAG,GAAGA,EAAE;EAAG,OAAOA,EAAE;EAAO,QAAQA,EAAE;CAAO;CACrF,YAAY,GAAM,GAAI,MAAOC,EAAcN,GAAMO,GAAIC,CAAE;CACvD,OAAO,GAAG,GAAG,MAAM;EACjB,IAAIC,EAAE,SAAS,UAAUJ,EAAE,SAAS,QAClC,OAAO;GACL,MAAM;GACN,GAAGI,EAAE,KAAKJ,EAAE,IAAII,EAAE,KAAKC;GACvB,GAAGD,EAAE,KAAKJ,EAAE,IAAII,EAAE,KAAKC;GACvB,OAAOD,EAAE,SAASJ,EAAE,QAAQI,EAAE,SAASC;GACvC,QAAQD,EAAE,UAAUJ,EAAE,SAASI,EAAE,UAAUC;EAC7C;EAEF,IAAID,EAAE,SAAS,aAAaJ,EAAE,SAAS,aAAaI,EAAE,OAAO,WAAWJ,EAAE,OAAO,QAAQ;GACvF,IAAMM,IAAO,IAAI,aAAaF,EAAE,OAAO,MAAM;GAC7C,KAAK,IAAI,IAAI,GAAG,IAAIA,EAAE,OAAO,QAAQ,KACnC,EAAK,KAAKA,EAAE,OAAO,MAAMJ,EAAE,OAAO,KAAKI,EAAE,OAAO,MAAMC;GAExD,OAAO;IAAE,MAAM;IAAW,UAAUD,EAAE;IAAU,QAAQE;IAAM,UAAUF,EAAE;GAAS;EACrF;EACA,MAAU,MAAM,mDAAmD;CACrE;CAMA,wBAAwB;AAC1B"}

package/dist/features/paths/strokeToPath.js

@@ -1,40 +0,0 @@
-import { resolveStrokeWidth as e, tessellateStroke as t } from "./tessellate/stroke.js";
-import { strokeInsets as n } from "../../core/markerInset.js";
-import { markerHeads as r } from "./markerCommands.js";
-import { pathIntersect as i, pathSubtract as a, pathUnion as o, trianglesToPath as s } from "@weasel-js/geom/booleans";
-//#region src/features/paths/strokeToPath.ts
-var c = {
-	kind: "polygon",
-	commands: /* @__PURE__ */ new Uint8Array(),
-	coords: /* @__PURE__ */ new Float32Array(),
-	fillRule: "nonzero"
-};
-function l(u, d, f = {}) {
-	let p = e(d.width ?? 1, f.scale ?? 1);
-	if (!(p > 0)) return c;
-	let m = f.flattenTolerance, h = {
-		...d,
-		width: p
-	}, g = n(h, p), _ = d.align ?? "center", v = _ !== "center" && u.kind !== "rect", y = v ? {
-		...h,
-		width: p * 2,
-		align: "center",
-		vertexWidths: d.vertexWidths?.map((e) => e * 2)
-	} : h, b = t(u, y, {
-		flattenTolerance: m,
-		startInset: g.start,
-		endInset: g.end
-	}), x = s(b.vertices, b.indices);
-	v && (x = _ === "inner" ? i(x, u) : a(x, u));
-	let S = [];
-	for (let { entry: e, path: t, size: n } of r(u, h, p, m)) (e.fill ?? "line") !== "none" && S.push(t), e.outline && (e.outline.paint ?? "line") !== "none" && S.push(l(t, {
-		width: e.outline.width * n,
-		cap: "round",
-		join: "round"
-	}, f));
-	return S.length === 0 ? x : o(x, ...S);
-}
-//#endregion
-export { l as strokeToPath };
-
-//# sourceMappingURL=strokeToPath.js.map

package/dist/features/paths/strokeToPath.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"strokeToPath.js","names":["EMPTY","strokeToPath","width","resolveStrokeWidth","stroke","opts","tolerance","sized","insets","strokeInsets","align","cut","path","ribbonStroke","w","mesh","tessellateStroke","ribbon","trianglesToPath","pathIntersect","pathSubtract","heads","head","markerHeads","entry","size","pathUnion"],"sources":["../../../src/features/paths/strokeToPath.ts"],"sourcesContent":["/**\n * A stroke as geometry: the region its ink covers, as a fillable path.\n *\n * The ribbon the renderer draws already has the joins, caps, dashes, and\n * marker trims; unioning its triangles gives the silhouette with every\n * self-overlap resolved, so the outline and the drawn stroke cannot disagree.\n */\nimport type { Stroke } from '@weasel-js/paint';\nimport type { Path, PolygonPath } from '@weasel-js/geom';\nimport { pathIntersect, pathSubtract, pathUnion, trianglesToPath } from '@weasel-js/geom/booleans';\nimport { strokeInsets } from '../../core/markerInset';\nimport { resolveStrokeWidth, tessellateStroke } from './tessellate/stroke';\nimport { markerHeads } from './markerCommands';\n\n/** Options for {@link strokeToPath}. */\nexport interface StrokeToPathOptions {\n  /** Screen pixels per world unit, for a `{ px }` width or marker size.\n   *  Default 1. */\n  scale?: number;\n  /** Flatness tolerance for curves, in the path's units. */\n  flattenTolerance?: number;\n}\n\nconst EMPTY: PolygonPath = {\n  kind: 'polygon', commands: new Uint8Array(0), coords: new Float32Array(0), fillRule: 'nonzero',\n};\n\n/**\n * The region `stroke` covers when drawn along `path`, as a path to fill:\n * width, cap, join, miter limit, dash, alignment, per-vertex widths, and\n * marker heads all included. Curves are flattened, so the result holds only\n * M/L/Z. A stroke with no width answers an empty path.\n */\nexport function strokeToPath(path: Path, stroke: Stroke, opts: StrokeToPathOptions = {}): PolygonPath {\n  const width = resolveStrokeWidth(stroke.width ?? 1, opts.scale ?? 1);\n  if (!(width > 0)) return EMPTY;\n  const tolerance = opts.flattenTolerance;\n  const sized: Stroke = { ...stroke, width };\n  const insets = strokeInsets(sized, width);\n  const align = stroke.align ?? 'center';\n  // A rect's aligned ribbon is built in place. Any other path gets a centered\n  // ribbon twice as wide, cut to the side of the path it belongs on.\n  const cut = align !== 'center' && path.kind !== 'rect';\n  const ribbonStroke: Stroke = cut\n    ? { ...sized, width: width * 2, align: 'center', vertexWidths: stroke.vertexWidths?.map((w) => w * 2) }\n    : sized;\n  const mesh = tessellateStroke(path, ribbonStroke, {\n    flattenTolerance: tolerance, startInset: insets.start, endInset: insets.end,\n  });\n  let ribbon = trianglesToPath(mesh.vertices, mesh.indices);\n  if (cut) ribbon = align === 'inner' ? pathIntersect(ribbon, path) : pathSubtract(ribbon, path);\n\n  const heads: PolygonPath[] = [];\n  for (const { entry, path: head, size } of markerHeads(path, sized, width, tolerance)) {\n    if ((entry.fill ?? 'line') !== 'none') heads.push(head);\n    if (entry.outline && (entry.outline.paint ?? 'line') !== 'none') {\n      heads.push(strokeToPath(head, { width: entry.outline.width * size, cap: 'round', join: 'round' }, opts));\n    }\n  }\n  return heads.length === 0 ? ribbon : pathUnion(ribbon, ...heads);\n}\n"],"mappings":";;;;;AAuBA,IAAMA,IAAqB;CACzB,MAAM;CAAW,0BAAU,IAAI,WAAY;CAAG,wBAAQ,IAAI,aAAc;CAAG,UAAU;AACvF;AAQA,SAAgBC,EAAa,GAAY,GAAgB,IAA4B,CAAC,GAAgB;CACpG,IAAMC,IAAQC,EAAmBC,EAAO,SAAS,GAAGC,EAAK,SAAS,CAAC;CACnE,IAAI,EAAEH,IAAQ,IAAI,OAAOF;CACzB,IAAMM,IAAYD,EAAK,kBACjBE,IAAgB;EAAE,GAAGH;EAAQ;CAAM,GACnCI,IAASC,EAAaF,GAAOL,CAAK,GAClCQ,IAAQN,EAAO,SAAS,UAGxBO,IAAMD,MAAU,YAAYE,EAAK,SAAS,QAC1CC,IAAuBF,IACzB;EAAE,GAAGJ;EAAO,OAAOL,IAAQ;EAAG,OAAO;EAAU,cAAcE,EAAO,cAAc,KAAK,MAAMU,IAAI,CAAC;CAAE,IACpGP,GACEQ,IAAOC,EAAiBJ,GAAMC,GAAc;EAChD,kBAAkBP;EAAW,YAAYE,EAAO;EAAO,UAAUA,EAAO;CAC1E,CAAC,GACGS,IAASC,EAAgBH,EAAK,UAAUA,EAAK,OAAO;CACxD,AAAIJ,MAAK,IAASD,MAAU,UAAUS,EAAcF,GAAQL,CAAI,IAAIQ,EAAaH,GAAQL,CAAI;CAE7F,IAAMS,IAAuB,CAAC;CAC9B,KAAK,IAAM,EAAE,UAAO,MAAMC,GAAM,aAAUC,EAAYX,GAAML,GAAOL,GAAOI,CAAS,GAEjF,CADKkB,EAAM,QAAQ,YAAY,UAAQH,EAAM,KAAKC,CAAI,GAClDE,EAAM,YAAYA,EAAM,QAAQ,SAAS,YAAY,UACvDH,EAAM,KAAKpB,EAAaqB,GAAM;EAAE,OAAOE,EAAM,QAAQ,QAAQC;EAAM,KAAK;EAAS,MAAM;CAAQ,GAAGpB,CAAI,CAAC;CAG3G,OAAOgB,EAAM,WAAW,IAAIJ,IAASS,EAAUT,GAAQ,GAAGI,CAAK;AACjE"}