@weasel-js/core 1.10.1 → 1.11.1

package/dist/features/snap/inputSubspace.js

@@ -0,0 +1,46 @@
+import { SNAP_AXIS_STEP } from "./roles.js";
+import { diagonal, edgeAxis } from "./resizeBox.js";
+import { stepLine } from "@weasel-js/geom/nd";
+
+//#region src/features/snap/inputSubspace.ts
+var PLANE = {
+	at: [0, 0],
+	dirs: [[1, 0], [0, 1]]
+};
+var AXES = [[1, 0], [0, 1]];
+/** `H`: the subspace of δ = pointer − press that the gesture's result stays
+*  in. `resize` is the box a resize drags, which an edge handle's axis and an
+*  aspect lock are read from; without it they run along the ctx axes. */
+function inputFlat(req, mods, delta0, resize) {
+	const h = req.handle;
+	if (h && h.x === "free" !== (h.y === "free")) {
+		const axis = resize ? edgeAxis(resize) : h.y === "free" ? {
+			x: 1,
+			y: 0
+		} : {
+			x: 0,
+			y: 1
+		};
+		return {
+			at: [0, 0],
+			dirs: [[axis.x, axis.y]]
+		};
+	}
+	const c = req.constrain;
+	if (!mods.constrain || c === void 0) return PLANE;
+	if (c === "axis") return stepLine([0, 0], [delta0.x, delta0.y], AXES, SNAP_AXIS_STEP);
+	if (c === "aspect") {
+		if (!resize || !h) return PLANE;
+		const d = diagonal(resize);
+		return {
+			at: [0, 0],
+			dirs: [[d.x, d.y]]
+		};
+	}
+	const origin = req.origin ?? req.press;
+	return stepLine([origin.x - req.press.x, origin.y - req.press.y], [delta0.x, delta0.y], AXES, c.step);
+}
+
+//#endregion
+export { inputFlat };
+//# sourceMappingURL=inputSubspace.js.map

package/dist/features/snap/inputSubspace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inputSubspace.js","names":[],"sources":["../../../src/features/snap/inputSubspace.ts"],"sourcesContent":["import { stepLine, type Flat } from '@weasel-js/geom/nd';\nimport type { SnapBegin, SnapMods } from 'interactions/actions/snapDep';\nimport { diagonal, edgeAxis, type ResizeSubject } from './resizeBox';\nimport { SNAP_AXIS_STEP } from './roles';\n\ntype Point = { x: number; y: number };\n\nconst PLANE: Flat = { at: [0, 0], dirs: [[1, 0], [0, 1]] };\nconst AXES = [[1, 0], [0, 1]] as const;\n\n/** `H`: the subspace of δ = pointer − press that the gesture's result stays\n *  in. `resize` is the box a resize drags, which an edge handle's axis and an\n *  aspect lock are read from; without it they run along the ctx axes. */\nexport function inputFlat(req: SnapBegin, mods: SnapMods, delta0: Point, resize?: ResizeSubject | null): Flat {\n  const h = req.handle;\n  if (h && (h.x === 'free') !== (h.y === 'free')) {\n    const axis = resize ? edgeAxis(resize)! : h.y === 'free' ? { x: 1, y: 0 } : { x: 0, y: 1 };\n    return { at: [0, 0], dirs: [[axis.x, axis.y]] };\n  }\n  const c = req.constrain;\n  if (!mods.constrain || c === undefined) return PLANE;\n  if (c === 'axis') return stepLine([0, 0], [delta0.x, delta0.y], AXES, SNAP_AXIS_STEP);\n  if (c === 'aspect') {\n    if (!resize || !h) return PLANE;\n    const d = diagonal(resize);\n    return { at: [0, 0], dirs: [[d.x, d.y]] };\n  }\n  const origin = req.origin ?? req.press;\n  return stepLine([origin.x - req.press.x, origin.y - req.press.y], [delta0.x, delta0.y], AXES, c.step);\n}\n"],"mappings":";;;;;AAOA,IAAM,QAAc;CAAE,IAAI,CAAC,GAAG,CAAC;CAAG,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAAE;AACzD,IAAM,OAAO,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;;;;AAK5B,SAAgB,UAAU,KAAgB,MAAgB,QAAe,QAAqC;CAC5G,MAAM,IAAI,IAAI;CACd,IAAI,KAAM,EAAE,MAAM,YAAa,EAAE,MAAM,SAAS;EAC9C,MAAM,OAAO,SAAS,SAAS,MAAM,IAAK,EAAE,MAAM,SAAS;GAAE,GAAG;GAAG,GAAG;EAAE,IAAI;GAAE,GAAG;GAAG,GAAG;EAAE;EACzF,OAAO;GAAE,IAAI,CAAC,GAAG,CAAC;GAAG,MAAM,CAAC,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC;EAAE;CAChD;CACA,MAAM,IAAI,IAAI;CACd,IAAI,CAAC,KAAK,aAAa,MAAM,QAAW,OAAO;CAC/C,IAAI,MAAM,QAAQ,OAAO,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,OAAO,GAAG,OAAO,CAAC,GAAG,MAAM,cAAc;CACpF,IAAI,MAAM,UAAU;EAClB,IAAI,CAAC,UAAU,CAAC,GAAG,OAAO;EAC1B,MAAM,IAAI,SAAS,MAAM;EACzB,OAAO;GAAE,IAAI,CAAC,GAAG,CAAC;GAAG,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC;EAAE;CAC1C;CACA,MAAM,SAAS,IAAI,UAAU,IAAI;CACjC,OAAO,SAAS,CAAC,OAAO,IAAI,IAAI,MAAM,GAAG,OAAO,IAAI,IAAI,MAAM,CAAC,GAAG,CAAC,OAAO,GAAG,OAAO,CAAC,GAAG,MAAM,EAAE,IAAI;AACtG"}

package/dist/features/snap/lazySession.js

@@ -0,0 +1,17 @@
+//#region src/features/snap/lazySession.ts
+/** A session of `dep` that begins on its first `at` or `angle`, so a press
+*  that never moves reads nothing of the scene. Null without a dep. */
+function lazySnapSession(dep, req) {
+	if (!dep) return null;
+	let begun = null;
+	const session = () => begun ??= dep.begin(req);
+	return {
+		at: (p, mods) => session().at(p, mods),
+		angle: (theta, mods) => session().angle(theta, mods),
+		end: () => begun?.end()
+	};
+}
+
+//#endregion
+export { lazySnapSession };
+//# sourceMappingURL=lazySession.js.map

