@weasel-js/core 1.10.1 → 1.11.0

package/dist/features/paths/shapeGenerator.js

@@ -1,89 +1,141 @@
-import { boundsOfPath as e, boxToBox as t, poseFrameOf as n, regularPolygonPath as r, starPath as i, transformPath as a, worldEditToStorage as o } from "@weasel-js/geom";
+import { boundsOfPath, boxToBox, poseFrameOf, regularPolygonPath, starPath, transformPath, worldEditToStorage } from "@weasel-js/geom";
+
 //#region src/features/paths/shapeGenerator.ts
-var s = {
+/**
+* The parameters a polygon or star was drawn with, kept on the node beside the
+* geometry they made (`data.generator` beside `data.path`), so the shape stays
+* editable as a polygon or a star after it is drawn.
+*
+* `data.path` stays the geometry every reader uses; the generator only says how
+* to make it again. Editing the path itself turns the shape into plain
+* geometry: the generator is dropped, since it could no longer reproduce what
+* is drawn. A generator whose path no longer matches it (a writer that changed
+* the path without dropping it) is treated the same way.
+*/
+/** The range of a polygon's side count and a star's point count. */
+var SHAPE_COUNT_RANGE = {
 	min: 3,
 	max: 32
-}, c = {
+};
+/** The range of a star's `innerRadiusRatio`. */
+var STAR_RATIO_RANGE = {
 	min: .01,
 	max: 1
-}, l = (e) => typeof e == "number" && Number.isFinite(e);
-function u(e) {
-	if (typeof e != "object" || !e) return !1;
-	let t = e;
-	return l(t.rotation) ? t.kind === "polygon" ? l(t.sides) : t.kind === "star" && l(t.points) && l(t.innerRadiusRatio) : !1;
+};
+var finite = (v) => typeof v === "number" && Number.isFinite(v);
+/** Whether `v` is a well-formed {@link ShapeGenerator}. */
+function isShapeGenerator(v) {
+	if (v === null || typeof v !== "object") return false;
+	const g = v;
+	if (!finite(g.rotation)) return false;
+	if (g.kind === "polygon") return finite(g.sides);
+	if (g.kind === "star") return finite(g.points) && finite(g.innerRadiusRatio);
+	return false;
 }
-function d(e) {
-	let t = e?.generator;
-	return u(t) ? t : null;
+/** The generator a node's `data` holds, or `null`. */
+function shapeGeneratorOf(data) {
+	const g = data?.generator;
+	return isShapeGenerator(g) ? g : null;
 }
-var f = (e, t, n) => Math.min(n, Math.max(t, e)), p = (e) => f(Math.round(e), s.min, s.max);
-function m(e) {
-	return e.kind === "polygon" ? {
+var clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+var count = (v) => clamp(Math.round(v), SHAPE_COUNT_RANGE.min, SHAPE_COUNT_RANGE.max);
+/** `g` with its counts rounded and every field held in range. */
+function clampShapeGenerator(g) {
+	if (g.kind === "polygon") return {
 		kind: "polygon",
-		sides: p(e.sides),
-		rotation: e.rotation
-	} : {
+		sides: count(g.sides),
+		rotation: g.rotation
+	};
+	return {
 		kind: "star",
-		points: p(e.points),
-		innerRadiusRatio: f(e.innerRadiusRatio, c.min, c.max),
-		rotation: e.rotation
+		points: count(g.points),
+		innerRadiusRatio: clamp(g.innerRadiusRatio, STAR_RATIO_RANGE.min, STAR_RATIO_RANGE.max),
+		rotation: g.rotation
 	};
 }
-function h(e, t = {
+/** The shape `g` makes, on a circle of `radius` around `center`. */
+function shapeGeneratorPath(g, center = {
 	x: 0,
 	y: 0
-}, n = 1) {
-	let a = m(e);
-	return a.kind === "polygon" ? r(t, n, a.sides, a.rotation) : i(t, n, a.points, n * a.innerRadiusRatio, a.rotation);
+}, radius = 1) {
+	const c = clampShapeGenerator(g);
+	return c.kind === "polygon" ? regularPolygonPath(center, radius, c.sides, c.rotation) : starPath(center, radius, c.points, radius * c.innerRadiusRatio, c.rotation);
 }
-function g(e) {
-	if (typeof e != "object" || !e || !("generator" in e)) return e;
-	let { generator: t, ...n } = e;
-	return n;
+/** `data` without its generator: the shape as plain geometry. */
+function withoutShapeGenerator(data) {
+	if (data === null || typeof data !== "object" || !("generator" in data)) return data;
+	const { generator: _dropped, ...rest } = data;
+	return rest;
 }
-function _(n, r) {
-	let i = n;
-	if (i?.kind !== "polygon") return !1;
-	let a = h(r);
-	if (i.coords.length !== a.coords.length) return !1;
-	let o = e(a), s = e(i), c = t(o.x, o.y, o.width, o.height, s.x, s.y, s.width, s.height), l = 1e-4 * Math.max(1, Math.abs(s.x) + s.width, Math.abs(s.y) + s.height);
-	for (let e = 0; e + 1 < a.coords.length; e += 2) {
-		let t = c[0] * a.coords[e] + c[4], n = c[3] * a.coords[e + 1] + c[5];
-		if (Math.abs(t - i.coords[e]) > l || Math.abs(n - i.coords[e + 1]) > l) return !1;
+/** Whether `path` is what `g` makes, up to the box-to-box map storage applies. */
+function pathMatches(path, g) {
+	const p = path;
+	if (p?.kind !== "polygon") return false;
+	const unit = shapeGeneratorPath(g);
+	if (p.coords.length !== unit.coords.length) return false;
+	const u = boundsOfPath(unit);
+	const b = boundsOfPath(p);
+	const m = boxToBox(u.x, u.y, u.width, u.height, b.x, b.y, b.width, b.height);
+	const tol = 1e-4 * Math.max(1, Math.abs(b.x) + b.width, Math.abs(b.y) + b.height);
+	for (let i = 0; i + 1 < unit.coords.length; i += 2) {
+		const x = m[0] * unit.coords[i] + m[4];
+		const y = m[3] * unit.coords[i + 1] + m[5];
+		if (Math.abs(x - p.coords[i]) > tol || Math.abs(y - p.coords[i + 1]) > tol) return false;
 	}
-	return !0;
+	return true;
 }
-function v(r, i) {
-	let s = d(r.data);
-	if (!s || !_(r.data.path, s)) return null;
-	let c = m(i), l = e(h(s)), { pose: u } = r, f = t(l.x, l.y, l.width, l.height, u.x, u.y, u.width, u.height), p = a(h(c), f), g = n(u), v = g ? a(p, g) : p, y = o(u, v);
+/**
+* `node` made again from `next`, in place: the new shape takes the box the old
+* one's circle had, under the same rotation and transform, so a star given
+* more points keeps its center and its size. Returns `null` when the node holds
+* no generator, or its path no longer matches the one it holds.
+*/
+function regenerateShape(node, next) {
+	const held = shapeGeneratorOf(node.data);
+	if (!held || !pathMatches(node.data.path, held)) return null;
+	const g = clampShapeGenerator(next);
+	const was = boundsOfPath(shapeGeneratorPath(held));
+	const { pose } = node;
+	const toLocal = boxToBox(was.x, was.y, was.width, was.height, pose.x, pose.y, pose.width, pose.height);
+	const local = transformPath(shapeGeneratorPath(g), toLocal);
+	const frame = poseFrameOf(pose);
+	const world = frame ? transformPath(local, frame) : local;
+	const stored = worldEditToStorage(pose, world);
 	return {
-		pose: y.pose,
+		pose: stored.pose,
 		data: {
-			...r.data,
-			path: y.path,
-			generator: c
+			...node.data,
+			path: stored.path,
+			generator: g
 		}
 	};
 }
-function y(e, t) {
-	let n = e.data;
-	if (typeof n != "object" || !n || !("generator" in n)) return e;
-	let r = n.generator, i = d(t.data);
-	if (i !== null && JSON.stringify(r) === JSON.stringify(i)) return e;
-	let a = i !== null && u(r) && r.kind === i.kind ? v({
-		pose: e.pose,
+/**
+* What a write that left a node as `next`, from `prev`, stores: when the write
+* changed the generator, the shape made again from it. A generator written
+* onto a node that held none, or of another kind, or onto one whose path no
+* longer matches, is dropped, leaving the shape as plain geometry. Any other
+* write is stored as written. Fits `NodePropertiesEntry.settle`.
+*/
+function settleShapeGenerator(next, prev) {
+	const data = next.data;
+	if (data === null || typeof data !== "object" || !("generator" in data)) return next;
+	const raw = data.generator;
+	const held = shapeGeneratorOf(prev.data);
+	if (held !== null && JSON.stringify(raw) === JSON.stringify(held)) return next;
+	const regenerated = held !== null && isShapeGenerator(raw) && raw.kind === held.kind ? regenerateShape({
+		pose: next.pose,
 		data: {
-			...n,
-			generator: i
+			...data,
+			generator: held
 		}
-	}, r) : null;
+	}, raw) : null;
 	return {
-		...e,
-		...a ?? { data: g(e.data) }
+		...next,
+		...regenerated ?? { data: withoutShapeGenerator(next.data) }
 	};
 }
-//#endregion
-export { s as SHAPE_COUNT_RANGE, c as STAR_RATIO_RANGE, m as clampShapeGenerator, u as isShapeGenerator, v as regenerateShape, y as settleShapeGenerator, d as shapeGeneratorOf, h as shapeGeneratorPath, g as withoutShapeGenerator };
 
+//#endregion
+export { SHAPE_COUNT_RANGE, STAR_RATIO_RANGE, clampShapeGenerator, isShapeGenerator, regenerateShape, settleShapeGenerator, shapeGeneratorOf, shapeGeneratorPath, withoutShapeGenerator };
 //# sourceMappingURL=shapeGenerator.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"shapeGenerator.js","names":["SHAPE_COUNT_RANGE","STAR_RATIO_RANGE","finite","v","isShapeGenerator","g","shapeGeneratorOf","data","clamp","hi","lo","count","clampShapeGenerator","shapeGeneratorPath","c","regularPolygonPath","center","radius","starPath","withoutShapeGenerator","_dropped","rest","pathMatches","p","path","unit","u","boundsOfPath","b","m","boxToBox","tol","i","x","y","regenerateShape","held","node","next","was","toLocal","pose","local","transformPath","frame","poseFrameOf","world","stored","worldEditToStorage","settleShapeGenerator","raw","prev","regenerated"],"sources":["../../../src/features/paths/shapeGenerator.ts"],"sourcesContent":["/**\n * The parameters a polygon or star was drawn with, kept on the node beside the\n * geometry they made (`data.generator` beside `data.path`), so the shape stays\n * editable as a polygon or a star after it is drawn.\n *\n * `data.path` stays the geometry every reader uses; the generator only says how\n * to make it again. Editing the path itself turns the shape into plain\n * geometry: the generator is dropped, since it could no longer reproduce what\n * is drawn. A generator whose path no longer matches it (a writer that changed\n * the path without dropping it) is treated the same way.\n */\nimport {\n  boundsOfPath,\n  boxToBox,\n  poseFrameOf,\n  regularPolygonPath,\n  starPath,\n  transformPath,\n  worldEditToStorage,\n  type PathInWorldPose,\n  type PolygonPath,\n} from '@weasel-js/geom';\n\n/** A regular polygon's parameters. `rotation` is the angle of its first\n *  vertex, in radians, inside the pose's own rotation. */\nexport interface PolygonGenerator {\n  kind: 'polygon';\n  sides: number;\n  rotation: number;\n}\n\n/** A star's parameters. `innerRadiusRatio` is the inner radius over the outer\n *  one; `rotation` is the angle of its first point, in radians, inside the\n *  pose's own rotation. */\nexport interface StarGenerator {\n  kind: 'star';\n  points: number;\n  innerRadiusRatio: number;\n  rotation: number;\n}\n\n/** The parameters a node's `data.path` was generated from. */\nexport type ShapeGenerator = PolygonGenerator | StarGenerator;\n\n/** The range of a polygon's side count and a star's point count. */\nexport const SHAPE_COUNT_RANGE = { min: 3, max: 32 } as const;\n\n/** The range of a star's `innerRadiusRatio`. */\nexport const STAR_RATIO_RANGE = { min: 0.01, max: 1 } as const;\n\nconst finite = (v: unknown): v is number => typeof v === 'number' && Number.isFinite(v);\n\n/** Whether `v` is a well-formed {@link ShapeGenerator}. */\nexport function isShapeGenerator(v: unknown): v is ShapeGenerator {\n  if (v === null || typeof v !== 'object') return false;\n  const g = v as Record<string, unknown>;\n  if (!finite(g.rotation)) return false;\n  if (g.kind === 'polygon') return finite(g.sides);\n  if (g.kind === 'star') return finite(g.points) && finite(g.innerRadiusRatio);\n  return false;\n}\n\n/** The generator a node's `data` holds, or `null`. */\nexport function shapeGeneratorOf(data: unknown): ShapeGenerator | null {\n  const g = (data as { generator?: unknown } | null | undefined)?.generator;\n  return isShapeGenerator(g) ? g : null;\n}\n\nconst clamp = (v: number, lo: number, hi: number): number => Math.min(hi, Math.max(lo, v));\nconst count = (v: number): number => clamp(Math.round(v), SHAPE_COUNT_RANGE.min, SHAPE_COUNT_RANGE.max);\n\n/** `g` with its counts rounded and every field held in range. */\nexport function clampShapeGenerator(g: ShapeGenerator): ShapeGenerator {\n  if (g.kind === 'polygon') return { kind: 'polygon', sides: count(g.sides), rotation: g.rotation };\n  return {\n    kind: 'star',\n    points: count(g.points),\n    innerRadiusRatio: clamp(g.innerRadiusRatio, STAR_RATIO_RANGE.min, STAR_RATIO_RANGE.max),\n    rotation: g.rotation,\n  };\n}\n\n/** The shape `g` makes, on a circle of `radius` around `center`. */\nexport function shapeGeneratorPath(\n  g: ShapeGenerator,\n  center: { x: number; y: number } = { x: 0, y: 0 },\n  radius = 1,\n): PolygonPath {\n  const c = clampShapeGenerator(g);\n  return c.kind === 'polygon'\n    ? regularPolygonPath(center, radius, c.sides, c.rotation)\n    : starPath(center, radius, c.points, radius * c.innerRadiusRatio, c.rotation);\n}\n\n/** `data` without its generator: the shape as plain geometry. */\nexport function withoutShapeGenerator<T>(data: T): T {\n  if (data === null || typeof data !== 'object' || !('generator' in data)) return data;\n  const { generator: _dropped, ...rest } = data as Record<string, unknown>;\n  void _dropped;\n  return rest as T;\n}\n\n/** Whether `path` is what `g` makes, up to the box-to-box map storage applies. */\nfunction pathMatches(path: unknown, g: ShapeGenerator): boolean {\n  const p = path as PolygonPath | undefined;\n  if (p?.kind !== 'polygon') return false;\n  const unit = shapeGeneratorPath(g);\n  if (p.coords.length !== unit.coords.length) return false;\n  const u = boundsOfPath(unit);\n  const b = boundsOfPath(p);\n  const m = boxToBox(u.x, u.y, u.width, u.height, b.x, b.y, b.width, b.height);\n  // Paths store float32 coordinates, so the slack scales with how far they are from the origin.\n  const tol = 1e-4 * Math.max(1, Math.abs(b.x) + b.width, Math.abs(b.y) + b.height);\n  for (let i = 0; i + 1 < unit.coords.length; i += 2) {\n    const x = m[0] * unit.coords[i] + m[4];\n    const y = m[3] * unit.coords[i + 1] + m[5];\n    if (Math.abs(x - p.coords[i]) > tol || Math.abs(y - p.coords[i + 1]) > tol) return false;\n  }\n  return true;\n}\n\n/** A node's two halves, as a regeneration reads and writes them. */\nexport interface GeneratedShape<P extends PathInWorldPose = PathInWorldPose> {\n  pose: P;\n  data: unknown;\n}\n\n/**\n * `node` made again from `next`, in place: the new shape takes the box the old\n * one's circle had, under the same rotation and transform, so a star given\n * more points keeps its center and its size. Returns `null` when the node holds\n * no generator, or its path no longer matches the one it holds.\n */\nexport function regenerateShape<P extends PathInWorldPose>(\n  node: GeneratedShape<P>,\n  next: ShapeGenerator,\n): GeneratedShape<P> | null {\n  const held = shapeGeneratorOf(node.data);\n  if (!held || !pathMatches((node.data as { path?: unknown }).path, held)) return null;\n  const g = clampShapeGenerator(next);\n  const was = boundsOfPath(shapeGeneratorPath(held));\n  const { pose } = node;\n  // Where the unit circle of the held generator lands in the pose's local frame.\n  const toLocal = boxToBox(was.x, was.y, was.width, was.height, pose.x, pose.y, pose.width, pose.height);\n  const local = transformPath(shapeGeneratorPath(g), toLocal) as PolygonPath;\n  const frame = poseFrameOf(pose);\n  const world = frame ? (transformPath(local, frame) as PolygonPath) : local;\n  const stored = worldEditToStorage(pose, world);\n  return { pose: stored.pose, data: { ...(node.data as object), path: stored.path, generator: g } };\n}\n\n/**\n * What a write that left a node as `next`, from `prev`, stores: when the write\n * changed the generator, the shape made again from it. A generator written\n * onto a node that held none, or of another kind, or onto one whose path no\n * longer matches, is dropped, leaving the shape as plain geometry. Any other\n * write is stored as written. Fits `NodePropertiesEntry.settle`.\n */\nexport function settleShapeGenerator<N extends { pose: unknown; data: unknown }>(next: N, prev: N): N {\n  const data = next.data as Record<string, unknown> | null;\n  if (data === null || typeof data !== 'object' || !('generator' in data)) return next;\n  const raw = data.generator;\n  const held = shapeGeneratorOf(prev.data);\n  if (held !== null && JSON.stringify(raw) === JSON.stringify(held)) return next;\n  const regenerated = held !== null && isShapeGenerator(raw) && raw.kind === held.kind\n    ? regenerateShape({ pose: next.pose as PathInWorldPose, data: { ...data, generator: held } }, raw)\n    : null;\n  return { ...next, ...(regenerated ?? { data: withoutShapeGenerator(next.data) }) };\n}\n"],"mappings":"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"}
+{"version":3,"file":"shapeGenerator.js","names":[],"sources":["../../../src/features/paths/shapeGenerator.ts"],"sourcesContent":["/**\n * The parameters a polygon or star was drawn with, kept on the node beside the\n * geometry they made (`data.generator` beside `data.path`), so the shape stays\n * editable as a polygon or a star after it is drawn.\n *\n * `data.path` stays the geometry every reader uses; the generator only says how\n * to make it again. Editing the path itself turns the shape into plain\n * geometry: the generator is dropped, since it could no longer reproduce what\n * is drawn. A generator whose path no longer matches it (a writer that changed\n * the path without dropping it) is treated the same way.\n */\nimport {\n  boundsOfPath,\n  boxToBox,\n  poseFrameOf,\n  regularPolygonPath,\n  starPath,\n  transformPath,\n  worldEditToStorage,\n  type PathInWorldPose,\n  type PolygonPath,\n} from '@weasel-js/geom';\n\n/** A regular polygon's parameters. `rotation` is the angle of its first\n *  vertex, in radians, inside the pose's own rotation. */\nexport interface PolygonGenerator {\n  kind: 'polygon';\n  sides: number;\n  rotation: number;\n}\n\n/** A star's parameters. `innerRadiusRatio` is the inner radius over the outer\n *  one; `rotation` is the angle of its first point, in radians, inside the\n *  pose's own rotation. */\nexport interface StarGenerator {\n  kind: 'star';\n  points: number;\n  innerRadiusRatio: number;\n  rotation: number;\n}\n\n/** The parameters a node's `data.path` was generated from. */\nexport type ShapeGenerator = PolygonGenerator | StarGenerator;\n\n/** The range of a polygon's side count and a star's point count. */\nexport const SHAPE_COUNT_RANGE = { min: 3, max: 32 } as const;\n\n/** The range of a star's `innerRadiusRatio`. */\nexport const STAR_RATIO_RANGE = { min: 0.01, max: 1 } as const;\n\nconst finite = (v: unknown): v is number => typeof v === 'number' && Number.isFinite(v);\n\n/** Whether `v` is a well-formed {@link ShapeGenerator}. */\nexport function isShapeGenerator(v: unknown): v is ShapeGenerator {\n  if (v === null || typeof v !== 'object') return false;\n  const g = v as Record<string, unknown>;\n  if (!finite(g.rotation)) return false;\n  if (g.kind === 'polygon') return finite(g.sides);\n  if (g.kind === 'star') return finite(g.points) && finite(g.innerRadiusRatio);\n  return false;\n}\n\n/** The generator a node's `data` holds, or `null`. */\nexport function shapeGeneratorOf(data: unknown): ShapeGenerator | null {\n  const g = (data as { generator?: unknown } | null | undefined)?.generator;\n  return isShapeGenerator(g) ? g : null;\n}\n\nconst clamp = (v: number, lo: number, hi: number): number => Math.min(hi, Math.max(lo, v));\nconst count = (v: number): number => clamp(Math.round(v), SHAPE_COUNT_RANGE.min, SHAPE_COUNT_RANGE.max);\n\n/** `g` with its counts rounded and every field held in range. */\nexport function clampShapeGenerator(g: ShapeGenerator): ShapeGenerator {\n  if (g.kind === 'polygon') return { kind: 'polygon', sides: count(g.sides), rotation: g.rotation };\n  return {\n    kind: 'star',\n    points: count(g.points),\n    innerRadiusRatio: clamp(g.innerRadiusRatio, STAR_RATIO_RANGE.min, STAR_RATIO_RANGE.max),\n    rotation: g.rotation,\n  };\n}\n\n/** The shape `g` makes, on a circle of `radius` around `center`. */\nexport function shapeGeneratorPath(\n  g: ShapeGenerator,\n  center: { x: number; y: number } = { x: 0, y: 0 },\n  radius = 1,\n): PolygonPath {\n  const c = clampShapeGenerator(g);\n  return c.kind === 'polygon'\n    ? regularPolygonPath(center, radius, c.sides, c.rotation)\n    : starPath(center, radius, c.points, radius * c.innerRadiusRatio, c.rotation);\n}\n\n/** `data` without its generator: the shape as plain geometry. */\nexport function withoutShapeGenerator<T>(data: T): T {\n  if (data === null || typeof data !== 'object' || !('generator' in data)) return data;\n  const { generator: _dropped, ...rest } = data as Record<string, unknown>;\n  void _dropped;\n  return rest as T;\n}\n\n/** Whether `path` is what `g` makes, up to the box-to-box map storage applies. */\nfunction pathMatches(path: unknown, g: ShapeGenerator): boolean {\n  const p = path as PolygonPath | undefined;\n  if (p?.kind !== 'polygon') return false;\n  const unit = shapeGeneratorPath(g);\n  if (p.coords.length !== unit.coords.length) return false;\n  const u = boundsOfPath(unit);\n  const b = boundsOfPath(p);\n  const m = boxToBox(u.x, u.y, u.width, u.height, b.x, b.y, b.width, b.height);\n  // Paths store float32 coordinates, so the slack scales with how far they are from the origin.\n  const tol = 1e-4 * Math.max(1, Math.abs(b.x) + b.width, Math.abs(b.y) + b.height);\n  for (let i = 0; i + 1 < unit.coords.length; i += 2) {\n    const x = m[0] * unit.coords[i] + m[4];\n    const y = m[3] * unit.coords[i + 1] + m[5];\n    if (Math.abs(x - p.coords[i]) > tol || Math.abs(y - p.coords[i + 1]) > tol) return false;\n  }\n  return true;\n}\n\n/** A node's two halves, as a regeneration reads and writes them. */\nexport interface GeneratedShape<P extends PathInWorldPose = PathInWorldPose> {\n  pose: P;\n  data: unknown;\n}\n\n/**\n * `node` made again from `next`, in place: the new shape takes the box the old\n * one's circle had, under the same rotation and transform, so a star given\n * more points keeps its center and its size. Returns `null` when the node holds\n * no generator, or its path no longer matches the one it holds.\n */\nexport function regenerateShape<P extends PathInWorldPose>(\n  node: GeneratedShape<P>,\n  next: ShapeGenerator,\n): GeneratedShape<P> | null {\n  const held = shapeGeneratorOf(node.data);\n  if (!held || !pathMatches((node.data as { path?: unknown }).path, held)) return null;\n  const g = clampShapeGenerator(next);\n  const was = boundsOfPath(shapeGeneratorPath(held));\n  const { pose } = node;\n  // Where the unit circle of the held generator lands in the pose's local frame.\n  const toLocal = boxToBox(was.x, was.y, was.width, was.height, pose.x, pose.y, pose.width, pose.height);\n  const local = transformPath(shapeGeneratorPath(g), toLocal) as PolygonPath;\n  const frame = poseFrameOf(pose);\n  const world = frame ? (transformPath(local, frame) as PolygonPath) : local;\n  const stored = worldEditToStorage(pose, world);\n  return { pose: stored.pose, data: { ...(node.data as object), path: stored.path, generator: g } };\n}\n\n/**\n * What a write that left a node as `next`, from `prev`, stores: when the write\n * changed the generator, the shape made again from it. A generator written\n * onto a node that held none, or of another kind, or onto one whose path no\n * longer matches, is dropped, leaving the shape as plain geometry. Any other\n * write is stored as written. Fits `NodePropertiesEntry.settle`.\n */\nexport function settleShapeGenerator<N extends { pose: unknown; data: unknown }>(next: N, prev: N): N {\n  const data = next.data as Record<string, unknown> | null;\n  if (data === null || typeof data !== 'object' || !('generator' in data)) return next;\n  const raw = data.generator;\n  const held = shapeGeneratorOf(prev.data);\n  if (held !== null && JSON.stringify(raw) === JSON.stringify(held)) return next;\n  const regenerated = held !== null && isShapeGenerator(raw) && raw.kind === held.kind\n    ? regenerateShape({ pose: next.pose as PathInWorldPose, data: { ...data, generator: held } }, raw)\n    : null;\n  return { ...next, ...(regenerated ?? { data: withoutShapeGenerator(next.data) }) };\n}\n"],"mappings":";;;;;;;;;;;;;;;AA6CA,IAAa,oBAAoB;CAAE,KAAK;CAAG,KAAK;AAAG;;AAGnD,IAAa,mBAAmB;CAAE,KAAK;CAAM,KAAK;AAAE;AAEpD,IAAM,UAAU,MAA4B,OAAO,MAAM,YAAY,OAAO,SAAS,CAAC;;AAGtF,SAAgB,iBAAiB,GAAiC;CAChE,IAAI,MAAM,QAAQ,OAAO,MAAM,UAAU,OAAO;CAChD,MAAM,IAAI;CACV,IAAI,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO;CAChC,IAAI,EAAE,SAAS,WAAW,OAAO,OAAO,EAAE,KAAK;CAC/C,IAAI,EAAE,SAAS,QAAQ,OAAO,OAAO,EAAE,MAAM,KAAK,OAAO,EAAE,gBAAgB;CAC3E,OAAO;AACT;;AAGA,SAAgB,iBAAiB,MAAsC;CACrE,MAAM,IAAK,MAAqD;CAChE,OAAO,iBAAiB,CAAC,IAAI,IAAI;AACnC;AAEA,IAAM,SAAS,GAAW,IAAY,OAAuB,KAAK,IAAI,IAAI,KAAK,IAAI,IAAI,CAAC,CAAC;AACzF,IAAM,SAAS,MAAsB,MAAM,KAAK,MAAM,CAAC,GAAG,kBAAkB,KAAK,kBAAkB,GAAG;;AAGtG,SAAgB,oBAAoB,GAAmC;CACrE,IAAI,EAAE,SAAS,WAAW,OAAO;EAAE,MAAM;EAAW,OAAO,MAAM,EAAE,KAAK;EAAG,UAAU,EAAE;CAAS;CAChG,OAAO;EACL,MAAM;EACN,QAAQ,MAAM,EAAE,MAAM;EACtB,kBAAkB,MAAM,EAAE,kBAAkB,iBAAiB,KAAK,iBAAiB,GAAG;EACtF,UAAU,EAAE;CACd;AACF;;AAGA,SAAgB,mBACd,GACA,SAAmC;CAAE,GAAG;CAAG,GAAG;AAAE,GAChD,SAAS,GACI;CACb,MAAM,IAAI,oBAAoB,CAAC;CAC/B,OAAO,EAAE,SAAS,YACd,mBAAmB,QAAQ,QAAQ,EAAE,OAAO,EAAE,QAAQ,IACtD,SAAS,QAAQ,QAAQ,EAAE,QAAQ,SAAS,EAAE,kBAAkB,EAAE,QAAQ;AAChF;;AAGA,SAAgB,sBAAyB,MAAY;CACnD,IAAI,SAAS,QAAQ,OAAO,SAAS,YAAY,EAAE,eAAe,OAAO,OAAO;CAChF,MAAM,EAAE,WAAW,UAAU,GAAG,SAAS;CAEzC,OAAO;AACT;;AAGA,SAAS,YAAY,MAAe,GAA4B;CAC9D,MAAM,IAAI;CACV,IAAI,GAAG,SAAS,WAAW,OAAO;CAClC,MAAM,OAAO,mBAAmB,CAAC;CACjC,IAAI,EAAE,OAAO,WAAW,KAAK,OAAO,QAAQ,OAAO;CACnD,MAAM,IAAI,aAAa,IAAI;CAC3B,MAAM,IAAI,aAAa,CAAC;CACxB,MAAM,IAAI,SAAS,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM;CAE3E,MAAM,MAAM,OAAO,KAAK,IAAI,GAAG,KAAK,IAAI,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM;CAChF,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,KAAK,OAAO,QAAQ,KAAK,GAAG;EAClD,MAAM,IAAI,EAAE,KAAK,KAAK,OAAO,KAAK,EAAE;EACpC,MAAM,IAAI,EAAE,KAAK,KAAK,OAAO,IAAI,KAAK,EAAE;EACxC,IAAI,KAAK,IAAI,IAAI,EAAE,OAAO,EAAE,IAAI,OAAO,KAAK,IAAI,IAAI,EAAE,OAAO,IAAI,EAAE,IAAI,KAAK,OAAO;CACrF;CACA,OAAO;AACT;;;;;;;AAcA,SAAgB,gBACd,MACA,MAC0B;CAC1B,MAAM,OAAO,iBAAiB,KAAK,IAAI;CACvC,IAAI,CAAC,QAAQ,CAAC,YAAa,KAAK,KAA4B,MAAM,IAAI,GAAG,OAAO;CAChF,MAAM,IAAI,oBAAoB,IAAI;CAClC,MAAM,MAAM,aAAa,mBAAmB,IAAI,CAAC;CACjD,MAAM,EAAE,SAAS;CAEjB,MAAM,UAAU,SAAS,IAAI,GAAG,IAAI,GAAG,IAAI,OAAO,IAAI,QAAQ,KAAK,GAAG,KAAK,GAAG,KAAK,OAAO,KAAK,MAAM;CACrG,MAAM,QAAQ,cAAc,mBAAmB,CAAC,GAAG,OAAO;CAC1D,MAAM,QAAQ,YAAY,IAAI;CAC9B,MAAM,QAAQ,QAAS,cAAc,OAAO,KAAK,IAAoB;CACrE,MAAM,SAAS,mBAAmB,MAAM,KAAK;CAC7C,OAAO;EAAE,MAAM,OAAO;EAAM,MAAM;GAAE,GAAI,KAAK;GAAiB,MAAM,OAAO;GAAM,WAAW;EAAE;CAAE;AAClG;;;;;;;;AASA,SAAgB,qBAAiE,MAAS,MAAY;CACpG,MAAM,OAAO,KAAK;CAClB,IAAI,SAAS,QAAQ,OAAO,SAAS,YAAY,EAAE,eAAe,OAAO,OAAO;CAChF,MAAM,MAAM,KAAK;CACjB,MAAM,OAAO,iBAAiB,KAAK,IAAI;CACvC,IAAI,SAAS,QAAQ,KAAK,UAAU,GAAG,MAAM,KAAK,UAAU,IAAI,GAAG,OAAO;CAC1E,MAAM,cAAc,SAAS,QAAQ,iBAAiB,GAAG,KAAK,IAAI,SAAS,KAAK,OAC5E,gBAAgB;EAAE,MAAM,KAAK;EAAyB,MAAM;GAAE,GAAG;GAAM,WAAW;EAAK;CAAE,GAAG,GAAG,IAC/F;CACJ,OAAO;EAAE,GAAG;EAAM,GAAI,eAAe,EAAE,MAAM,sBAAsB,KAAK,IAAI,EAAE;CAAG;AACnF"}

package/dist/features/paths/strokeOutline.js

@@ -0,0 +1,15 @@
+import { findShapeSilhouette } from "../../canvas/NodeShape.js";
+import { isSilhouettePose } from "../../core/geometry/regionHit.js";
+
+//#region src/features/paths/strokeOutline.ts
+/** The outline `node` is drawn with, in world coords: its pose when the pose
+*  is a polygon, else its painter's silhouette. Null for a node with neither. */
+function nodeOutline(node) {
+	const pose = node.pose;
+	if (isSilhouettePose(pose)) return pose;
+	return findShapeSilhouette(node, pose);
+}
+
+//#endregion
+export { nodeOutline };
+//# sourceMappingURL=strokeOutline.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"strokeOutline.js","names":[],"sources":["../../../src/features/paths/strokeOutline.ts"],"sourcesContent":["import type { Path } from '@weasel-js/geom';\nimport { isSilhouettePose } from 'core/geometry/regionHit';\nimport type { Node } from 'core/scene/types';\nimport { findShapeSilhouette } from 'canvas/NodeShape';\n\n/** The outline `node` is drawn with, in world coords: its pose when the pose\n *  is a polygon, else its painter's silhouette. Null for a node with neither. */\nexport function nodeOutline(node: Node<unknown, string, unknown>): Path | null {\n  const pose = node.pose;\n  if (isSilhouettePose(pose)) return pose;\n  return findShapeSilhouette(node, pose);\n}\n"],"mappings":";;;;;;AAOA,SAAgB,YAAY,MAAmD;CAC7E,MAAM,OAAO,KAAK;CAClB,IAAI,iBAAiB,IAAI,GAAG,OAAO;CACnC,OAAO,oBAAoB,MAAM,IAAI;AACvC"}

package/dist/features/paths/useAnchorFields.js

@@ -0,0 +1,35 @@
+import { anchorFieldsOf } from "../../interactions/actions/defaults/anchorFields.js";
+import { useMemo, useSyncExternalStore } from "react";
+import { useActionsRegistry, useOptionalDepRegistry } from "@weasel-js/routing/react";
+
+//#region src/features/paths/useAnchorFields.ts
+/**
+* The anchor fields of the path being edited, for chrome beside the canvas:
+* a panel showing the selected anchors' numbers and writing typed ones back.
+*/
+var noSubscribe = () => () => {};
+/**
+* The selected anchors' fields in the canvas in scope — the one last pressed
+* in, from chrome above several — kept current as the path, the anchor
+* selection, or the edited path changes. Outside any canvas it answers `{}`
+* and writes nothing.
+*/
+function useAnchorFields() {
+	const deps = useOptionalDepRegistry();
+	const actions = useActionsRegistry();
+	const snapshot = () => JSON.stringify(anchorFieldsOf(deps ? { editAnchors: deps.get("editAnchors") } : void 0));
+	const json = useSyncExternalStore(deps?.subscribe ?? noSubscribe, snapshot, snapshot);
+	return useMemo(() => ({
+		values: JSON.parse(json),
+		write: (field, entry) => {
+			actions?.trigger("setAnchorField", {
+				field,
+				...entry
+			});
+		}
+	}), [json, actions]);
+}
+
+//#endregion
+export { useAnchorFields };
+//# sourceMappingURL=useAnchorFields.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useAnchorFields.js","names":[],"sources":["../../../src/features/paths/useAnchorFields.ts"],"sourcesContent":["/**\n * The anchor fields of the path being edited, for chrome beside the canvas:\n * a panel showing the selected anchors' numbers and writing typed ones back.\n */\nimport { useMemo, useSyncExternalStore } from 'react';\nimport type { AnchorField, AnchorFieldValues, NumberEntry } from '@weasel-js/geom';\nimport { useActionsRegistry, useOptionalDepRegistry } from '@weasel-js/routing/react';\nimport { anchorFieldsOf } from 'interactions/actions/defaults/anchorFields';\n\n/** What {@link useAnchorFields} answers. */\nexport interface AnchorFieldsApi {\n  /** Each field's value: a number, `null` where the selected anchors differ,\n   *  no key where the field does not apply. Empty outside path edit or with no\n   *  anchor selected. */\n  values: AnchorFieldValues;\n  /** Write `entry` into `field` of every selected anchor, as one undo step,\n   *  through the `setAnchorField` action. */\n  write(field: AnchorField, entry: NumberEntry): void;\n}\n\nconst noSubscribe = (): (() => void) => () => {};\n\n/**\n * The selected anchors' fields in the canvas in scope — the one last pressed\n * in, from chrome above several — kept current as the path, the anchor\n * selection, or the edited path changes. Outside any canvas it answers `{}`\n * and writes nothing.\n */\nexport function useAnchorFields(): AnchorFieldsApi {\n  const deps = useOptionalDepRegistry();\n  const actions = useActionsRegistry();\n  const snapshot = (): string => JSON.stringify(anchorFieldsOf(deps ? { editAnchors: deps.get('editAnchors') } : undefined));\n  const json = useSyncExternalStore(deps?.subscribe ?? noSubscribe, snapshot, snapshot);\n  return useMemo(() => ({\n    values: JSON.parse(json) as AnchorFieldValues,\n    write: (field, entry) => { actions?.trigger('setAnchorField', { field, ...entry }); },\n  }), [json, actions]);\n}\n"],"mappings":";;;;;;;;;AAoBA,IAAM,0BAAwC,CAAC;;;;;;;AAQ/C,SAAgB,kBAAmC;CACjD,MAAM,OAAO,uBAAuB;CACpC,MAAM,UAAU,mBAAmB;CACnC,MAAM,iBAAyB,KAAK,UAAU,eAAe,OAAO,EAAE,aAAa,KAAK,IAAI,aAAa,EAAE,IAAI,MAAS,CAAC;CACzH,MAAM,OAAO,qBAAqB,MAAM,aAAa,aAAa,UAAU,QAAQ;CACpF,OAAO,eAAe;EACpB,QAAQ,KAAK,MAAM,IAAI;EACvB,QAAQ,OAAO,UAAU;GAAE,SAAS,QAAQ,kBAAkB;IAAE;IAAO,GAAG;GAAM,CAAC;EAAG;CACtF,IAAI,CAAC,MAAM,OAAO,CAAC;AACrB"}

package/dist/features/paths/usePathEdit.js

@@ -1,34 +1,64 @@
-import { rectFromPlane as e } from "../../core/viewport/parallax.js";
-import { liveEditablePath as t } from "./editablePath.js";
-import { createPathEditState as n } from "./pathEditState.js";
-import { createPathEditingOverlayLayer as r } from "./pathEditingOverlayLayer.js";
-import { useState as i } from "react";
-import { useLatest as a } from "@weasel-js/react";
+import { rectFromPlane } from "../../core/viewport/parallax.js";
+import { liveAnchorMarkers, liveEditablePath } from "./editablePath.js";
+import { createPathEditState } from "./pathEditState.js";
+import { createPathEditingOverlayLayer } from "./pathEditingOverlayLayer.js";
+import { useEffect, useMemo, useState } from "react";
+import { useLatest } from "@weasel-js/react";
+
 //#region src/features/paths/usePathEdit.ts
-function o(e) {
-	let t = a(e), [r] = i(() => n({
-		host: () => t.current.host,
-		isAllowed: () => t.current.isAllowed?.() ?? !0,
-		isSelectedNode: (e) => t.current.isSelectedNode(e)
-	}));
-	return r;
+/**
+* The path-edit state and its anchor overlay for one canvas surface.
+*/
+/** One state object for the life of the component, answering from the
+*  options of the last committed render. */
+function usePathEditState(options) {
+	const live = useLatest(options);
+	const [state] = useState(() => {
+		const made = createPathEditState({
+			host: () => live.current.host,
+			isAllowed: () => live.current.isAllowed?.() ?? true,
+			isSelectedNode: (id) => live.current.isSelectedNode(id),
+			extensions: options.extensions
+		});
+		const { opening } = options;
+		if (opening) {
+			made.setEditingId(opening.id);
+			made.setSelectedAnchors(new Set(opening.anchors ?? []));
+		}
+		return made;
+	});
+	useEffect(() => state.setExtensions(options.extensions), [state, options.extensions]);
+	return state;
 }
-function s(n, o) {
-	let s = a(o), [c] = i(() => ({
-		...r({
-			getEditingId: () => n.getEditingId() || null,
-			getPose: (e, n, r) => t(e, s.current.nodeOf(e), n, s.current.planeOfNode(e, r)),
-			getSelectedAnchors: n.getSelectedAnchors,
-			getMarquee: (t) => {
-				let r = n.getMarquee(), i = r ? s.current.planeOfNode(n.getEditingId(), t) : null;
-				return r && i ? e(i, r) : r;
-			}
+/** The anchor overlay for `state`, drawn as `config` says. Rebuilt when
+*  `config` changes, so pass a stable one; otherwise it reads `inputs` as of
+*  the last commit and repaints itself when the state changes. */
+function usePathEditOverlayLayer(state, inputs, config) {
+	const live = useLatest(inputs);
+	return useMemo(() => ({
+		...createPathEditingOverlayLayer({
+			getEditingId: () => state.getEditingId() || null,
+			getPose: (id, previews, view) => liveEditablePath(id, live.current.nodeOf(id), previews, live.current.planeOfNode(id, view), state.getExtensions()),
+			getAnchorMarkers: (id, previews) => liveAnchorMarkers(id, live.current.nodeOf(id), previews, state.getExtensions()),
+			getSelectedAnchors: state.getSelectedAnchors,
+			getSelectedMark: state.getSelectedMark,
+			getExtensions: state.getExtensions,
+			getNode: (id) => live.current.nodeOf(id) ?? null,
+			getMarquee: (view) => {
+				const rect = state.getMarquee();
+				const plane = rect ? live.current.planeOfNode(state.getEditingId(), view) : null;
+				return rect && plane ? rectFromPlane(plane, rect) : rect;
+			},
+			...config?.style ? { style: config.style } : {}
 		}),
-		subscribe: n.subscribe
-	}));
-	return c;
+		subscribe: state.subscribe
+	}), [
+		state,
+		live,
+		config
+	]);
 }
-//#endregion
-export { s as usePathEditOverlayLayer, o as usePathEditState };
 
+//#endregion
+export { usePathEditOverlayLayer, usePathEditState };
 //# sourceMappingURL=usePathEdit.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"usePathEdit.js","names":["usePathEditState","live","useLatest","options","state","useState","createPathEditState","id","usePathEditOverlayLayer","inputs","layer","createPathEditingOverlayLayer","liveEditablePath","previews","view","rect","plane","rectFromPlane"],"sources":["../../../src/features/paths/usePathEdit.ts"],"sourcesContent":["/**\n * The path-edit state and its anchor overlay for one canvas surface.\n */\nimport { useLatest } from '@weasel-js/react';\nimport { useState } from 'react';\nimport type { PathEditHost } from 'canvas/SceneCanvas/pathEditHost';\nimport type { RenderLayer } from 'core/layers/render';\nimport { rectFromPlane, type PlaneMap } from 'core/viewport/parallax';\nimport type { View } from 'core/viewport/view';\nimport { liveEditablePath, type EditableShape } from './editablePath';\nimport { createPathEditingOverlayLayer } from './pathEditingOverlayLayer';\nimport { createPathEditState, type PathEditState } from './pathEditState';\n\nexport interface UsePathEditStateOptions {\n  /** `<SceneCanvas pathEdit>`. */\n  host: PathEditHost | undefined;\n  /** See `PathEditSource.isAllowed`; absent when no mode registry is wired. */\n  isAllowed: (() => boolean) | undefined;\n  isSelectedNode: (id: string) => boolean;\n}\n\n/** One state object for the life of the component, answering from the\n *  options of the last committed render. */\nexport function usePathEditState(options: UsePathEditStateOptions): PathEditState {\n  const live = useLatest(options);\n  const [state] = useState(() => createPathEditState({\n    host: () => live.current.host,\n    isAllowed: () => live.current.isAllowed?.() ?? true,\n    isSelectedNode: (id) => live.current.isSelectedNode(id),\n  }));\n  return state;\n}\n\nexport interface PathEditOverlayInputs {\n  /** The committed node for an id, or nothing once it is gone. */\n  nodeOf: (id: string) => EditableShape | null | undefined;\n  /** How `view`'s world maps into the parallax plane `id` is drawn through. */\n  planeOfNode: (id: string, view: View) => PlaneMap | null;\n}\n\n/** The anchor overlay for `state`. Built once: it reads `inputs` as of the\n *  last commit and repaints itself when the state changes. */\nexport function usePathEditOverlayLayer(\n  state: PathEditState,\n  inputs: PathEditOverlayInputs,\n): RenderLayer<unknown> {\n  const live = useLatest(inputs);\n  const [layer] = useState<RenderLayer<unknown>>(() => ({\n    ...createPathEditingOverlayLayer({\n      getEditingId: () => state.getEditingId() || null,\n      getPose: (id, previews, view) =>\n        liveEditablePath(id, live.current.nodeOf(id), previews, live.current.planeOfNode(id, view)),\n      getSelectedAnchors: state.getSelectedAnchors,\n      // Drawn by an action that ran in the edited path's plane.\n      getMarquee: (view) => {\n        const rect = state.getMarquee();\n        const plane = rect ? live.current.planeOfNode(state.getEditingId(), view) : null;\n        return rect && plane ? rectFromPlane(plane, rect) : rect;\n      },\n    }),\n    subscribe: state.subscribe,\n  }));\n  return layer;\n}\n"],"mappings":";;;;;;;AAuBA,SAAgBA,EAAiB,GAAiD;CAChF,IAAMC,IAAOC,EAAUC,CAAO,GACxB,CAACC,KAASC,QAAeC,EAAoB;EACjD,YAAYL,EAAK,QAAQ;EACzB,iBAAiBA,EAAK,QAAQ,YAAY,KAAK;EAC/C,iBAAiB,MAAOA,EAAK,QAAQ,eAAeM,CAAE;CACxD,CAAC,CAAC;CACF,OAAOH;AACT;AAWA,SAAgBI,EACd,GACA,GACsB;CACtB,IAAMP,IAAOC,EAAUO,CAAM,GACvB,CAACC,KAASL,SAAsC;EACpD,GAAGM,EAA8B;GAC/B,oBAAoBP,EAAM,aAAa,KAAK;GAC5C,UAAU,GAAI,GAAU,MACtBQ,EAAiBL,GAAIN,EAAK,QAAQ,OAAOM,CAAE,GAAGM,GAAUZ,EAAK,QAAQ,YAAYM,GAAIO,CAAI,CAAC;GAC5F,oBAAoBV,EAAM;GAE1B,aAAa,MAAS;IACpB,IAAMW,IAAOX,EAAM,WAAW,GACxBY,IAAQD,IAAOd,EAAK,QAAQ,YAAYG,EAAM,aAAa,GAAGU,CAAI,IAAI;IAC5E,OAAOC,KAAQC,IAAQC,EAAcD,GAAOD,CAAI,IAAIA;GACtD;EACF,CAAC;EACD,WAAWX,EAAM;CACnB,EAAE;CACF,OAAOM;AACT"}
+{"version":3,"file":"usePathEdit.js","names":[],"sources":["../../../src/features/paths/usePathEdit.ts"],"sourcesContent":["/**\n * The path-edit state and its anchor overlay for one canvas surface.\n */\nimport { useLatest } from '@weasel-js/react';\nimport { useEffect, useMemo, useState } from 'react';\nimport type { PathEditHost, PathEditOpening } from 'canvas/SceneCanvas/pathEditHost';\nimport type { RenderLayer } from 'core/layers/render';\nimport { rectFromPlane, type PlaneMap } from 'core/viewport/parallax';\nimport type { View } from 'core/viewport/view';\nimport { liveAnchorMarkers, liveEditablePath, type EditableShape } from './editablePath';\nimport { createPathEditingOverlayLayer } from './pathEditingOverlayLayer';\nimport type { PathEditingOverlaySlotConfig } from 'canvas/layerSlots';\nimport { createPathEditState, type PathEditState } from './pathEditState';\nimport type { PathEditExtension } from './pathEditExtension';\n\nexport interface UsePathEditStateOptions {\n  /** `<SceneCanvas pathEdit>`. */\n  host: PathEditHost | undefined;\n  /** `<SceneCanvas defaultPathEdit>`: what the state starts holding. */\n  opening?: PathEditOpening;\n  /** See `PathEditSource.isAllowed`; absent when no mode registry is wired. */\n  isAllowed: (() => boolean) | undefined;\n  isSelectedNode: (id: string) => boolean;\n  /** The path-edit extensions the canvas's presets bring. */\n  extensions: readonly PathEditExtension[];\n}\n\n/** One state object for the life of the component, answering from the\n *  options of the last committed render. */\nexport function usePathEditState(options: UsePathEditStateOptions): PathEditState {\n  const live = useLatest(options);\n  const [state] = useState(() => {\n    const made = createPathEditState({\n      host: () => live.current.host,\n      isAllowed: () => live.current.isAllowed?.() ?? true,\n      isSelectedNode: (id) => live.current.isSelectedNode(id),\n      extensions: options.extensions,\n    });\n    const { opening } = options;\n    if (opening) {\n      made.setEditingId(opening.id);\n      made.setSelectedAnchors(new Set(opening.anchors ?? []));\n    }\n    return made;\n  });\n  useEffect(() => state.setExtensions(options.extensions), [state, options.extensions]);\n  return state;\n}\n\nexport interface PathEditOverlayInputs {\n  /** The committed node for an id, or nothing once it is gone. */\n  nodeOf: (id: string) => EditableShape | null | undefined;\n  /** How `view`'s world maps into the parallax plane `id` is drawn through. */\n  planeOfNode: (id: string, view: View) => PlaneMap | null;\n}\n\n/** The anchor overlay for `state`, drawn as `config` says. Rebuilt when\n *  `config` changes, so pass a stable one; otherwise it reads `inputs` as of\n *  the last commit and repaints itself when the state changes. */\nexport function usePathEditOverlayLayer(\n  state: PathEditState,\n  inputs: PathEditOverlayInputs,\n  config?: PathEditingOverlaySlotConfig,\n): RenderLayer<unknown> {\n  const live = useLatest(inputs);\n  return useMemo<RenderLayer<unknown>>(() => ({\n    ...createPathEditingOverlayLayer({\n      getEditingId: () => state.getEditingId() || null,\n      getPose: (id, previews, view) =>\n        liveEditablePath(id, live.current.nodeOf(id), previews, live.current.planeOfNode(id, view), state.getExtensions()),\n      getAnchorMarkers: (id, previews) => liveAnchorMarkers(id, live.current.nodeOf(id), previews, state.getExtensions()),\n      getSelectedAnchors: state.getSelectedAnchors,\n      getSelectedMark: state.getSelectedMark,\n      getExtensions: state.getExtensions,\n      getNode: (id) => live.current.nodeOf(id) ?? null,\n      // Drawn by an action that ran in the edited path's plane.\n      getMarquee: (view) => {\n        const rect = state.getMarquee();\n        const plane = rect ? live.current.planeOfNode(state.getEditingId(), view) : null;\n        return rect && plane ? rectFromPlane(plane, rect) : rect;\n      },\n      ...(config?.style ? { style: config.style } : {}),\n    }),\n    subscribe: state.subscribe,\n  }), [state, live, config]);\n}\n"],"mappings":";;;;;;;;;;;;;AA6BA,SAAgB,iBAAiB,SAAiD;CAChF,MAAM,OAAO,UAAU,OAAO;CAC9B,MAAM,CAAC,SAAS,eAAe;EAC7B,MAAM,OAAO,oBAAoB;GAC/B,YAAY,KAAK,QAAQ;GACzB,iBAAiB,KAAK,QAAQ,YAAY,KAAK;GAC/C,iBAAiB,OAAO,KAAK,QAAQ,eAAe,EAAE;GACtD,YAAY,QAAQ;EACtB,CAAC;EACD,MAAM,EAAE,YAAY;EACpB,IAAI,SAAS;GACX,KAAK,aAAa,QAAQ,EAAE;GAC5B,KAAK,mBAAmB,IAAI,IAAI,QAAQ,WAAW,CAAC,CAAC,CAAC;EACxD;EACA,OAAO;CACT,CAAC;CACD,gBAAgB,MAAM,cAAc,QAAQ,UAAU,GAAG,CAAC,OAAO,QAAQ,UAAU,CAAC;CACpF,OAAO;AACT;;;;AAYA,SAAgB,wBACd,OACA,QACA,QACsB;CACtB,MAAM,OAAO,UAAU,MAAM;CAC7B,OAAO,eAAqC;EAC1C,GAAG,8BAA8B;GAC/B,oBAAoB,MAAM,aAAa,KAAK;GAC5C,UAAU,IAAI,UAAU,SACtB,iBAAiB,IAAI,KAAK,QAAQ,OAAO,EAAE,GAAG,UAAU,KAAK,QAAQ,YAAY,IAAI,IAAI,GAAG,MAAM,cAAc,CAAC;GACnH,mBAAmB,IAAI,aAAa,kBAAkB,IAAI,KAAK,QAAQ,OAAO,EAAE,GAAG,UAAU,MAAM,cAAc,CAAC;GAClH,oBAAoB,MAAM;GAC1B,iBAAiB,MAAM;GACvB,eAAe,MAAM;GACrB,UAAU,OAAO,KAAK,QAAQ,OAAO,EAAE,KAAK;GAE5C,aAAa,SAAS;IACpB,MAAM,OAAO,MAAM,WAAW;IAC9B,MAAM,QAAQ,OAAO,KAAK,QAAQ,YAAY,MAAM,aAAa,GAAG,IAAI,IAAI;IAC5E,OAAO,QAAQ,QAAQ,cAAc,OAAO,IAAI,IAAI;GACtD;GACA,GAAI,QAAQ,QAAQ,EAAE,OAAO,OAAO,MAAM,IAAI,CAAC;EACjD,CAAC;EACD,WAAW,MAAM;CACnB,IAAI;EAAC;EAAO;EAAM;CAAM,CAAC;AAC3B"}

package/dist/features/poseRun/usePoseRun.js

@@ -1,62 +1,129 @@
-import { useCallback as e, useEffect as t, useMemo as n, useRef as r } from "react";
-import { useLatest as i, useVisibleRaf as a } from "@weasel-js/react";
+import { useCallback, useEffect, useMemo, useRef } from "react";
+import { useLatest, useVisibleRaf } from "@weasel-js/react";
+
 //#region src/features/poseRun/usePoseRun.ts
-function o(o) {
-	let s = i(o), c = r(/* @__PURE__ */ new Map()), l = r(null), u = r(!1), d = r(0), f = r(!0), p = e(() => {
-		let { scene: e } = s.current;
-		return l.current?.scene !== e && (l.current?.hold.drop(), l.current = {
-			scene: e,
-			hold: e.overrides.hold()
-		}), l.current.hold;
-	}, [s]), m = e(() => {
-		l.current?.hold.drop(), c.current.clear();
-	}, []), h = () => {
-		let e = s.current.scene, t = 0;
+/**
+* A pose run: poses published per frame, committed once.
+*
+* The frames go to `scene.overrides` — the ephemeral table a drag publishes
+* to — so an edge follows a node the run is moving, and the whole run lands as
+* one undo entry when it settles.
+*
+* **A node another gesture owns is pinned, not driven.** The run publishes
+* through a hold of its own, so an override it did not put there belongs to
+* somebody else — a drag, a resize. It never writes that id, never commits it,
+* and hands it to `step` as pinned so the producer can hold its neighbors
+* against it.
+*/
+/**
+* Drive node poses frame by frame through `scene.overrides`, committing them as
+* one undo entry when `step` reports done or `stop` is called. Idle until
+* `start`; unmounting abandons the run without writing.
+*/
+function usePoseRun(opts) {
+	const optsRef = useLatest(opts);
+	/** This frame's poses. */
+	const previews = useRef(/* @__PURE__ */ new Map());
+	/** The hold the run publishes through, and the scene it was taken from. */
+	const held = useRef(null);
+	const running = useRef(false);
+	const frame = useRef(0);
+	const mounted = useRef(true);
+	/** The hold on the scene the options name now. A run handed a different
+	*  scene mid-flight lets go of the old one's nodes. */
+	const holdNow = useCallback(() => {
+		const { scene } = optsRef.current;
+		if (held.current?.scene !== scene) {
+			held.current?.hold.drop();
+			held.current = {
+				scene,
+				hold: scene.overrides.hold()
+			};
+		}
+		return held.current.hold;
+	}, [optsRef]);
+	const release = useCallback(() => {
+		held.current?.hold.drop();
+		previews.current.clear();
+	}, []);
+	const commit = (finished) => {
+		const scene = optsRef.current.scene;
+		const also = optsRef.current.commitWith;
+		let moved = 0;
 		try {
-			c.current.size > 0 && e.batch(s.current.label ?? "Layout", () => {
-				for (let [n, r] of c.current) e.get(n) === void 0 || e.isLocked(n) || (e.setPose(n, r), t++);
+			if (previews.current.size > 0 || also !== void 0) scene.batch(optsRef.current.label ?? "Layout", () => {
+				for (const [id, pose] of previews.current) {
+					if (scene.get(id) === void 0 || scene.isLocked(id)) continue;
+					scene.setPose(id, pose);
+					moved++;
+				}
+				also?.(finished);
 			});
 		} finally {
-			m();
+			release();
 		}
-		s.current.onCommit?.(t);
-	}, g = (e) => {
-		u.current = !1, e.cancel();
-	}, _ = (e) => {
-		if (!f.current || !u.current) return;
-		let t = p(), n = t.others(), { poses: r, done: i } = s.current.step({
-			pinned: n,
-			frame: d.current
+		optsRef.current.onCommit?.(moved);
+	};
+	const halt = (loop) => {
+		running.current = false;
+		loop.cancel();
+	};
+	const tick = (loop) => {
+		if (!mounted.current || !running.current) return;
+		const hold = holdNow();
+		const pinned = hold.others();
+		const { poses, done } = optsRef.current.step({
+			pinned,
+			frame: frame.current
 		});
-		d.current++, c.current.clear();
-		for (let [e, t] of r) n.has(e) || c.current.set(e, t);
-		if (t.set(c.current), i) {
-			g(e), h();
+		frame.current++;
+		previews.current.clear();
+		for (const [id, pose] of poses) {
+			if (pinned.has(id)) continue;
+			previews.current.set(id, pose);
+		}
+		hold.set(previews.current);
+		if (done) {
+			halt(loop);
+			commit(true);
 			return;
 		}
-		e.request();
-	}, v = a((e, t) => {
-		_(t);
+		loop.request();
+	};
+	const loop = useVisibleRaf((_time, loop) => {
+		tick(loop);
 	}, {
-		requestFrame: o.requestFrame,
-		cancelFrame: o.cancelFrame
+		requestFrame: opts.requestFrame,
+		cancelFrame: opts.cancelFrame
 	});
-	return t(() => (f.current = !0, () => {
-		f.current = !1, v.cancel(), m();
-	}), [v, m]), n(() => ({
+	useEffect(() => {
+		mounted.current = true;
+		return () => {
+			mounted.current = false;
+			loop.cancel();
+			release();
+		};
+	}, [loop, release]);
+	return useMemo(() => ({
 		start() {
-			!u.current && f.current && (u.current = !0, d.current = 0, v.request());
+			if (running.current || !mounted.current) return;
+			running.current = true;
+			frame.current = 0;
+			loop.request();
 		},
 		stop() {
-			u.current && (g(v), h());
+			if (!running.current) return;
+			halt(loop);
+			commit(false);
 		},
 		cancel() {
-			g(v), m();
+			halt(loop);
+			release();
 		},
-		isRunning: () => u.current
-	}), [v]);
+		isRunning: () => running.current
+	}), [loop]);
 }
-//#endregion
-export { o as usePoseRun };
 
+//#endregion
+export { usePoseRun };
 //# sourceMappingURL=usePoseRun.js.map