package/dist/features/snap/lazySession.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazySession.js","names":[],"sources":["../../../src/features/snap/lazySession.ts"],"sourcesContent":["import type { SnapBegin, SnapDep, SnapSession } from 'interactions/actions/snapDep';\n\n/** A session of `dep` that begins on its first `at` or `angle`, so a press\n *  that never moves reads nothing of the scene. Null without a dep. */\nexport function lazySnapSession(dep: SnapDep | undefined, req: SnapBegin): SnapSession | null {\n  if (!dep) return null;\n  let begun: SnapSession | null = null;\n  const session = () => (begun ??= dep.begin(req));\n  return {\n    at: (p, mods) => session().at(p, mods),\n    angle: (theta, mods) => session().angle(theta, mods),\n    end: () => begun?.end(),\n  };\n}\n"],"mappings":";;;AAIA,SAAgB,gBAAgB,KAA0B,KAAoC;CAC5F,IAAI,CAAC,KAAK,OAAO;CACjB,IAAI,QAA4B;CAChC,MAAM,gBAAiB,UAAU,IAAI,MAAM,GAAG;CAC9C,OAAO;EACL,KAAK,GAAG,SAAS,QAAQ,CAAC,CAAC,GAAG,GAAG,IAAI;EACrC,QAAQ,OAAO,SAAS,QAAQ,CAAC,CAAC,MAAM,OAAO,IAAI;EACnD,WAAW,OAAO,IAAI;CACxB;AACF"}

package/dist/features/snap/marks.js

@@ -0,0 +1,29 @@
+import { fromPlane } from "../../core/viewport/parallax.js";
+
+//#region src/features/snap/marks.ts
+/** `marks` with repeats dropped, so a target several probes meet is drawn once. */
+function distinct(marks) {
+	const seen = /* @__PURE__ */ new Set();
+	return marks.filter((m) => {
+		const key = JSON.stringify(m);
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
+/** `m` carried out of a plane into the camera's world, where the readout draws. */
+function markFromPlane(m, plane) {
+	const pt = (p) => fromPlane(plane, p);
+	return m.kind === "point" ? {
+		...m,
+		at: pt(m.at)
+	} : {
+		...m,
+		from: pt(m.from),
+		to: pt(m.to)
+	};
+}
+
+//#endregion
+export { distinct, markFromPlane };
+//# sourceMappingURL=marks.js.map

package/dist/features/snap/marks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"marks.js","names":[],"sources":["../../../src/features/snap/marks.ts"],"sourcesContent":["import { fromPlane, type PlaneMap } from 'core/viewport/parallax';\nimport type { SnapMark } from './types';\n\ntype Point = { x: number; y: number };\n\n/** `marks` with repeats dropped, so a target several probes meet is drawn once. */\nexport function distinct<P>(marks: readonly SnapMark<P>[]): SnapMark<P>[] {\n  // A string key keeps this linear: comparing every pair field by field more\n  // than doubled a crowded row's frame time (culling.test.ts, 2026-10-18).\n  const seen = new Set<string>();\n  return marks.filter((m) => {\n    const key = JSON.stringify(m);\n    if (seen.has(key)) return false;\n    seen.add(key);\n    return true;\n  });\n}\n\n/** `m` carried out of a plane into the camera's world, where the readout draws. */\nexport function markFromPlane(m: SnapMark, plane: PlaneMap): SnapMark {\n  const pt = (p: Point) => fromPlane(plane, p);\n  return m.kind === 'point' ? { ...m, at: pt(m.at) } : { ...m, from: pt(m.from), to: pt(m.to) };\n}\n"],"mappings":";;;;AAMA,SAAgB,SAAY,OAA8C;CAGxE,MAAM,uBAAO,IAAI,IAAY;CAC7B,OAAO,MAAM,QAAQ,MAAM;EACzB,MAAM,MAAM,KAAK,UAAU,CAAC;EAC5B,IAAI,KAAK,IAAI,GAAG,GAAG,OAAO;EAC1B,KAAK,IAAI,GAAG;EACZ,OAAO;CACT,CAAC;AACH;;AAGA,SAAgB,cAAc,GAAa,OAA2B;CACpE,MAAM,MAAM,MAAa,UAAU,OAAO,CAAC;CAC3C,OAAO,EAAE,SAAS,UAAU;EAAE,GAAG;EAAG,IAAI,GAAG,EAAE,EAAE;CAAE,IAAI;EAAE,GAAG;EAAG,MAAM,GAAG,EAAE,IAAI;EAAG,IAAI,GAAG,EAAE,EAAE;CAAE;AAC9F"}

package/dist/features/snap/outcomeStore.js

@@ -0,0 +1,25 @@
+//#region src/features/snap/outcomeStore.ts
+var NONE = [];
+/** An empty outcome store, which notifies only when the marks change. */
+function createSnapOutcomeStore() {
+	let marks = NONE;
+	const listeners = /* @__PURE__ */ new Set();
+	return {
+		get: () => marks,
+		set(next) {
+			if (next.length === 0 && marks.length === 0) return;
+			marks = next.length === 0 ? NONE : next;
+			for (const l of [...listeners]) l();
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		}
+	};
+}
+
+//#endregion
+export { createSnapOutcomeStore };
+//# sourceMappingURL=outcomeStore.js.map

package/dist/features/snap/outcomeStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"outcomeStore.js","names":[],"sources":["../../../src/features/snap/outcomeStore.ts"],"sourcesContent":["import type { SnapMark } from './types';\n\ntype Point = { x: number; y: number };\n\n/** The marks of the snap in flight, for the readout to draw. */\nexport interface SnapOutcomeStore<P = Point> {\n  get(): readonly SnapMark<P>[];\n  set(marks: readonly SnapMark<P>[]): void;\n  subscribe(listener: () => void): () => void;\n}\n\nconst NONE: readonly never[] = [];\n\n/** An empty outcome store, which notifies only when the marks change. */\nexport function createSnapOutcomeStore<P = Point>(): SnapOutcomeStore<P> {\n  let marks: readonly SnapMark<P>[] = NONE;\n  const listeners = new Set<() => void>();\n  return {\n    get: () => marks,\n    set(next) {\n      if (next.length === 0 && marks.length === 0) return;\n      marks = next.length === 0 ? NONE : next;\n      for (const l of [...listeners]) l();\n    },\n    subscribe(listener) {\n      listeners.add(listener);\n      return () => { listeners.delete(listener); };\n    },\n  };\n}\n"],"mappings":";AAWA,IAAM,OAAyB,CAAC;;AAGhC,SAAgB,yBAAyD;CACvE,IAAI,QAAgC;CACpC,MAAM,4BAAY,IAAI,IAAgB;CACtC,OAAO;EACL,WAAW;EACX,IAAI,MAAM;GACR,IAAI,KAAK,WAAW,KAAK,MAAM,WAAW,GAAG;GAC7C,QAAQ,KAAK,WAAW,IAAI,OAAO;GACnC,KAAK,MAAM,KAAK,CAAC,GAAG,SAAS,GAAG,EAAE;EACpC;EACA,UAAU,UAAU;GAClB,UAAU,IAAI,QAAQ;GACtB,aAAa;IAAE,UAAU,OAAO,QAAQ;GAAG;EAC7C;CACF;AACF"}

package/dist/features/snap/pointSnap.js

@@ -0,0 +1,48 @@
+import { inputSession } from "./session2d.js";
+
+//#region src/features/snap/pointSnap.ts
+var FREE = {
+	suspend: false,
+	constrain: false
+};
+/** A {@link PointSnap}. With no `snap` dep, or one that runs no sessions,
+*  every point lands where it is. */
+function pointSnap() {
+	let live = null;
+	const begin = (dep, req) => dep?.begin(req) ?? inputSession(req);
+	const request = (p, origin) => ({
+		gesture: "point",
+		press: p,
+		...origin ? { origin } : {}
+	});
+	const stop = () => {
+		live?.session.end();
+		live = null;
+	};
+	return {
+		place(dep, p, mods, origin) {
+			const session = begin(dep, request(p, origin));
+			try {
+				return session.at(p, mods);
+			} finally {
+				session.end();
+			}
+		},
+		trail(dep, p, origin) {
+			if (!live || live.dep !== dep || live.origin?.x !== origin?.x || live.origin?.y !== origin?.y) {
+				stop();
+				live = {
+					session: begin(dep, request(p, origin)),
+					dep,
+					origin: origin && { ...origin }
+				};
+			}
+			return live.session.at(p, FREE).point;
+		},
+		stop
+	};
+}
+
+//#endregion
+export { pointSnap };
+//# sourceMappingURL=pointSnap.js.map

package/dist/features/snap/pointSnap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pointSnap.js","names":[],"sources":["../../../src/features/snap/pointSnap.ts"],"sourcesContent":["import type { SnapBegin, SnapDep, SnapMods, SnapOutcome, SnapSession } from 'interactions/actions/snapDep';\nimport { inputSession } from './session2d';\n\ntype Point = { x: number; y: number };\n\nconst FREE: SnapMods = { suspend: false, constrain: false };\n\n/** A drawing tool's point snapping: the points it places one by one, and the\n *  cursor it trails from the last of them. */\nexport interface PointSnap {\n  /** Where a point placed at `p` lands, in a `point` session of its own\n   *  whose `origin` is the point placed before. */\n  place(dep: SnapDep | undefined, p: Point, mods: SnapMods, origin?: Point): SnapOutcome;\n  /** Where the cursor at `p` lands. One session runs while `dep` and\n   *  `origin` stay the same, and its marks stay drawn until {@link stop}. */\n  trail(dep: SnapDep | undefined, p: Point, origin?: Point): Point;\n  /** End the cursor's session, clearing its marks. */\n  stop(): void;\n}\n\n/** A {@link PointSnap}. With no `snap` dep, or one that runs no sessions,\n *  every point lands where it is. */\nexport function pointSnap(): PointSnap {\n  let live: { session: SnapSession; dep: SnapDep | undefined; origin: Point | undefined } | null = null;\n  const begin = (dep: SnapDep | undefined, req: SnapBegin) => dep?.begin(req) ?? inputSession(req);\n  const request = (p: Point, origin: Point | undefined): SnapBegin => ({ gesture: 'point', press: p, ...(origin ? { origin } : {}) });\n  const stop = () => {\n    live?.session.end();\n    live = null;\n  };\n  return {\n    place(dep, p, mods, origin) {\n      const session = begin(dep, request(p, origin));\n      try {\n        return session.at(p, mods);\n      } finally {\n        session.end();\n      }\n    },\n    trail(dep, p, origin) {\n      if (!live || live.dep !== dep || live.origin?.x !== origin?.x || live.origin?.y !== origin?.y) {\n        stop();\n        live = { session: begin(dep, request(p, origin)), dep, origin: origin && { ...origin } };\n      }\n      return live.session.at(p, FREE).point;\n    },\n    stop,\n  };\n}\n"],"mappings":";;;AAKA,IAAM,OAAiB;CAAE,SAAS;CAAO,WAAW;AAAM;;;AAiB1D,SAAgB,YAAuB;CACrC,IAAI,OAA6F;CACjG,MAAM,SAAS,KAA0B,QAAmB,KAAK,MAAM,GAAG,KAAK,aAAa,GAAG;CAC/F,MAAM,WAAW,GAAU,YAA0C;EAAE,SAAS;EAAS,OAAO;EAAG,GAAI,SAAS,EAAE,OAAO,IAAI,CAAC;CAAG;CACjI,MAAM,aAAa;EACjB,MAAM,QAAQ,IAAI;EAClB,OAAO;CACT;CACA,OAAO;EACL,MAAM,KAAK,GAAG,MAAM,QAAQ;GAC1B,MAAM,UAAU,MAAM,KAAK,QAAQ,GAAG,MAAM,CAAC;GAC7C,IAAI;IACF,OAAO,QAAQ,GAAG,GAAG,IAAI;GAC3B,UAAU;IACR,QAAQ,IAAI;GACd;EACF;EACA,MAAM,KAAK,GAAG,QAAQ;GACpB,IAAI,CAAC,QAAQ,KAAK,QAAQ,OAAO,KAAK,QAAQ,MAAM,QAAQ,KAAK,KAAK,QAAQ,MAAM,QAAQ,GAAG;IAC7F,KAAK;IACL,OAAO;KAAE,SAAS,MAAM,KAAK,QAAQ,GAAG,MAAM,CAAC;KAAG;KAAK,QAAQ,UAAU,EAAE,GAAG,OAAO;IAAE;GACzF;GACA,OAAO,KAAK,QAAQ,GAAG,GAAG,IAAI,CAAC,CAAC;EAClC;EACA;CACF;AACF"}

package/dist/features/snap/probes2d.js

@@ -0,0 +1,99 @@
+import { unionBounds } from "../../core/geometry/unionBounds.js";
+import { resizeProbes, resizeSubject } from "./resizeBox.js";
+
+//#region src/features/snap/probes2d.ts
+/** The union drawn box of the subjects, or null when none is left. */
+function subjectBox(ids, reads) {
+	const boxes = [];
+	for (const id of ids) {
+		const pose = reads.pose(id);
+		if (pose !== void 0) boxes.push(reads.drawnBox(id, pose));
+	}
+	return unionBounds(boxes);
+}
+/** The subject of `req`, null where the gesture has none or nothing is left. */
+function subjectOf(req, reads) {
+	if (req.gesture === "move") return {
+		box: subjectBox(req.ids ?? [], reads),
+		resize: null
+	};
+	if (req.gesture !== "resize" || !req.handle) return {
+		box: null,
+		resize: null
+	};
+	if (req.box) return {
+		box: null,
+		resize: resizeSubject(req.box, req.handle)
+	};
+	const bounds = subjectBox(req.ids ?? [], reads);
+	return {
+		box: null,
+		resize: bounds ? resizeSubject({ bounds }, req.handle) : null
+	};
+}
+/** The probes a gesture snaps, where they are at press. */
+function buildProbes(req, reads, subject = subjectOf(req, reads)) {
+	const ids = req.ids ?? [];
+	switch (req.gesture) {
+		case "point": return [{
+			id: "pointer",
+			at: req.press,
+			role: "pointer"
+		}];
+		case "resize": return subject.resize ? resizeProbes(subject.resize) : [{
+			id: "pointer",
+			at: req.press,
+			role: "pointer"
+		}];
+		case "move": return moveProbes(req.press, ids, reads, subject.box);
+		case "rotate":
+		case "handle": return [];
+	}
+}
+function moveProbes(press, ids, reads, box) {
+	const out = [];
+	for (const id of ids) {
+		const pose = reads.pose(id);
+		if (pose !== void 0) out.push({
+			id: `origin:${id}`,
+			at: reads.origin(pose),
+			role: "origin"
+		});
+	}
+	if (box) out.push({
+		id: "box.min",
+		at: {
+			x: box.x,
+			y: box.y
+		},
+		role: "box"
+	}, {
+		id: "box.center",
+		at: {
+			x: box.x + box.width / 2,
+			y: box.y + box.height / 2
+		},
+		role: "box"
+	}, {
+		id: "box.max",
+		at: {
+			x: box.x + box.width,
+			y: box.y + box.height
+		},
+		role: "box"
+	});
+	const geometry = reads.geometryAt?.(press, ids) ?? press;
+	out.push({
+		id: "geometry",
+		at: {
+			x: geometry.x,
+			y: geometry.y
+		},
+		role: "geometry"
+	});
+	return out;
+}
+
+//#endregion
+export { buildProbes, subjectBox, subjectOf };
+//# sourceMappingURL=probes2d.js.map

package/dist/features/snap/probes2d.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"probes2d.js","names":[],"sources":["../../../src/features/snap/probes2d.ts"],"sourcesContent":["import { unionBounds } from 'core/geometry/unionBounds';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { SnapBegin } from 'interactions/actions/snapDep';\nimport type { SnapProbeAt } from './types';\nimport { resizeProbes, resizeSubject, type ResizeSubject } from './resizeBox';\n\ntype Point = { x: number; y: number };\n\n/** How a 2D session reads its subject at press. */\nexport interface ProbeReads {\n  /** `id`'s world pose now, or undefined when it is gone. */\n  pose(id: string): unknown;\n  /** The axis-aligned box `id` is drawn with at `pose`, stroke included. */\n  drawnBox(id: string, pose: unknown): Bounds;\n  /** The point of `pose` a grid rounds: its `OriginProjection` origin. */\n  origin(pose: unknown): Point;\n  /** The point of the subject's own geometry nearest `press`, or null. */\n  geometryAt?(press: Point, ids: readonly string[]): Point | null;\n}\n\n/** The union drawn box of the subjects, or null when none is left. */\nexport function subjectBox(ids: readonly string[], reads: ProbeReads): Bounds | null {\n  const boxes: Bounds[] = [];\n  for (const id of ids) {\n    const pose = reads.pose(id);\n    if (pose !== undefined) boxes.push(reads.drawnBox(id, pose));\n  }\n  return unionBounds(boxes);\n}\n\n/** What a gesture drags, read once at press. */\nexport interface Subject2d {\n  /** A move's subjects' union drawn box. */\n  box: Bounds | null;\n  /** A resize's box and frame: the one it names, else the subjects' drawn\n   *  box, axis-aligned. */\n  resize: ResizeSubject | null;\n}\n\n/** The subject of `req`, null where the gesture has none or nothing is left. */\nexport function subjectOf(req: SnapBegin, reads: ProbeReads): Subject2d {\n  if (req.gesture === 'move') return { box: subjectBox(req.ids ?? [], reads), resize: null };\n  if (req.gesture !== 'resize' || !req.handle) return { box: null, resize: null };\n  if (req.box) return { box: null, resize: resizeSubject(req.box, req.handle) };\n  const bounds = subjectBox(req.ids ?? [], reads);\n  return { box: null, resize: bounds ? resizeSubject({ bounds }, req.handle) : null };\n}\n\n/** The probes a gesture snaps, where they are at press. */\nexport function buildProbes(req: SnapBegin, reads: ProbeReads, subject = subjectOf(req, reads)): SnapProbeAt[] {\n  const ids = req.ids ?? [];\n  switch (req.gesture) {\n    case 'point':\n      return [{ id: 'pointer', at: req.press, role: 'pointer' }];\n    case 'resize':\n      return subject.resize ? resizeProbes(subject.resize) : [{ id: 'pointer', at: req.press, role: 'pointer' }];\n    case 'move':\n      return moveProbes(req.press, ids, reads, subject.box);\n    case 'rotate':\n    case 'handle':\n      return [];\n  }\n}\n\nfunction moveProbes(press: Point, ids: readonly string[], reads: ProbeReads, box: Bounds | null): SnapProbeAt[] {\n  const out: SnapProbeAt[] = [];\n  for (const id of ids) {\n    const pose = reads.pose(id);\n    if (pose !== undefined) out.push({ id: `origin:${id}`, at: reads.origin(pose), role: 'origin' });\n  }\n  if (box) {\n    out.push(\n      { id: 'box.min', at: { x: box.x, y: box.y }, role: 'box' },\n      { id: 'box.center', at: { x: box.x + box.width / 2, y: box.y + box.height / 2 }, role: 'box' },\n      { id: 'box.max', at: { x: box.x + box.width, y: box.y + box.height }, role: 'box' },\n    );\n  }\n  const geometry = reads.geometryAt?.(press, ids) ?? press;\n  out.push({ id: 'geometry', at: { x: geometry.x, y: geometry.y }, role: 'geometry' });\n  return out;\n}\n"],"mappings":";;;;;AAqBA,SAAgB,WAAW,KAAwB,OAAkC;CACnF,MAAM,QAAkB,CAAC;CACzB,KAAK,MAAM,MAAM,KAAK;EACpB,MAAM,OAAO,MAAM,KAAK,EAAE;EAC1B,IAAI,SAAS,QAAW,MAAM,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC;CAC7D;CACA,OAAO,YAAY,KAAK;AAC1B;;AAYA,SAAgB,UAAU,KAAgB,OAA8B;CACtE,IAAI,IAAI,YAAY,QAAQ,OAAO;EAAE,KAAK,WAAW,IAAI,OAAO,CAAC,GAAG,KAAK;EAAG,QAAQ;CAAK;CACzF,IAAI,IAAI,YAAY,YAAY,CAAC,IAAI,QAAQ,OAAO;EAAE,KAAK;EAAM,QAAQ;CAAK;CAC9E,IAAI,IAAI,KAAK,OAAO;EAAE,KAAK;EAAM,QAAQ,cAAc,IAAI,KAAK,IAAI,MAAM;CAAE;CAC5E,MAAM,SAAS,WAAW,IAAI,OAAO,CAAC,GAAG,KAAK;CAC9C,OAAO;EAAE,KAAK;EAAM,QAAQ,SAAS,cAAc,EAAE,OAAO,GAAG,IAAI,MAAM,IAAI;CAAK;AACpF;;AAGA,SAAgB,YAAY,KAAgB,OAAmB,UAAU,UAAU,KAAK,KAAK,GAAkB;CAC7G,MAAM,MAAM,IAAI,OAAO,CAAC;CACxB,QAAQ,IAAI,SAAZ;EACE,KAAK,SACH,OAAO,CAAC;GAAE,IAAI;GAAW,IAAI,IAAI;GAAO,MAAM;EAAU,CAAC;EAC3D,KAAK,UACH,OAAO,QAAQ,SAAS,aAAa,QAAQ,MAAM,IAAI,CAAC;GAAE,IAAI;GAAW,IAAI,IAAI;GAAO,MAAM;EAAU,CAAC;EAC3G,KAAK,QACH,OAAO,WAAW,IAAI,OAAO,KAAK,OAAO,QAAQ,GAAG;EACtD,KAAK;EACL,KAAK,UACH,OAAO,CAAC;CACZ;AACF;AAEA,SAAS,WAAW,OAAc,KAAwB,OAAmB,KAAmC;CAC9G,MAAM,MAAqB,CAAC;CAC5B,KAAK,MAAM,MAAM,KAAK;EACpB,MAAM,OAAO,MAAM,KAAK,EAAE;EAC1B,IAAI,SAAS,QAAW,IAAI,KAAK;GAAE,IAAI,UAAU;GAAM,IAAI,MAAM,OAAO,IAAI;GAAG,MAAM;EAAS,CAAC;CACjG;CACA,IAAI,KACF,IAAI,KACF;EAAE,IAAI;EAAW,IAAI;GAAE,GAAG,IAAI;GAAG,GAAG,IAAI;EAAE;EAAG,MAAM;CAAM,GACzD;EAAE,IAAI;EAAc,IAAI;GAAE,GAAG,IAAI,IAAI,IAAI,QAAQ;GAAG,GAAG,IAAI,IAAI,IAAI,SAAS;EAAE;EAAG,MAAM;CAAM,GAC7F;EAAE,IAAI;EAAW,IAAI;GAAE,GAAG,IAAI,IAAI,IAAI;GAAO,GAAG,IAAI,IAAI,IAAI;EAAO;EAAG,MAAM;CAAM,CACpF;CAEF,MAAM,WAAW,MAAM,aAAa,OAAO,GAAG,KAAK;CACnD,IAAI,KAAK;EAAE,IAAI;EAAY,IAAI;GAAE,GAAG,SAAS;GAAG,GAAG,SAAS;EAAE;EAAG,MAAM;CAAW,CAAC;CACnF,OAAO;AACT"}

package/dist/features/snap/readoutDraw.js

@@ -0,0 +1,93 @@
+import { pathSnapGlyph } from "../paths/pathSnap/glyphs.js";
+import { textCommand, textCommandFromRuns } from "@weasel-js/renderer";
+import { PATH_L, PATH_M, pathFromD, rectPath } from "@weasel-js/geom";
+
+//#region src/features/snap/readoutDraw.ts
+/**
+* The screen-space drawing the snap readout and the guides overlay share:
+* ticked segments, number pills, and the glyph-and-label of a point mark.
+*/
+var PILL_FONT = { fontSize: 10 };
+var PILL_CHAR_W = 6;
+var PILL_H = 14;
+var PILL_PAD_X = 4;
+/** A straight segment from (x0, y0) to (x1, y1), with a tick of length `t`
+*  across each end. Screen px. */
+function tickedSegment(x0, y0, x1, y1, t) {
+	const h = t / 2;
+	const len = Math.hypot(x1 - x0, y1 - y0);
+	const [nx, ny] = x0 === x1 ? [1, 0] : y0 === y1 || len === 0 ? [0, 1] : [-(y1 - y0) / len, (x1 - x0) / len];
+	const coords = [
+		x0,
+		y0,
+		x1,
+		y1,
+		...t <= 0 ? [] : [
+			x0 - nx * h,
+			y0 - ny * h,
+			x0 + nx * h,
+			y0 + ny * h,
+			x1 - nx * h,
+			y1 - ny * h,
+			x1 + nx * h,
+			y1 + ny * h
+		]
+	];
+	const commands = [];
+	for (let i = 0; i < coords.length; i += 4) commands.push(PATH_M, PATH_L);
+	return {
+		kind: "polygon",
+		commands: new Uint8Array(commands),
+		coords: new Float32Array(coords),
+		fillRule: "nonzero"
+	};
+}
+/** `text` on a filled pill centered at (cx, cy), in white on `color`. */
+function pillCommands(cx, cy, text, color) {
+	const w = text.length * PILL_CHAR_W + 8;
+	const left = cx - w / 2;
+	const top = cy - PILL_H / 2;
+	return [{
+		kind: "path",
+		path: rectPath(left, top, w, PILL_H),
+		fill: { paint: {
+			kind: "solid",
+			color
+		} }
+	}, textCommandFromRuns(left + PILL_PAD_X, top + 2, [{
+		text,
+		fill: { paint: {
+			kind: "solid",
+			color: "#fff"
+		} }
+	}], PILL_FONT)];
+}
+/** A ticked segment between two screen points, with `label` on a pill at its middle. */
+function measuredSegmentCommands(x0, y0, x1, y1, ticks, stroke, label, color) {
+	const out = [{
+		kind: "path",
+		path: tickedSegment(x0, y0, x1, y1, ticks),
+		stroke
+	}];
+	if (label !== null) out.push(...pillCommands((x0 + x1) / 2, (y0 + y1) / 2, label, color));
+	return out;
+}
+/** The glyph for `glyph` on (x, y), `r` from center to edge, with `label`
+*  above and to its right. An unknown glyph name draws as `anchor`. */
+function glyphCommands(glyph, x, y, label, color, r = 5, fontSize = 11) {
+	const d = pathSnapGlyph(glyph, x, y, r) ?? pathSnapGlyph("anchor", x, y, r);
+	const out = [{
+		kind: "path",
+		path: pathFromD(d),
+		stroke: {
+			paint: { color },
+			width: 1.5
+		}
+	}];
+	if (label) out.push(textCommand(x + r + 3, y - r - fontSize - 2, label, { fontSize }, void 0, void 0, void 0, { fill: { paint: { color } } }));
+	return out;
+}
+
+//#endregion
+export { glyphCommands, measuredSegmentCommands, pillCommands, tickedSegment };
+//# sourceMappingURL=readoutDraw.js.map

package/dist/features/snap/readoutDraw.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"readoutDraw.js","names":[],"sources":["../../../src/features/snap/readoutDraw.ts"],"sourcesContent":["/**\n * The screen-space drawing the snap readout and the guides overlay share:\n * ticked segments, number pills, and the glyph-and-label of a point mark.\n */\nimport { PATH_L, PATH_M, pathFromD, rectPath, type PolygonPath, type PathSnapKind } from '@weasel-js/geom';\nimport { textCommand, textCommandFromRuns, type CommandStroke, type DrawCommand } from '@weasel-js/renderer';\nimport { pathSnapGlyph } from 'features/paths/pathSnap/glyphs';\n\nconst PILL_FONT = { fontSize: 10 };\n// No text measurer in a layer: a 10px digit advances about 6px.\nconst PILL_CHAR_W = 6;\nconst PILL_H = 14;\nconst PILL_PAD_X = 4;\n\n/** A straight segment from (x0, y0) to (x1, y1), with a tick of length `t`\n *  across each end. Screen px. */\nexport function tickedSegment(x0: number, y0: number, x1: number, y1: number, t: number): PolygonPath {\n  const h = t / 2;\n  const len = Math.hypot(x1 - x0, y1 - y0);\n  // Across the segment: the pixel axes when it runs along one, else its normal.\n  const [nx, ny] = x0 === x1 ? [1, 0] : y0 === y1 || len === 0 ? [0, 1] : [-(y1 - y0) / len, (x1 - x0) / len];\n  const ends = t <= 0 ? [] : [\n    x0 - nx * h, y0 - ny * h, x0 + nx * h, y0 + ny * h,\n    x1 - nx * h, y1 - ny * h, x1 + nx * h, y1 + ny * h,\n  ];\n  const coords = [x0, y0, x1, y1, ...ends];\n  const commands: number[] = [];\n  for (let i = 0; i < coords.length; i += 4) commands.push(PATH_M, PATH_L);\n  return {\n    kind: 'polygon',\n    commands: new Uint8Array(commands),\n    coords: new Float32Array(coords),\n    fillRule: 'nonzero',\n  };\n}\n\n/** `text` on a filled pill centered at (cx, cy), in white on `color`. */\nexport function pillCommands(cx: number, cy: number, text: string, color: string): DrawCommand[] {\n  const w = text.length * PILL_CHAR_W + PILL_PAD_X * 2;\n  const left = cx - w / 2;\n  const top = cy - PILL_H / 2;\n  return [\n    { kind: 'path', path: rectPath(left, top, w, PILL_H), fill: { paint: { kind: 'solid', color } } },\n    textCommandFromRuns(left + PILL_PAD_X, top + 2, [{ text, fill: { paint: { kind: 'solid', color: '#fff' } } }], PILL_FONT),\n  ];\n}\n\n/** A ticked segment between two screen points, with `label` on a pill at its middle. */\nexport function measuredSegmentCommands(\n  x0: number, y0: number, x1: number, y1: number,\n  ticks: number, stroke: CommandStroke, label: string | null, color: string,\n): DrawCommand[] {\n  const out: DrawCommand[] = [{ kind: 'path', path: tickedSegment(x0, y0, x1, y1, ticks), stroke }];\n  if (label !== null) out.push(...pillCommands((x0 + x1) / 2, (y0 + y1) / 2, label, color));\n  return out;\n}\n\n/** The glyph for `glyph` on (x, y), `r` from center to edge, with `label`\n *  above and to its right. An unknown glyph name draws as `anchor`. */\nexport function glyphCommands(\n  glyph: string, x: number, y: number, label: string | undefined, color: string, r = 5, fontSize = 11,\n): DrawCommand[] {\n  const d = pathSnapGlyph(glyph as PathSnapKind, x, y, r) ?? pathSnapGlyph('anchor', x, y, r);\n  const out: DrawCommand[] = [\n    { kind: 'path', path: pathFromD(d), stroke: { paint: { color }, width: 1.5 } },\n  ];\n  if (label) {\n    out.push(textCommand(x + r + 3, y - r - fontSize - 2, label, { fontSize }, undefined, undefined, undefined, {\n      fill: { paint: { color } },\n    }));\n  }\n  return out;\n}\n"],"mappings":";;;;;;;;;AAQA,IAAM,YAAY,EAAE,UAAU,GAAG;AAEjC,IAAM,cAAc;AACpB,IAAM,SAAS;AACf,IAAM,aAAa;;;AAInB,SAAgB,cAAc,IAAY,IAAY,IAAY,IAAY,GAAwB;CACpG,MAAM,IAAI,IAAI;CACd,MAAM,MAAM,KAAK,MAAM,KAAK,IAAI,KAAK,EAAE;CAEvC,MAAM,CAAC,IAAI,MAAM,OAAO,KAAK,CAAC,GAAG,CAAC,IAAI,OAAO,MAAM,QAAQ,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,KAAK,MAAM,MAAM,KAAK,MAAM,GAAG;CAK1G,MAAM,SAAS;EAAC;EAAI;EAAI;EAAI;EAAI,GAJnB,KAAK,IAAI,CAAC,IAAI;GACzB,KAAK,KAAK;GAAG,KAAK,KAAK;GAAG,KAAK,KAAK;GAAG,KAAK,KAAK;GACjD,KAAK,KAAK;GAAG,KAAK,KAAK;GAAG,KAAK,KAAK;GAAG,KAAK,KAAK;EACnD;CACuC;CACvC,MAAM,WAAqB,CAAC;CAC5B,KAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK,GAAG,SAAS,KAAK,QAAQ,MAAM;CACvE,OAAO;EACL,MAAM;EACN,UAAU,IAAI,WAAW,QAAQ;EACjC,QAAQ,IAAI,aAAa,MAAM;EAC/B,UAAU;CACZ;AACF;;AAGA,SAAgB,aAAa,IAAY,IAAY,MAAc,OAA8B;CAC/F,MAAM,IAAI,KAAK,SAAS,cAAc;CACtC,MAAM,OAAO,KAAK,IAAI;CACtB,MAAM,MAAM,KAAK,SAAS;CAC1B,OAAO,CACL;EAAE,MAAM;EAAQ,MAAM,SAAS,MAAM,KAAK,GAAG,MAAM;EAAG,MAAM,EAAE,OAAO;GAAE,MAAM;GAAS;EAAM,EAAE;CAAE,GAChG,oBAAoB,OAAO,YAAY,MAAM,GAAG,CAAC;EAAE;EAAM,MAAM,EAAE,OAAO;GAAE,MAAM;GAAS,OAAO;EAAO,EAAE;CAAE,CAAC,GAAG,SAAS,CAC1H;AACF;;AAGA,SAAgB,wBACd,IAAY,IAAY,IAAY,IACpC,OAAe,QAAuB,OAAsB,OAC7C;CACf,MAAM,MAAqB,CAAC;EAAE,MAAM;EAAQ,MAAM,cAAc,IAAI,IAAI,IAAI,IAAI,KAAK;EAAG;CAAO,CAAC;CAChG,IAAI,UAAU,MAAM,IAAI,KAAK,GAAG,cAAc,KAAK,MAAM,IAAI,KAAK,MAAM,GAAG,OAAO,KAAK,CAAC;CACxF,OAAO;AACT;;;AAIA,SAAgB,cACd,OAAe,GAAW,GAAW,OAA2B,OAAe,IAAI,GAAG,WAAW,IAClF;CACf,MAAM,IAAI,cAAc,OAAuB,GAAG,GAAG,CAAC,KAAK,cAAc,UAAU,GAAG,GAAG,CAAC;CAC1F,MAAM,MAAqB,CACzB;EAAE,MAAM;EAAQ,MAAM,UAAU,CAAC;EAAG,QAAQ;GAAE,OAAO,EAAE,MAAM;GAAG,OAAO;EAAI;CAAE,CAC/E;CACA,IAAI,OACF,IAAI,KAAK,YAAY,IAAI,IAAI,GAAG,IAAI,IAAI,WAAW,GAAG,OAAO,EAAE,SAAS,GAAG,QAAW,QAAW,QAAW,EAC1G,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,EAC3B,CAAC,CAAC;CAEJ,OAAO;AACT"}

package/dist/features/snap/readoutLayer.js

@@ -0,0 +1,49 @@
+import { viewToTransform } from "../../core/viewport/view.js";
+import { worldToScreen } from "../../core/viewport/viewTransform.js";
+import { glyphCommands, measuredSegmentCommands } from "./readoutDraw.js";
+
+//#region src/features/snap/readoutLayer.ts
+var TICK = 6;
+/** A screen-space layer drawing the marks in `store`, redrawn when they change. */
+function createSnapReadoutLayer(store, style = {}) {
+	const color = style.color ?? "#e8742c";
+	const gapColor = style.gapColor ?? "#3aa0ff";
+	const width = style.lineWidth ?? 1;
+	const strokeOf = (c) => ({
+		paint: {
+			kind: "solid",
+			color: c
+		},
+		width
+	});
+	return {
+		id: "snap-readout",
+		label: "Snap readout",
+		space: "screen",
+		alwaysOn: true,
+		subscribe: (repaint) => store.subscribe(repaint),
+		draw: (_data, view) => {
+			const marks = store.get();
+			if (marks.length === 0) return [];
+			const t = viewToTransform(view);
+			const out = [];
+			for (const m of marks) {
+				const measured = m.kind === "gap" || m.kind === "distance";
+				const c = m.color ?? (measured ? gapColor : color);
+				if (m.kind === "point") {
+					const [x, y] = worldToScreen(m.at.x, m.at.y, t);
+					out.push(...glyphCommands(m.glyph, x, y, m.label, c));
+					continue;
+				}
+				const [x0, y0] = worldToScreen(m.from.x, m.from.y, t);
+				const [x1, y1] = worldToScreen(m.to.x, m.to.y, t);
+				out.push(...measuredSegmentCommands(x0, y0, x1, y1, measured ? TICK : 0, strokeOf(c), measured ? String(Math.round(m.value)) : null, c));
+			}
+			return out;
+		}
+	};
+}
+
+//#endregion
+export { createSnapReadoutLayer };
+//# sourceMappingURL=readoutLayer.js.map

package/dist/features/snap/readoutLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"readoutLayer.js","names":[],"sources":["../../../src/features/snap/readoutLayer.ts"],"sourcesContent":["/** The one layer that draws what a snap won: every mark in the outcome store. */\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport type { RenderLayer } from 'core/layers/render';\nimport { viewToTransform } from 'core/viewport/view';\nimport { worldToScreen } from 'core/viewport/viewTransform';\nimport type { SnapOutcomeStore } from './outcomeStore';\nimport { glyphCommands, measuredSegmentCommands } from './readoutDraw';\nimport type { SnapReadoutStyle } from './types';\n\nconst TICK = 6;\n\n/** A screen-space layer drawing the marks in `store`, redrawn when they change. */\nexport function createSnapReadoutLayer(\n  store: SnapOutcomeStore,\n  style: SnapReadoutStyle = {},\n): RenderLayer<unknown> {\n  const color = style.color ?? '#e8742c';\n  const gapColor = style.gapColor ?? '#3aa0ff';\n  const width = style.lineWidth ?? 1;\n  const strokeOf = (c: string) => ({ paint: { kind: 'solid' as const, color: c }, width });\n  return {\n    id: 'snap-readout',\n    label: 'Snap readout',\n    space: 'screen',\n    alwaysOn: true,\n    subscribe: (repaint) => store.subscribe(repaint),\n    draw: (_data, view) => {\n      const marks = store.get();\n      if (marks.length === 0) return [];\n      const t = viewToTransform(view);\n      const out: DrawCommand[] = [];\n      for (const m of marks) {\n        const measured = m.kind === 'gap' || m.kind === 'distance';\n        const c = m.color ?? (measured ? gapColor : color);\n        if (m.kind === 'point') {\n          const [x, y] = worldToScreen(m.at.x, m.at.y, t);\n          out.push(...glyphCommands(m.glyph, x, y, m.label, c));\n          continue;\n        }\n        const [x0, y0] = worldToScreen(m.from.x, m.from.y, t);\n        const [x1, y1] = worldToScreen(m.to.x, m.to.y, t);\n        out.push(...measuredSegmentCommands(\n          x0, y0, x1, y1, measured ? TICK : 0, strokeOf(c), measured ? String(Math.round(m.value)) : null, c,\n        ));\n      }\n      return out;\n    },\n  };\n}\n"],"mappings":";;;;;AASA,IAAM,OAAO;;AAGb,SAAgB,uBACd,OACA,QAA0B,CAAC,GACL;CACtB,MAAM,QAAQ,MAAM,SAAS;CAC7B,MAAM,WAAW,MAAM,YAAY;CACnC,MAAM,QAAQ,MAAM,aAAa;CACjC,MAAM,YAAY,OAAe;EAAE,OAAO;GAAE,MAAM;GAAkB,OAAO;EAAE;EAAG;CAAM;CACtF,OAAO;EACL,IAAI;EACJ,OAAO;EACP,OAAO;EACP,UAAU;EACV,YAAY,YAAY,MAAM,UAAU,OAAO;EAC/C,OAAO,OAAO,SAAS;GACrB,MAAM,QAAQ,MAAM,IAAI;GACxB,IAAI,MAAM,WAAW,GAAG,OAAO,CAAC;GAChC,MAAM,IAAI,gBAAgB,IAAI;GAC9B,MAAM,MAAqB,CAAC;GAC5B,KAAK,MAAM,KAAK,OAAO;IACrB,MAAM,WAAW,EAAE,SAAS,SAAS,EAAE,SAAS;IAChD,MAAM,IAAI,EAAE,UAAU,WAAW,WAAW;IAC5C,IAAI,EAAE,SAAS,SAAS;KACtB,MAAM,CAAC,GAAG,KAAK,cAAc,EAAE,GAAG,GAAG,EAAE,GAAG,GAAG,CAAC;KAC9C,IAAI,KAAK,GAAG,cAAc,EAAE,OAAO,GAAG,GAAG,EAAE,OAAO,CAAC,CAAC;KACpD;IACF;IACA,MAAM,CAAC,IAAI,MAAM,cAAc,EAAE,KAAK,GAAG,EAAE,KAAK,GAAG,CAAC;IACpD,MAAM,CAAC,IAAI,MAAM,cAAc,EAAE,GAAG,GAAG,EAAE,GAAG,GAAG,CAAC;IAChD,IAAI,KAAK,GAAG,wBACV,IAAI,IAAI,IAAI,IAAI,WAAW,OAAO,GAAG,SAAS,CAAC,GAAG,WAAW,OAAO,KAAK,MAAM,EAAE,KAAK,CAAC,IAAI,MAAM,CACnG,CAAC;GACH;GACA,OAAO;EACT;CACF;AACF"}

package/dist/features/snap/registry.js

@@ -0,0 +1,27 @@
+import { createContext, useContext, useEffect } from "react";
+
+//#region src/features/snap/registry.ts
+function createSnapSourceRegistry() {
+	let sources = [];
+	return {
+		list: () => sources,
+		add(source) {
+			sources = [...sources, source];
+			return () => {
+				sources = sources.filter((s) => s !== source);
+			};
+		}
+	};
+}
+var SnapSourceRegistryContext = createContext(null);
+/** Adds `source` to the enclosing `<SceneCanvas>`'s snapping while mounted.
+*  Pass a stable object: a new one each render re-registers it. */
+function useSnapSource(source) {
+	const registry = useContext(SnapSourceRegistryContext);
+	if (!registry) throw new Error("[useSnapSource] call it under a <SceneCanvas>");
+	useEffect(() => registry.add(source), [registry, source]);
+}
+
+//#endregion
+export { SnapSourceRegistryContext, createSnapSourceRegistry, useSnapSource };
+//# sourceMappingURL=registry.js.map

package/dist/features/snap/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","names":[],"sources":["../../../src/features/snap/registry.ts"],"sourcesContent":["import { createContext, useContext, useEffect } from 'react';\nimport type { SnapSource } from './types';\n\n/** The sources contributed to one canvas by {@link useSnapSource}, in mount order. */\nexport interface SnapSourceRegistry {\n  list(): readonly SnapSource[];\n  add(source: SnapSource): () => void;\n}\n\nexport function createSnapSourceRegistry(): SnapSourceRegistry {\n  let sources: readonly SnapSource[] = [];\n  return {\n    list: () => sources,\n    add(source) {\n      sources = [...sources, source];\n      return () => { sources = sources.filter((s) => s !== source); };\n    },\n  };\n}\n\nexport const SnapSourceRegistryContext = createContext<SnapSourceRegistry | null>(null);\n\n/** Adds `source` to the enclosing `<SceneCanvas>`'s snapping while mounted.\n *  Pass a stable object: a new one each render re-registers it. */\nexport function useSnapSource(source: SnapSource): void {\n  const registry = useContext(SnapSourceRegistryContext);\n  if (!registry) throw new Error('[useSnapSource] call it under a <SceneCanvas>');\n  useEffect(() => registry.add(source), [registry, source]);\n}\n"],"mappings":";;;AASA,SAAgB,2BAA+C;CAC7D,IAAI,UAAiC,CAAC;CACtC,OAAO;EACL,YAAY;EACZ,IAAI,QAAQ;GACV,UAAU,CAAC,GAAG,SAAS,MAAM;GAC7B,aAAa;IAAE,UAAU,QAAQ,QAAQ,MAAM,MAAM,MAAM;GAAG;EAChE;CACF;AACF;AAEA,IAAa,4BAA4B,cAAyC,IAAI;;;AAItF,SAAgB,cAAc,QAA0B;CACtD,MAAM,WAAW,WAAW,yBAAyB;CACrD,IAAI,CAAC,UAAU,MAAM,IAAI,MAAM,+CAA+C;CAC9E,gBAAgB,SAAS,IAAI,MAAM,GAAG,CAAC,UAAU,MAAM,CAAC;AAC1D"}

package/dist/features/snap/resizeBox.js

@@ -0,0 +1,137 @@
+import { fixedCornerOf, movedEdges, movingPoint } from "../../interactions/actions/resize/cornerHandles.js";
+
+//#region src/features/snap/resizeBox.ts
+var EPS = 1e-9;
+function resizeSubject(box, handle) {
+	const at = box.toWorld ?? ((p) => p);
+	const o = at({
+		x: 0,
+		y: 0
+	});
+	const ax = at({
+		x: 1,
+		y: 0
+	});
+	const ay = at({
+		x: 0,
+		y: 1
+	});
+	return {
+		bounds: box.bounds,
+		handle,
+		at,
+		ex: {
+			x: ax.x - o.x,
+			y: ax.y - o.y
+		},
+		ey: {
+			x: ay.x - o.x,
+			y: ay.y - o.y
+		}
+	};
+}
+/** The dragged corner or edge midpoint as `pointer`, and as `box` the dragged
+*  corner or both ends of the dragged edge: the points a drag δ moves by δ. */
+function resizeProbes(s) {
+	const { bounds: b, handle } = s;
+	const out = [{
+		id: "pointer",
+		at: s.at(movingPoint(b, handle)),
+		role: "pointer"
+	}];
+	const sides = (pin, lo, size) => pin === "min" ? [lo + size] : pin === "max" ? [lo] : [lo, lo + size];
+	const xs = sides(handle.x, b.x, b.width);
+	const ys = sides(handle.y, b.y, b.height);
+	if (xs.length === 2 && ys.length === 2) return out;
+	for (const x of xs) for (const y of ys) out.push({
+		id: `box.${out.length - 1}`,
+		at: s.at({
+			x,
+			y
+		}),
+		role: "box"
+	});
+	return out;
+}
+/** The direction an edge handle's edge moves along; null for a corner. */
+function edgeAxis(s) {
+	const { x, y } = s.handle;
+	if (x === "free" === (y === "free")) return null;
+	return y === "free" ? s.ex : s.ey;
+}
+/** From the fixed corner to the dragged one. */
+function diagonal(s) {
+	const f = s.at(fixedCornerOf(s.bounds, s.handle));
+	const m = s.at(movingPoint(s.bounds, s.handle));
+	return {
+		x: m.x - f.x,
+		y: m.y - f.y
+	};
+}
+/** The box in its own frame once the handle has moved by `delta`. */
+function movedBox(s, delta) {
+	const det = s.ex.x * s.ey.y - s.ey.x * s.ex.y;
+	const local = Math.abs(det) < EPS ? {
+		x: 0,
+		y: 0
+	} : {
+		x: (s.ey.y * delta.x - s.ey.x * delta.y) / det,
+		y: (s.ex.x * delta.y - s.ex.y * delta.x) / det
+	};
+	return movedEdges(s.bounds, s.handle, local.x, local.y);
+}
+/** The box's axis-aligned extent once the handle has moved by `delta`. */
+function resizedBox(s, delta) {
+	const b = movedBox(s, delta);
+	const corners = [
+		s.at({
+			x: b.x,
+			y: b.y
+		}),
+		s.at({
+			x: b.x + b.width,
+			y: b.y
+		}),
+		s.at({
+			x: b.x,
+			y: b.y + b.height
+		}),
+		s.at({
+			x: b.x + b.width,
+			y: b.y + b.height
+		})
+	];
+	const xs = corners.map((c) => c.x);
+	const ys = corners.map((c) => c.y);
+	const x = Math.min(...xs);
+	const y = Math.min(...ys);
+	return {
+		x,
+		y,
+		width: Math.max(...xs) - x,
+		height: Math.max(...ys) - y
+	};
+}
+/** The sides of {@link resizedBox} a drag of `delta` moves: the side across
+*  from the pinned one, or the pinned side's once the drag has flipped the
+*  box past it. A frame that turns or flips the box moves no side of its
+*  extent alone. */
+function resizeEdges(s, delta) {
+	if (!(Math.abs(s.ex.y) < EPS && Math.abs(s.ey.x) < EPS && s.ex.x > 0 && s.ey.y > 0)) return {
+		x: null,
+		y: null
+	};
+	const b = movedBox(s, delta);
+	const moved = (pin, size) => {
+		if (pin === "free") return null;
+		return size >= 0 ? pin === "min" ? "max" : "min" : pin;
+	};
+	return {
+		x: moved(s.handle.x, b.width),
+		y: moved(s.handle.y, b.height)
+	};
+}
+
+//#endregion
+export { EPS, diagonal, edgeAxis, resizeEdges, resizeProbes, resizeSubject, resizedBox };
+//# sourceMappingURL=resizeBox.js.map