@weasel-js/core 1.9.4 → 1.10.0

package/dist/interactions/actions/insert/geometry.js

@@ -0,0 +1,35 @@
+//#region src/interactions/actions/insert/geometry.ts
+function e(e, t) {
+	let n = e === "center" ? "center" : "corner";
+	return t ? n === "center" ? "corner" : "center" : n;
+}
+function t(e, t, n, r, i) {
+	if (i === "center") {
+		let i = Math.abs(n - e), a = Math.abs(r - t);
+		return {
+			x: e - i,
+			y: t - a,
+			width: i * 2,
+			height: a * 2
+		};
+	}
+	return {
+		x: Math.min(e, n),
+		y: Math.min(t, r),
+		width: Math.abs(n - e),
+		height: Math.abs(r - t)
+	};
+}
+function n(e, t) {
+	let n = t.x - e.x, r = t.y - e.y, i = Math.hypot(n, r);
+	if (i === 0) return t;
+	let a = Math.PI / 12, o = Math.round(Math.atan2(r, n) / a) * a;
+	return {
+		x: e.x + i * Math.cos(o),
+		y: e.y + i * Math.sin(o)
+	};
+}
+//#endregion
+export { t as computeBounds, e as effectiveOriginMode, n as snapTo15Degrees };
+
+//# sourceMappingURL=geometry.js.map

package/dist/interactions/actions/insert/geometry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.js","names":["effectiveOriginMode","nominal","paramsOrigin","altHeld","computeBounds","originMode","dx","currentX","startX","dy","currentY","startY","snapTo15Degrees","end","start","len","step","snapped"],"sources":["../../../../src/interactions/actions/insert/geometry.ts"],"sourcesContent":["/** Resolve the effective origin mode from the binding's nominal opt\n *  and live Alt state. Alt inverts: `corner` ⇄ `center`. Applies to\n *  every shape kind — radial shapes (polygon/star) included; the\n *  overlay paints an `anchorPoint` dot at the click so corner mode\n *  reads as anchored even though no polygon vertex sits there.\n */\nexport function effectiveOriginMode(\n  paramsOrigin: unknown,\n  altHeld: boolean,\n): 'corner' | 'center' {\n  const nominal: 'corner' | 'center' = paramsOrigin === 'center' ? 'center' : 'corner';\n  if (!altHeld) return nominal;\n  return nominal === 'center' ? 'corner' : 'center';\n}\n\n/** Compute the insert AABB from drag endpoints.\n *  - `'corner'` (default): bounds = drag rect (top-left → bottom-right of cursor sweep).\n *  - `'center'`: bounds = symmetric AABB anchored on the start point.\n *    Used when the tool's Alt-modifier binding passes\n *    `originMode: 'center'` (Illustrator/Figma convention). */\nexport function computeBounds(\n  startX: number, startY: number,\n  currentX: number, currentY: number,\n  originMode: 'corner' | 'center',\n): { x: number; y: number; width: number; height: number } {\n  if (originMode === 'center') {\n    const dx = Math.abs(currentX - startX);\n    const dy = Math.abs(currentY - startY);\n    return { x: startX - dx, y: startY - dy, width: dx * 2, height: dy * 2 };\n  }\n  return {\n    x: Math.min(startX, currentX),\n    y: Math.min(startY, currentY),\n    width: Math.abs(currentX - startX),\n    height: Math.abs(currentY - startY),\n  };\n}\n\n/** Constrain `end` to the nearest 15° increment around `start`, preserving\n *  the drag length. The line tool's documented Shift behavior. */\nexport function snapTo15Degrees(\n  start: { x: number; y: number },\n  end: { x: number; y: number },\n): { x: number; y: number } {\n  const dx = end.x - start.x;\n  const dy = end.y - start.y;\n  const len = Math.hypot(dx, dy);\n  if (len === 0) return end;\n  const step = Math.PI / 12; // 15°\n  const snapped = Math.round(Math.atan2(dy, dx) / step) * step;\n  return { x: start.x + len * Math.cos(snapped), y: start.y + len * Math.sin(snapped) };\n}\n"],"mappings":";AAMA,SAAgBA,EACd,GACA,GACqB;CACrB,IAAMC,IAA+BC,MAAiB,WAAW,WAAW;CAE5E,OADKC,IACEF,MAAY,WAAW,WAAW,WADpBA;AAEvB;AAOA,SAAgBG,EACd,GAAgB,GAChB,GAAkB,GAClB,GACyD;CACzD,IAAIC,MAAe,UAAU;EAC3B,IAAMC,IAAK,KAAK,IAAIC,IAAWC,CAAM,GAC/BC,IAAK,KAAK,IAAIC,IAAWC,CAAM;EACrC,OAAO;GAAE,GAAGH,IAASF;GAAI,GAAGK,IAASF;GAAI,OAAOH,IAAK;GAAG,QAAQG,IAAK;EAAE;CACzE;CACA,OAAO;EACL,GAAG,KAAK,IAAID,GAAQD,CAAQ;EAC5B,GAAG,KAAK,IAAII,GAAQD,CAAQ;EAC5B,OAAO,KAAK,IAAIH,IAAWC,CAAM;EACjC,QAAQ,KAAK,IAAIE,IAAWC,CAAM;CACpC;AACF;AAIA,SAAgBC,EACd,GACA,GAC0B;CAC1B,IAAMN,IAAKO,EAAI,IAAIC,EAAM,GACnBL,IAAKI,EAAI,IAAIC,EAAM,GACnBC,IAAM,KAAK,MAAMT,GAAIG,CAAE;CAC7B,IAAIM,MAAQ,GAAG,OAAOF;CACtB,IAAMG,IAAO,KAAK,KAAK,IACjBC,IAAU,KAAK,MAAM,KAAK,MAAMR,GAAIH,CAAE,IAAIU,CAAI,IAAIA;CACxD,OAAO;EAAE,GAAGF,EAAM,IAAIC,IAAM,KAAK,IAAIE,CAAO;EAAG,GAAGH,EAAM,IAAIC,IAAM,KAAK,IAAIE,CAAO;CAAE;AACtF"}

package/dist/interactions/actions/insert/rotateAction.js

@@ -0,0 +1,21 @@
+//#region src/interactions/actions/insert/rotateAction.ts
+var e = Math.PI / 720, t = {
+	id: "insert.adjustRotation",
+	label: "Insert — rotate",
+	group: "insert",
+	eligible: { capability: "creates-shapes" },
+	invoker: {
+		timing: "immediate",
+		run: (t, n) => {
+			let r = t.insertLive?.gesture;
+			if (!r || !r.open) return;
+			let i = n?.deltaY ?? 0;
+			i !== 0 && (r.userRotation += i * e);
+		}
+	},
+	requires: ["insertLive"]
+};
+//#endregion
+export { t as insertRotateAction };
+
+//# sourceMappingURL=rotateAction.js.map

package/dist/interactions/actions/insert/rotateAction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rotateAction.js","names":["ROTATION_SENSITIVITY","insertRotateAction","gesture","deps","deltaY","params"],"sources":["../../../../src/interactions/actions/insert/rotateAction.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport type { InsertLiveGesture } from './live';\n\n/** Radians per unit of wheel deltaY. Tuned so a typical mouse-wheel click\n *  (deltaY ≈ 100) yields ~25°, while a trackpad event (deltaY ≈ 1–10)\n *  yields a smooth 0.25–2.5° increment. */\nconst ROTATION_SENSITIVITY = Math.PI / 720;\n\n/**\n * @experimental\n * Companion to `insertAction` — adjusts the live insert gesture's\n * `userRotation` based on wheel deltaY. Intended to be bound to\n * Shift+wheel during the insert tool's engaged phase. No-op when no\n * insert is in flight.\n */\nexport const insertRotateAction: Action = {\n  id: 'insert.adjustRotation',\n  label: 'Insert — rotate',\n  group: 'insert',\n  eligible: { capability: 'creates-shapes' },\n  invoker: {\n    timing: 'immediate' as const,\n    run: (deps, params) => {\n      const gesture = deps.insertLive?.gesture as InsertLiveGesture | null | undefined;\n      if (!gesture || !gesture.open) return;\n      const deltaY = (params as { deltaY?: number } | undefined)?.deltaY ?? 0;\n      if (deltaY === 0) return;\n      gesture.userRotation += deltaY * ROTATION_SENSITIVITY;\n    },\n  },\n  requires: ['insertLive'],\n};\n"],"mappings":";AAMA,IAAMA,IAAuB,KAAK,KAAK,KAS1BC,IAA6B;CACxC,IAAI;CACJ,OAAO;CACP,OAAO;CACP,UAAU,EAAE,YAAY,iBAAiB;CACzC,SAAS;EACP,QAAQ;EACR,MAAM,GAAM,MAAW;GACrB,IAAMC,IAAUC,EAAK,YAAY;GACjC,IAAI,CAACD,KAAW,CAACA,EAAQ,MAAM;GAC/B,IAAME,IAAUC,GAA4C,UAAU;GACtE,AAAID,MAAW,MACf,EAAQ,gBAAgBA,IAASJ;EACnC;CACF;CACA,UAAU,CAAC,YAAY;AACzB"}

package/dist/interactions/actions/insert/session.js

@@ -0,0 +1,59 @@
+import { gestureReaders as e } from "../../gestures/shared/screenTolerance.js";
+import { pointerStateOf as t } from "../pointerState.js";
+//#region src/interactions/actions/insert/session.ts
+var n = "gesture";
+function r(r, i) {
+	let a = r.deps.insert;
+	if (!a) return null;
+	let o = r.deps.selection, s = o ? [...o.get()] : [];
+	o && s.length > 0 && o.clear();
+	let c = r.deps.snap, l = c ? (e) => c.point(e) : (e) => e, u = i?.behaviors ?? [], d = e(r.deps), f = l({
+		x: r.world.x,
+		y: r.world.y
+	}), p = {
+		draggedIds: [n],
+		origin: /* @__PURE__ */ new Map([[n, f]]),
+		current: /* @__PURE__ */ new Map([[n, f]]),
+		snap: null,
+		modifiers: { ...r.modifiers },
+		pointer: t(r.world, r),
+		view: d.view(),
+		plane: d.plane(),
+		adapter: void 0,
+		scratch: {}
+	};
+	for (let e of u) e.onStart?.(p);
+	let m = p.origin.get(n);
+	return {
+		session: {
+			dep: a,
+			textEdit: r.deps.textEdit,
+			snap: l,
+			opts: i,
+			priorSelection: s,
+			behaviors: u,
+			gestureCtx: p,
+			scene: r.deps.scene,
+			applyOps: r.deps.applyOps,
+			selection: o
+		},
+		readers: d,
+		frame: {
+			pointer: {
+				x: r.world.x,
+				y: r.world.y
+			},
+			points: r.drag?.points ?? null,
+			altHeld: r.modifiers.alt,
+			shiftHeld: r.modifiers.shift,
+			shaped: {
+				start: m,
+				current: m
+			}
+		}
+	};
+}
+//#endregion
+export { n as GESTURE_KEY, r as beginInsert };
+
+//# sourceMappingURL=session.js.map

package/dist/interactions/actions/insert/session.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.js","names":["GESTURE_KEY","beginInsert","dep","ctx","selection","priorSelection","snapDep","snap","p","behaviors","opts","readers","gestureReaders","origin","gestureCtx","pointerStateOf","b","startPoint"],"sources":["../../../../src/interactions/actions/insert/session.ts"],"sourcesContent":["import type { BindingOpts, DragSample, InvocationCtx } from '@weasel-js/routing';\nimport { pointerStateOf } from '../pointerState';\nimport type { Op } from 'core/ops/types';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport { gestureReaders, type GestureReaders } from '../../gestures/shared/screenTolerance';\nimport type { GestureContext, InsertBehavior, InsertPoint } from '../../gestures/types';\nimport type { InsertDep, TextEditDep } from '../depSchema';\n\n/** The key an insert's single gesture point rides under in the behaviors'\n *  `draggedIds` / `origin` / `current` — insert has no node id yet. */\nexport const GESTURE_KEY = 'gesture';\n\n/** What an insert captured at press. Nothing here changes during the drag.\n *  The deps are captured because the dispatcher builds the deps bag once, on\n *  `start`: every later pump event carries `deps: {}`. */\nexport interface InsertSession {\n  readonly dep: InsertDep;\n  /** For the text kind's drop-into-the-caret step. */\n  readonly textEdit: TextEditDep | undefined;\n  /** World-space point snapper from the `snap` dep, or identity when the\n   *  dep isn't registered. Applied to the drag's start and current point so\n   *  the live preview and the committed geometry agree. Freehand pencil\n   *  samples are deliberately NOT snapped — a grid-quantized freehand trail\n   *  is a staircase, not a stroke. */\n  readonly snap: (p: { x: number; y: number }) => { x: number; y: number };\n  /** The active binding's opts — re-resolved on every read so thunked\n   *  params see the latest tool state (e.g. polygon `sides` after ArrowUp). */\n  readonly opts: BindingOpts | undefined;\n  /** What was selected before the draw cleared it, to put back on cancel. */\n  readonly priorSelection: readonly NodeId[];\n  /** Behaviors from `opts.behaviors`; empty when none were bound. */\n  readonly behaviors: readonly InsertBehavior<unknown>[];\n  /** Reused gesture context handed to behaviors. Its `origin` holds the\n   *  start point under {@link GESTURE_KEY}, after `onStart` shaped it. */\n  readonly gestureCtx: GestureContext<unknown>;\n  /** For committing a behavior's `Op[]`. */\n  readonly scene: Scene<unknown, string, unknown> | undefined;\n  readonly applyOps: ((ops: Op[], label: string) => void) | undefined;\n  readonly selection: SelectionApi | undefined;\n}\n\n/** What the latest pump event left. Replaced, not mutated, by the next. */\nexport interface InsertFrame {\n  /** The raw (unsnapped) pointer in world space. */\n  readonly pointer: InsertPoint;\n  /** Pointer trail accumulated by the dispatcher in world space; pencil-kind\n   *  commits read it. */\n  readonly points: ReadonlyArray<DragSample> | null;\n  /** Alt inverts the binding's nominal `originMode` (corner ⇄ center), so\n   *  pressing or releasing it mid-drag flips the preview and the commit\n   *  without the dispatcher re-routing to another binding. */\n  readonly altHeld: boolean;\n  /** Shift constrains the `line` kind to 15° increments. */\n  readonly shiftHeld: boolean;\n  /** The endpoints after Shift-constrain, the `snap` dep, and the behaviors. */\n  readonly shaped: { start: InsertPoint; current: InsertPoint };\n}\n\n/** Capture an insert at press. Null with no `insert` dep. Clears the\n *  selection and runs each behavior's `onStart`. */\nexport function beginInsert(\n  ctx: InvocationCtx,\n  opts: BindingOpts | undefined,\n): { session: InsertSession; readers: GestureReaders; frame: InsertFrame } | null {\n  const dep = ctx.deps.insert;\n  if (!dep) return null;\n\n  // Starting a draw retires any prior selection — the lingering halo\n  // around an unrelated node while the user is drawing a new shape is\n  // just visual noise, and it primes the UX bug where a drag that\n  // continues over the selected node would otherwise drive the move\n  // action via fall-through. The clear is unconditional: the user has\n  // committed to \"I'm making a new thing\" by engaging a creation tool.\n  const selection = ctx.deps.selection;\n  const priorSelection = selection ? [...selection.get()] : [];\n  if (selection && priorSelection.length > 0) {\n    selection.clear();\n  }\n\n  const snapDep = ctx.deps.snap;\n  const snap = snapDep\n    ? (p: { x: number; y: number }) => snapDep.point(p)\n    : (p: { x: number; y: number }) => p;\n  const behaviors = (opts?.behaviors ?? []) as InsertBehavior<unknown>[];\n  const readers = gestureReaders(ctx.deps);\n  const origin = snap({ x: ctx.world.x, y: ctx.world.y });\n  const gestureCtx: GestureContext<unknown> = {\n    draggedIds: [GESTURE_KEY],\n    origin: new Map<string, unknown>([[GESTURE_KEY, origin]]),\n    current: new Map<string, unknown>([[GESTURE_KEY, origin]]),\n    snap: null,\n    modifiers: { ...ctx.modifiers },\n    pointer: pointerStateOf(ctx.world, ctx),\n    view: readers.view(),\n    plane: readers.plane(),\n    // No node exists to adapt until commit; insert behaviors read points.\n    adapter: undefined as unknown as GestureContext<unknown>['adapter'],\n    scratch: {},\n  };\n  for (const b of behaviors) b.onStart?.(gestureCtx);\n  const startPoint = gestureCtx.origin.get(GESTURE_KEY) as InsertPoint;\n\n  const session: InsertSession = {\n    dep,\n    textEdit: ctx.deps.textEdit,\n    snap,\n    opts,\n    priorSelection,\n    behaviors,\n    gestureCtx,\n    scene: ctx.deps.scene,\n    applyOps: ctx.deps.applyOps,\n    selection,\n  };\n  const frame: InsertFrame = {\n    pointer: { x: ctx.world.x, y: ctx.world.y },\n    points: ctx.drag?.points ?? null,\n    altHeld: ctx.modifiers.alt,\n    shiftHeld: ctx.modifiers.shift,\n    shaped: { start: startPoint, current: startPoint },\n  };\n  return { session, readers, frame };\n}\n"],"mappings":";;;AAWA,IAAaA,IAAc;AAkD3B,SAAgBC,EACd,GACA,GACgF;CAChF,IAAMC,IAAMC,EAAI,KAAK;CACrB,IAAI,CAACD,GAAK,OAAO;CAQjB,IAAME,IAAYD,EAAI,KAAK,WACrBE,IAAiBD,IAAY,CAAC,GAAGA,EAAU,IAAI,CAAC,IAAI,CAAC;CAC3D,AAAIA,KAAaC,EAAe,SAAS,KACvCD,EAAU,MAAM;CAGlB,IAAME,IAAUH,EAAI,KAAK,MACnBI,IAAOD,KACR,MAAgCA,EAAQ,MAAME,CAAC,KAC/C,MAAgCA,GAC/BC,IAAaC,GAAM,aAAa,CAAC,GACjCC,IAAUC,EAAeT,EAAI,IAAI,GACjCU,IAASN,EAAK;EAAE,GAAGJ,EAAI,MAAM;EAAG,GAAGA,EAAI,MAAM;CAAE,CAAC,GAChDW,IAAsC;EAC1C,YAAY,CAACd,CAAW;EACxB,wBAAQ,IAAI,IAAqB,CAAC,CAACA,GAAaa,CAAM,CAAC,CAAC;EACxD,yBAAS,IAAI,IAAqB,CAAC,CAACb,GAAaa,CAAM,CAAC,CAAC;EACzD,MAAM;EACN,WAAW,EAAE,GAAGV,EAAI,UAAU;EAC9B,SAASY,EAAeZ,EAAI,OAAOA,CAAG;EACtC,MAAMQ,EAAQ,KAAK;EACnB,OAAOA,EAAQ,MAAM;EAErB,SAAS,KAAA;EACT,SAAS,CAAC;CACZ;CACA,KAAK,IAAMK,KAAKP,GAAW,EAAE,UAAUK,CAAU;CACjD,IAAMG,IAAaH,EAAW,OAAO,IAAId,CAAW;CAqBpD,OAAO;EAAE,SAAA;GAlBP;GACA,UAAUG,EAAI,KAAK;GACnB;GACA;GACA;GACA;GACA;GACA,OAAOA,EAAI,KAAK;GAChB,UAAUA,EAAI,KAAK;GACnB;EASO;EAAS;EAAS,OAAA;GANzB,SAAS;IAAE,GAAGA,EAAI,MAAM;IAAG,GAAGA,EAAI,MAAM;GAAE;GAC1C,QAAQA,EAAI,MAAM,UAAU;GAC5B,SAASA,EAAI,UAAU;GACvB,WAAWA,EAAI,UAAU;GACzB,QAAQ;IAAE,OAAOc;IAAY,SAASA;GAAW;EAExB;CAAM;AACnC"}

package/dist/interactions/actions/insert/shape.js

@@ -0,0 +1,34 @@
+import { applyUserRotation as e, buildExtras as t } from "./extras.js";
+import { computeBounds as n, effectiveOriginMode as r } from "./geometry.js";
+//#region src/interactions/actions/insert/shape.ts
+function i(e) {
+	return e?.kind ?? "rect";
+}
+function a(e, t, n) {
+	let { start: r } = e, { current: i } = e;
+	return t === "line" && n === "center" && (r = {
+		x: r.x - (i.x - r.x),
+		y: r.y - (i.y - r.y)
+	}), {
+		start: r,
+		current: i
+	};
+}
+function o(o, s, c, l) {
+	let u = r(o?.originMode, s.altHeld), { start: d, current: f } = a(s.shaped, i(o), u), p = n(d.x, d.y, f.x, f.y, u), m = t({
+		...o ?? {},
+		originMode: u
+	}, d.x, d.y, f.x, f.y, c);
+	return e(m, l), {
+		bounds: p,
+		extras: m,
+		start: d
+	};
+}
+function s(e, t) {
+	return t === "pencil" ? !0 : t === "line" ? e.width !== 0 || e.height !== 0 : e.width !== 0 && e.height !== 0;
+}
+//#endregion
+export { i as insertKind, o as insertShape, s as isCommittableExtent };
+
+//# sourceMappingURL=shape.js.map

package/dist/interactions/actions/insert/shape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape.js","names":["insertKind","resolved","\"kind\"","resolveEndpoints","shaped","kind","mode","start","current","insertShape","effectiveOriginMode","\"originMode\"","frame","bounds","computeBounds","extras","buildExtras","points","applyUserRotation","userRotation","isCommittableExtent"],"sources":["../../../../src/interactions/actions/insert/shape.ts"],"sourcesContent":["import type { DragSample } from '@weasel-js/routing';\nimport type { InsertPoint } from '../../gestures/types';\nimport type { InsertExtras } from '../depSchema';\nimport { applyUserRotation, buildExtras } from './extras';\nimport { computeBounds, effectiveOriginMode } from './geometry';\nimport type { InsertFrame } from './session';\n\n/** The node kind a binding's resolved params ask for. */\nexport function insertKind(resolved: Record<string, unknown> | undefined): string {\n  return (resolved?.['kind'] as string | undefined) ?? 'rect';\n}\n\n/** The effective endpoints: `shaped`, plus — for the `line` kind only — the\n *  alt/center reading as \"mirror the start around the pointer\" rather than\n *  \"grow a symmetric AABB\". */\nfunction resolveEndpoints(\n  shaped: InsertFrame['shaped'],\n  kind: string,\n  mode: 'corner' | 'center',\n): { start: InsertPoint; current: InsertPoint } {\n  let { start } = shaped;\n  const { current } = shaped;\n\n  // A line has no area, so \"from center\" means the drag is a half-line:\n  // mirror the start to the far side of the pointer.\n  if (kind === 'line' && mode === 'center') {\n    start = { x: start.x - (current.x - start.x), y: start.y - (current.y - start.y) };\n  }\n  return { start, current };\n}\n\nexport interface InsertShape {\n  bounds: { x: number; y: number; width: number; height: number };\n  extras: InsertExtras;\n  /** Where the drag started, after the endpoints were resolved. */\n  start: InsertPoint;\n}\n\n/** The shape an insert has at `frame`. The live overlay and the commit both\n *  read it from here, so they can't disagree. Extras are derived with the\n *  effective origin mode, so polygon/star center+radius follow the live Alt\n *  toggle and not the binding's nominal `originMode`. */\nexport function insertShape(\n  resolved: Record<string, unknown> | undefined,\n  frame: Pick<InsertFrame, 'shaped' | 'altHeld'>,\n  points: ReadonlyArray<DragSample> | null,\n  userRotation: number,\n): InsertShape {\n  const mode = effectiveOriginMode(resolved?.['originMode'], frame.altHeld);\n  const { start, current } = resolveEndpoints(frame.shaped, insertKind(resolved), mode);\n  const bounds = computeBounds(start.x, start.y, current.x, current.y, mode);\n  const extras = buildExtras(\n    { ...(resolved ?? {}), originMode: mode },\n    start.x, start.y, current.x, current.y,\n    points,\n  );\n  applyUserRotation(extras, userRotation);\n  return { bounds, extras, start };\n}\n\n/** Whether a drag produced enough extent to be worth committing. The test\n *  is kind-aware because \"zero size\" isn't one shape:\n *   - pencil: a sample trail can be meaningful even when start ≈ end\n *     (a closed loop), so no guard at all.\n *   - line: has no area by construction. An axis-aligned line has a\n *     zero-height (or zero-width) AABB and is perfectly valid — only\n *     a zero-LENGTH drag is degenerate. (Shift-constrain makes\n *     axis-aligned the common case, which is how this surfaced.)\n *   - everything else: a zero extent in either axis is degenerate. */\nexport function isCommittableExtent(\n  bounds: { width: number; height: number },\n  kind: string,\n): boolean {\n  if (kind === 'pencil') return true;\n  if (kind === 'line') return bounds.width !== 0 || bounds.height !== 0;\n  return bounds.width !== 0 && bounds.height !== 0;\n}\n"],"mappings":";;;AAQA,SAAgBA,EAAW,GAAuD;CAChF,OAAQC,GAAWC,QAAkC;AACvD;AAKA,SAASC,EACP,GACA,GACA,GAC8C;CAC9C,IAAI,EAAE,aAAUC,GACV,EAAE,eAAYA;CAOpB,OAHIC,MAAS,UAAUC,MAAS,aAC9B,IAAQ;EAAE,GAAGC,EAAM,KAAKC,EAAQ,IAAID,EAAM;EAAI,GAAGA,EAAM,KAAKC,EAAQ,IAAID,EAAM;CAAG,IAE5E;EAAE;EAAO;CAAQ;AAC1B;AAaA,SAAgBE,EACd,GACA,GACA,GACA,GACa;CACb,IAAMH,IAAOI,EAAoBT,GAAWU,YAAeC,EAAM,OAAO,GAClE,EAAE,UAAO,eAAYT,EAAiBS,EAAM,QAAQZ,EAAWC,CAAQ,GAAGK,CAAI,GAC9EO,IAASC,EAAcP,EAAM,GAAGA,EAAM,GAAGC,EAAQ,GAAGA,EAAQ,GAAGF,CAAI,GACnES,IAASC,EACb;EAAE,GAAIf,KAAY,CAAC;EAAI,YAAYK;CAAK,GACxCC,EAAM,GAAGA,EAAM,GAAGC,EAAQ,GAAGA,EAAQ,GACrCS,CACF;CAEA,OADAC,EAAkBH,GAAQI,CAAY,GAC/B;EAAE;EAAQ;EAAQ;CAAM;AACjC;AAWA,SAAgBC,EACd,GACA,GACS;CAGT,OAFIf,MAAS,WAAiB,KAC1BA,MAAS,SAAeQ,EAAO,UAAU,KAAKA,EAAO,WAAW,IAC7DA,EAAO,UAAU,KAAKA,EAAO,WAAW;AACjD"}

package/dist/interactions/actions/lasso-select/action.js

@@ -0,0 +1,143 @@
+import { reduceBehaviorEnd as e, runBehaviorCancel as t, runBehaviorSettled as n } from "../gestureLifecycle.js";
+import { gestureViewReader as r } from "../../gestures/shared/screenTolerance.js";
+import { pointerStateOf as i } from "../pointerState.js";
+import { selectionFromHits as a } from "../hitSelection.js";
+import { applyOpsTo as o } from "../../../core/applyOps.js";
+import { LASSO_VERTICES as s } from "./behaviors/selectFromLasso.js";
+import { resolveParams as c, setScratch as l } from "@weasel-js/routing";
+//#region src/interactions/actions/lasso-select/action.ts
+function u(e) {
+	if (e.length === 0) return null;
+	let t = e[0].x, n = e[0].y, r = e[0].x, i = e[0].y;
+	for (let a of e) a.x < t && (t = a.x), a.y < n && (n = a.y), a.x > r && (r = a.x), a.y > i && (i = a.y);
+	return {
+		x: t,
+		y: n,
+		width: r - t,
+		height: i - n
+	};
+}
+function d(e, t, n, r) {
+	if (e.hitTestLasso) return e.hitTestLasso(t, n, r);
+	let i = u(t);
+	return i ? e.hitTestArea(i, r) : [];
+}
+function f(e, t) {
+	let n = {
+		getSelection: () => e.getSelection(),
+		setSelection: (t) => e.setSelection(t),
+		hitTestArea: (n) => e.hitTestArea(n, t),
+		hitTestLasso: (n, r) => d(e, n, r, t),
+		applyOps: (e) => o(n, e)
+	};
+	return n;
+}
+var p = 2, m = {
+	id: "lassoSelect",
+	label: "Lasso Select",
+	eligible: { capability: "creates-selection" },
+	requires: ["lassoSelect", "view"],
+	invoker: {
+		timing: "ongoing",
+		start(e, t) {
+			let a = e.deps.lassoSelect;
+			if (!a) return {};
+			let o = c(t?.params), u = e.deps.view, d = [{
+				x: e.world.x,
+				y: e.world.y
+			}], m = t?.behaviors ?? [], g = null, _ = r(e.deps);
+			if (m.length > 0) {
+				let t = {
+					worldX: e.world.x,
+					worldY: e.world.y,
+					shiftHeld: e.modifiers.shift
+				};
+				g = {
+					draggedIds: ["gesture"],
+					origin: /* @__PURE__ */ new Map([["gesture", t]]),
+					current: /* @__PURE__ */ new Map([["gesture", { ...t }]]),
+					snap: null,
+					modifiers: { ...e.modifiers },
+					pointer: i(e.world, e),
+					view: _(),
+					adapter: f(a, u),
+					scratch: {}
+				}, l(g.scratch, s, d);
+				for (let e of m) e.onStart?.(g);
+			}
+			let v = {
+				dep: a,
+				mode: o?.mode ?? "intersect",
+				minVertexSpacing: o?.minVertexSpacing ?? p,
+				view: u,
+				vertices: d,
+				shiftHeld: e.modifiers.shift,
+				currentX: e.world.x,
+				currentY: e.world.y,
+				open: !0,
+				behaviors: m,
+				gesture: g
+			};
+			return {
+				kind: "lasso",
+				onMove(e) {
+					let { x: t, y: n } = e.world;
+					v.currentX = t, v.currentY = n;
+					let r = v.vertices[v.vertices.length - 1], a = t - r.x, o = n - r.y, s = v.minVertexSpacing;
+					a * a + o * o >= s * s && v.vertices.push({
+						x: t,
+						y: n
+					});
+					let c = v.gesture;
+					if (c) {
+						c.modifiers = { ...e.modifiers }, c.pointer = i(e.world, e), c.view = _(), c.current.set("gesture", {
+							worldX: t,
+							worldY: n,
+							shiftHeld: v.shiftHeld
+						});
+						let r = {
+							vertices: v.vertices,
+							shiftHeld: v.shiftHeld
+						};
+						for (let e of v.behaviors) e.onMove?.(c, r);
+					}
+				},
+				overlay() {
+					return v.open ? {
+						kind: "lasso",
+						vertices: v.vertices,
+						current: {
+							x: v.currentX,
+							y: v.currentY
+						},
+						shiftHeld: v.shiftHeld
+					} : null;
+				},
+				onEnd(e, t) {
+					let r = !1;
+					try {
+						r = h(v, t);
+					} finally {
+						v.gesture && n(v.behaviors, v.gesture, r);
+					}
+				}
+			};
+		}
+	},
+	enabled: () => !0
+};
+function h(n, r) {
+	if (n.open = !1, r === "cancel") return n.gesture && t(n.behaviors, n.gesture), !1;
+	let { dep: i, mode: o, view: s, vertices: c, shiftHeld: l, gesture: u } = n;
+	if (u) {
+		let t = e(n.behaviors, u);
+		if (t !== void 0) return t !== null && u.adapter.applyOps(t), t !== null;
+	}
+	if (c.length < 3) return l || i.setSelection([]), !l;
+	let f = d(i, c, o, s);
+	return i.setSelection(a(i.getSelection(), f, l)), !0;
+}
+//#endregion
+export { m as lassoSelectAction };
+
+//# sourceMappingURL=action.js.map

package/dist/interactions/actions/lasso-select/action.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"action.js","names":["polygonAABB","pts","minX","minY","maxX","maxY","p","hitTestPolygon","dep","vertices","mode","view","aabb","behaviorAdapter","adapter","ids","rect","polygon","applyOpsTo","ops","DEFAULT_MIN_VERTEX_SPACING","lassoSelectAction","ctx","params","resolveParams","opts","behaviors","gesture","readView","gestureViewReader","pose","pointerStateOf","setScratch","LASSO_VERTICES","b","scratch","moveCtx","x","y","last","dx","dy","min","g","proposed","committed","endLasso","reason","runBehaviorSettled","runBehaviorCancel","d","r","reduceBehaviorEnd","shiftHeld","hits","selectionFromHits"],"sources":["../../../../src/interactions/actions/lasso-select/action.ts"],"sourcesContent":["/**\n * `lassoSelectAction` — ongoing Action descriptor for polygon lasso selection.\n *\n * A move adds a vertex unless it is closer than the binding's\n * `params.minVertexSpacing` (default 2 world-px) to the last one. The commit\n * hit-tests the polygon with `dep.hitTestLasso(polygon, mode)` — `mode` from\n * the binding's `params.mode`, default `'intersect'` — falling back to the\n * polygon's AABB via `dep.hitTestArea(bounds)`. Shift extends the selection.\n * Always transient: no undo entry.\n *\n * `opts.behaviors` (`LassoSelectBehavior[]`) run over a `GestureContext`\n * whose `origin.get('gesture')` is the start pose, whose scratch holds the\n * vertices under `LASSO_VERTICES`, and whose adapter answers selection and\n * hit-testing from the `lassoSelect` dep. `onEnd` is first-non-undefined-wins:\n * `Op[]` is applied in place of the default selection, `null` aborts, and\n * all-`undefined` falls through to it. A behavior's ops are applied\n * transiently too.\n */\n\nimport { gestureViewReader } from '../../gestures/shared/screenTolerance';\nimport { resolveParams, setScratch, type Action } from '@weasel-js/routing';\nimport type { InvocationCtx, OngoingHandle, OngoingOverlay, Point2 } from '@weasel-js/routing';\nimport { pointerStateOf } from '../pointerState';\nimport type { LassoSelectDep, ViewApi } from '../depSchema';\nimport type { LassoHitMode, LassoSelectAdapter } from 'core/adapters/types';\nimport type { Op } from 'core/ops/types';\nimport { applyOpsTo } from 'core/applyOps';\nimport type { GestureContext, LassoSelectBehavior, LassoSelectPose } from '../../gestures/types';\nimport { LASSO_VERTICES } from './behaviors/selectFromLasso';\nimport { reduceBehaviorEnd, runBehaviorCancel, runBehaviorSettled } from '../gestureLifecycle';\nimport { selectionFromHits } from '../hitSelection';\n\n/** Compute AABB of a polygon (for fallback hit-test when hitTestLasso is absent). */\nfunction polygonAABB(\n  pts: Point2[],\n): { x: number; y: number; width: number; height: number } | null {\n  if (pts.length === 0) return null;\n  let minX = pts[0].x, minY = pts[0].y, maxX = pts[0].x, maxY = pts[0].y;\n  for (const p of pts) {\n    if (p.x < minX) minX = p.x;\n    if (p.y < minY) minY = p.y;\n    if (p.x > maxX) maxX = p.x;\n    if (p.y > maxY) maxY = p.y;\n  }\n  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };\n}\n\n/** The dep's polygon test, or its rect test over the polygon's AABB when it\n *  has none. What both the default commit and a behavior's adapter ask. */\nfunction hitTestPolygon(\n  dep: LassoSelectDep,\n  vertices: ReadonlyArray<Point2>,\n  mode: LassoHitMode,\n  view: ViewApi | undefined,\n): string[] {\n  if (dep.hitTestLasso) return dep.hitTestLasso(vertices, mode, view);\n  const aabb = polygonAABB(vertices as Point2[]);\n  return aabb ? dep.hitTestArea(aabb, view) : [];\n}\n\n/** The adapter a behavior sees: selection and hit-testing from the dep,\n *  scoped to the view the lasso started in. */\nfunction behaviorAdapter(dep: LassoSelectDep, view: ViewApi | undefined): LassoSelectAdapter {\n  const adapter: LassoSelectAdapter = {\n    getSelection: () => dep.getSelection(),\n    setSelection: (ids) => dep.setSelection(ids),\n    hitTestArea: (rect) => dep.hitTestArea(rect, view),\n    hitTestLasso: (polygon, mode) => hitTestPolygon(dep, polygon, mode, view),\n    applyOps: (ops: Op[]) => applyOpsTo(adapter, ops),\n  };\n  return adapter;\n}\n\nconst DEFAULT_MIN_VERTEX_SPACING = 2; // world-px\n\ninterface LassoScratch {\n  dep: LassoSelectDep;\n  mode: LassoHitMode;\n  minVertexSpacing: number;\n  /** The view the lasso started in: what it does not paint is not taken. */\n  view: ViewApi | undefined;\n  vertices: Point2[];\n  shiftHeld: boolean;\n  /** Current pointer position — paint the live \"close-line\" from the last\n   *  vertex back to the start while the gesture is open. Tracked separately\n   *  from `vertices` because we throttle vertex insertion. */\n  currentX: number;\n  currentY: number;\n  /** Cleared by `onEnd` so post-commit `overlay()` returns null. */\n  open: boolean;\n  behaviors: LassoSelectBehavior[];\n  /** Built only when there are behaviors to hand it to. */\n  gesture: GestureContext<LassoSelectPose> | null;\n}\n\n/**\n * @experimental\n * Static descriptor for the `lassoSelect` Action.\n */\nexport const lassoSelectAction: Action & { requires: string[] } = {\n  id: 'lassoSelect',\n  label: 'Lasso Select',\n  eligible: { capability: 'creates-selection' },\n  requires: ['lassoSelect', 'view'],\n  invoker: {\n    timing: 'ongoing',\n    start(ctx: InvocationCtx, opts): OngoingHandle {\n      const dep = ctx.deps.lassoSelect;\n      if (!dep) return {};\n\n      const params = resolveParams(opts?.params) as\n        { mode?: LassoHitMode; minVertexSpacing?: number } | undefined;\n      const view = ctx.deps.view;\n      const vertices: Point2[] = [{ x: ctx.world.x, y: ctx.world.y }];\n      const behaviors = (opts?.behaviors ?? []) as LassoSelectBehavior[];\n      let gesture: GestureContext<LassoSelectPose> | null = null;\n      const readView = gestureViewReader(ctx.deps);\n      if (behaviors.length > 0) {\n        const pose: LassoSelectPose = {\n          worldX: ctx.world.x, worldY: ctx.world.y, shiftHeld: ctx.modifiers.shift,\n        };\n        gesture = {\n          draggedIds: ['gesture'],\n          origin: new Map([['gesture', pose]]),\n          current: new Map([['gesture', { ...pose }]]),\n          snap: null,\n          modifiers: { ...ctx.modifiers },\n          pointer: pointerStateOf(ctx.world, ctx),\n          view: readView(),\n          adapter: behaviorAdapter(dep, view) as unknown as GestureContext<LassoSelectPose>['adapter'],\n          scratch: {},\n        };\n        // The live array, so a behavior reads every vertex added since.\n        setScratch(gesture.scratch, LASSO_VERTICES, vertices);\n        for (const b of behaviors) b.onStart?.(gesture);\n      }\n      const scratch: LassoScratch = {\n        dep,\n        mode: params?.mode ?? 'intersect',\n        minVertexSpacing: params?.minVertexSpacing ?? DEFAULT_MIN_VERTEX_SPACING,\n        view,\n        vertices,\n        shiftHeld: ctx.modifiers.shift,\n        currentX: ctx.world.x,\n        currentY: ctx.world.y,\n        open: true,\n        behaviors,\n        gesture,\n      };\n\n      return {\n        kind: 'lasso',\n        onMove(moveCtx: InvocationCtx): void {\n          const { x, y } = moveCtx.world;\n          scratch.currentX = x;\n          scratch.currentY = y;\n          const last = scratch.vertices[scratch.vertices.length - 1];\n          const dx = x - last.x;\n          const dy = y - last.y;\n          const min = scratch.minVertexSpacing;\n          if (dx * dx + dy * dy >= min * min) {\n            scratch.vertices.push({ x, y });\n          }\n          const g = scratch.gesture;\n          if (g) {\n            g.modifiers = { ...moveCtx.modifiers };\n            g.pointer = pointerStateOf(moveCtx.world, moveCtx);\n            g.view = readView();\n            g.current.set('gesture', { worldX: x, worldY: y, shiftHeld: scratch.shiftHeld });\n            const proposed = { vertices: scratch.vertices, shiftHeld: scratch.shiftHeld };\n            for (const b of scratch.behaviors) b.onMove?.(g, proposed);\n          }\n        },\n        overlay(): OngoingOverlay | null {\n          if (!scratch.open) return null;\n          return {\n            kind: 'lasso',\n            vertices: scratch.vertices,\n            current: { x: scratch.currentX, y: scratch.currentY },\n            shiftHeld: scratch.shiftHeld,\n          };\n        },\n        onEnd(_endCtx: InvocationCtx, reason: 'commit' | 'cancel'): void {\n          let committed = false;\n          try {\n            committed = endLasso(scratch, reason);\n          } finally {\n            if (scratch.gesture) runBehaviorSettled(scratch.behaviors, scratch.gesture, committed);\n          }\n        },\n      };\n    },\n  },\n  enabled: () => true,\n};\n\n/** Close the lasso. Returns whether it committed: a behavior's ops were\n *  applied, or the lasso set the selection. */\nfunction endLasso(scratch: LassoScratch, reason: 'commit' | 'cancel'): boolean {\n  scratch.open = false;\n  if (reason === 'cancel') {\n    if (scratch.gesture) runBehaviorCancel(scratch.behaviors, scratch.gesture);\n    return false;\n  }\n\n  const { dep: d, mode, view, vertices, shiftHeld, gesture: g } = scratch;\n\n  if (g) {\n    const r = reduceBehaviorEnd(scratch.behaviors, g);\n    if (r !== undefined) {\n      if (r !== null) (g.adapter as unknown as LassoSelectAdapter).applyOps!(r);\n      return r !== null;\n    }\n  }\n\n  // Need at least 3 vertices for a meaningful polygon; otherwise no-op.\n  if (vertices.length < 3) {\n    if (!shiftHeld) d.setSelection([]);\n    return !shiftHeld;\n  }\n\n  const hits = hitTestPolygon(d, vertices, mode, view);\n\n  d.setSelection(selectionFromHits(d.getSelection(), hits, shiftHeld));\n  return true;\n}\n"],"mappings":"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"}

package/dist/interactions/actions/move/action.js

@@ -0,0 +1,87 @@
+import { closeGesture as e, runBehaviorCancel as t } from "../gestureLifecycle.js";
+import { inPlane as n, selectionLayer as r } from "../planeInput.js";
+import { beginMove as i } from "./session.js";
+import { nextFrame as a } from "./frame.js";
+import { commitMove as o } from "./commit/index.js";
+import { pastDragThreshold as s } from "@weasel-js/routing";
+//#region src/interactions/actions/move/action.ts
+var c = n({
+	id: "move",
+	label: "Move",
+	activeCursor: "move",
+	defaultBinding: {
+		kind: "drag",
+		target: "selected-body"
+	},
+	eligible: { capability: "transforms-selection" },
+	requires: [
+		"selection",
+		"scene",
+		"poseDescriptor",
+		"layout",
+		"applyOps",
+		"geometryProjection",
+		"nodeAtPoint",
+		"view"
+	],
+	invoker: {
+		timing: "ongoing",
+		start(n, r) {
+			let c = {
+				delta: {
+					dx: 0,
+					dy: 0
+				},
+				previews: /* @__PURE__ */ new Map(),
+				opaque: /* @__PURE__ */ new Set()
+			}, l = i(n, r, () => c);
+			if (!l) return {};
+			let { session: u, readers: d } = l, f = u.scene.overrides.hold(), p = null;
+			return {
+				kind: "move",
+				onMove(e) {
+					if (e.drag) {
+						if (!p) {
+							let t = e.drag.screenDelta;
+							if (t && !s({
+								clientX: 0,
+								clientY: 0
+							}, {
+								clientX: t.x,
+								clientY: t.y
+							}, u.dragThresholdPx)) return;
+							u.lifecycle.start(u.ids);
+						}
+						p = e.world, c = a(u, d, e), f.set(c.previews);
+					}
+				},
+				onEnd(n, r) {
+					let i = !1;
+					try {
+						r === "commit" && p ? i = o({
+							session: u,
+							delta: c.delta,
+							at: n.drag ? n.world : p
+						}) : t(u.behaviors, u.gestureCtx);
+					} finally {
+						e({
+							hold: f,
+							previews: c.previews,
+							behaviors: u.behaviors,
+							ctx: u.gestureCtx,
+							lifecycle: u.lifecycle
+						}, i);
+					}
+				},
+				previewIds: () => c.previews.keys(),
+				previewPose: (e) => c.previews.get(e) ?? null,
+				previewOpaqueIds: () => c.opaque.size === 0 ? null : c.opaque
+			};
+		}
+	},
+	enabled: () => !0
+}, r);
+//#endregion
+export { c as moveAction };
+
+//# sourceMappingURL=action.js.map

package/dist/interactions/actions/move/action.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"action.js","names":["moveAction","inPlane","frame","begun","beginMove","ctx","opts","hold","session","engaged","moveCtx","s","pastDragThreshold","nextFrame","readers","committed","reason","commitMove","endCtx","runBehaviorCancel","id","selectionLayer"],"sources":["../../../../src/interactions/actions/move/action.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport type { InvocationCtx, OngoingHandle, BindingOpts } from '@weasel-js/routing';\nimport { pastDragThreshold } from '@weasel-js/routing';\nimport type { NodeId } from 'core/scene/types';\nimport { closeGesture, runBehaviorCancel } from '../gestureLifecycle';\nimport { inPlane, selectionLayer } from '../planeInput';\nimport { beginMove, type MoveFrame, type ReparentOnDrop } from './session';\nimport { nextFrame } from './frame';\nimport { commitMove } from './commit';\nexport type { ReparentOnDrop };\n\n/**\n * @experimental\n * Drag-translates the selection.\n *\n * Each frame's poses go to the scene's ephemeral override table, not the\n * document: `Scene.setPose` records an undo entry per call, and the overrides\n * are what let a node deriving its geometry from a dragged one follow the\n * drag. Release commits one batch — at most one undo entry, none when the\n * binding's params make it transient — and cancel drops the overrides.\n *\n * Behaviors from the binding's `opts.behaviors` fold into each frame; on\n * release the first non-`undefined` answer wins (`Op[]` commits, `null`\n * aborts). `beginMove` appends the action's own two: a layout drop and\n * reparent-on-drop.\n */\nexport const moveAction: Action & { requires: string[] } = inPlane({\n  id: 'move',\n  label: 'Move',\n  // No hover `cursor`: pointing at a node shouldn't preemptively promise a move.\n  activeCursor: 'move',\n  // Ambient default targets `selected-body`, not a bare `{ kind: 'drag' }`,\n  // which catches every drag in ambient scope and bleeds the move into\n  // drawing-tool gestures wherever the higher-priority active match falls\n  // through.\n  defaultBinding: { kind: 'drag', target: 'selected-body' },\n  eligible: { capability: 'transforms-selection' },\n  requires: ['selection', 'scene', 'poseDescriptor', 'layout', 'applyOps', 'geometryProjection', 'nodeAtPoint', 'view'],\n  invoker: {\n    timing: 'ongoing',\n    start(ctx: InvocationCtx, opts?: BindingOpts): OngoingHandle {\n      let frame: MoveFrame = { delta: { dx: 0, dy: 0 }, previews: new Map(), opaque: new Set() };\n      const begun = beginMove(ctx, opts, () => frame);\n      if (!begun) return {};\n      const { session, readers } = begun;\n      const hold = session.scene.overrides.hold();\n      // Where the last move put the pointer, once the drag has passed its\n      // threshold; null until then.\n      let engaged: { x: number; y: number } | null = null;\n      return {\n        kind: 'move',\n        onMove(moveCtx: InvocationCtx): void {\n          if (!moveCtx.drag) return;\n          if (!engaged) {\n            const s = moveCtx.drag.screenDelta;\n            if (s && !pastDragThreshold({ clientX: 0, clientY: 0 }, { clientX: s.x, clientY: s.y }, session.dragThresholdPx)) return;\n            session.lifecycle.start(session.ids as unknown as string[]);\n          }\n          engaged = moveCtx.world;\n          frame = nextFrame(session, readers, moveCtx);\n          hold.set(frame.previews);\n        },\n        onEnd(endCtx: InvocationCtx, reason: 'commit' | 'cancel'): void {\n          let committed = false;\n          try {\n            // A press that never traveled `dragThresholdPx` was never a move:\n            // its behaviors started, so they are canceled, not asked to commit.\n            if (reason === 'commit' && engaged) {\n              committed = commitMove({\n                session,\n                delta: frame.delta,\n                at: endCtx.drag ? endCtx.world : engaged,\n              });\n            } else runBehaviorCancel(session.behaviors, session.gestureCtx);\n          } finally {\n            // After the commit, so no frame can paint the pre-drag pose between\n            // the override going away and the document catching up.\n            closeGesture({ hold, previews: frame.previews, behaviors: session.behaviors, ctx: session.gestureCtx, lifecycle: session.lifecycle }, committed);\n          }\n        },\n        previewIds: () => frame.previews.keys(),\n        previewPose: (id: string) => frame.previews.get(id as NodeId) ?? null,\n        previewOpaqueIds: () => (frame.opaque.size === 0 ? null : frame.opaque),\n      };\n    },\n  },\n  /**\n   * Always enabled: the dispatcher treats anything `!== true` as \"fall\n   * through to the next-best match\", so a disabled reason here loses every\n   * drag-on-selected-body to a lower-specificity binding (a shape tool's\n   * insert drag).\n   */\n  enabled: () => true,\n}, selectionLayer);\n"],"mappings":";;;;;;;AA0BA,IAAaA,IAA8CC,EAAQ;CACjE,IAAI;CACJ,OAAO;CAEP,cAAc;CAKd,gBAAgB;EAAE,MAAM;EAAQ,QAAQ;CAAgB;CACxD,UAAU,EAAE,YAAY,uBAAuB;CAC/C,UAAU;EAAC;EAAa;EAAS;EAAkB;EAAU;EAAY;EAAsB;EAAe;CAAM;CACpH,SAAS;EACP,QAAQ;EACR,MAAM,GAAoB,GAAmC;GAC3D,IAAIC,IAAmB;IAAE,OAAO;KAAE,IAAI;KAAG,IAAI;IAAE;IAAG,0BAAU,IAAI,IAAI;IAAG,wBAAQ,IAAI,IAAI;GAAE,GACnFC,IAAQC,EAAUC,GAAKC,SAAYJ,CAAK;GAC9C,IAAI,CAACC,GAAO,OAAO,CAAC;GACpB,IAAM,EAAE,YAAS,eAAYA,GACvBI,IAAOC,EAAQ,MAAM,UAAU,KAAK,GAGtCC,IAA2C;GAC/C,OAAO;IACL,MAAM;IACN,OAAO,GAA8B;KACnC,IAAKC,EAAQ,MACb;UAAI,CAACD,GAAS;OACZ,IAAME,IAAID,EAAQ,KAAK;OACvB,IAAIC,KAAK,CAACC,EAAkB;QAAE,SAAS;QAAG,SAAS;OAAE,GAAG;QAAE,SAASD,EAAE;QAAG,SAASA,EAAE;OAAE,GAAGH,EAAQ,eAAe,GAAG;OAClH,EAAQ,UAAU,MAAMA,EAAQ,GAA0B;MAC5D;MAGA,AAFA,IAAUE,EAAQ,OAClB,IAAQG,EAAUL,GAASM,GAASJ,CAAO,GAC3CH,EAAK,IAAIL,EAAM,QAAQ;KAHvB;IAIF;IACA,MAAM,GAAuB,GAAmC;KAC9D,IAAIa,IAAY;KAChB,IAAI;MAGF,AAAIC,MAAW,YAAYP,IACzB,IAAYQ,EAAW;OACrB;OACA,OAAOf,EAAM;OACb,IAAIgB,EAAO,OAAOA,EAAO,QAAQT;MACnC,CAAC,IACIU,EAAkBX,EAAQ,WAAWA,EAAQ,UAAU;KAChE,UAAU;MAGR,EAAa;OAAE;OAAM,UAAUN,EAAM;OAAU,WAAWM,EAAQ;OAAW,KAAKA,EAAQ;OAAY,WAAWA,EAAQ;MAAU,GAAGO,CAAS;KACjJ;IACF;IACA,kBAAkBb,EAAM,SAAS,KAAK;IACtC,cAAc,MAAeA,EAAM,SAAS,IAAIkB,CAAY,KAAK;IACjE,wBAAyBlB,EAAM,OAAO,SAAS,IAAI,OAAOA,EAAM;GAClE;EACF;CACF;CAOA,eAAe;AACjB,GAAGmB,CAAc"}

package/dist/interactions/actions/move/behaviors/layoutDrop.js

@@ -0,0 +1,51 @@
+import { layoutDropOps as e } from "../commit/layoutDrop.js";
+import { runDropPass as t } from "../layout/dropPass.js";
+import { layoutReleaseOps as n } from "../commit/layoutRelease.js";
+import { landReleased as r, releasedPoses as i, stepGlide as a } from "../layout/glide.js";
+//#region src/interactions/actions/move/behaviors/layoutDrop.ts
+function o(o) {
+	let s = null, c = /* @__PURE__ */ new Set(), l = null, u = () => {
+		let e = o.session();
+		e.layout?.reflow && (l = i(e, o.frame().previews));
+	};
+	return {
+		onMove(e, n) {
+			if (s = null, n.kind !== "translate") return;
+			let r = o.session();
+			s = t(r, {
+				dx: n.dx,
+				dy: n.dy
+			}, {
+				x: e.pointer.worldX,
+				y: e.pointer.worldY
+			});
+			let i = s?.pass?.reflowIds, l = r.layout?.reflow;
+			return l ? (a(l, c, s?.reflow ?? /* @__PURE__ */ new Map()), { opaque: i }) : {
+				poses: s?.reflow,
+				opaque: i
+			};
+		},
+		onEnd(t, r) {
+			if (u(), r.answered) return;
+			let i = o.session(), { delta: a } = o.frame();
+			if (a.dx === 0 && a.dy === 0) return;
+			let c = (e) => e.length > 0 ? e : null;
+			if (s?.pass) return c(e(i, s.pass));
+			let l = n(i, a, s?.dropCenter ?? null);
+			return l === void 0 ? void 0 : c(l);
+		},
+		onCancel: u,
+		onSettled() {
+			let e = o.session(), t = e.layout?.reflow;
+			if (t) {
+				for (let e of c) t.settle(e);
+				r(e, t, l ?? /* @__PURE__ */ new Map());
+			}
+			c.clear();
+		}
+	};
+}
+//#endregion
+export { o as layoutDrop };
+
+//# sourceMappingURL=layoutDrop.js.map

package/dist/interactions/actions/move/behaviors/layoutDrop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"layoutDrop.js","names":["layoutDrop","drop","gliding","released","noteReleased","session","move","releasedPoses","proposed","runDropPass","ctx","opaque","reflow","stepGlide","end","delta","orAbort","ops","layoutDropOps","release","layoutReleaseOps","id"],"sources":["../../../../../src/interactions/actions/move/behaviors/layoutDrop.ts"],"sourcesContent":["import type { Op } from 'core/ops/types';\nimport type { NodeId } from 'core/scene/types';\nimport type { BehaviorResult, MoveBehavior } from '../../../gestures/types';\nimport { layoutDropOps } from '../commit/layoutDrop';\nimport { layoutReleaseOps } from '../commit/layoutRelease';\nimport { runDropPass } from '../layout/dropPass';\nimport { landReleased, releasedPoses, stepGlide, type Released } from '../layout/glide';\nimport type { DropPass } from '../layout/types';\nimport type { MoveGesture } from '../session';\n\n/**\n * The move behavior that drops the selection into the layout container under\n * it. Each move it resolves the drop and shows the siblings making room; on\n * release it answers with the container's `commitDrop`, or, outside every\n * container, with what the source layouts' `releaseDrop` and the exits decide.\n *\n * Built by the move action for one drag, after the binding's own behaviors, and\n * only when the `layout` dep is present.\n */\nexport function layoutDrop(move: MoveGesture): MoveBehavior<unknown> {\n  // This frame's pass; reset by every move, a throwing one included.\n  let drop: DropPass | null = null;\n  const gliding = new Set<NodeId>();\n  let released: Map<NodeId, Released> | null = null;\n  // Before the commit: where each dragged id is shown as the gesture closes.\n  const noteReleased = (): void => {\n    const session = move.session();\n    if (session.layout?.reflow) released = releasedPoses(session, move.frame().previews);\n  };\n\n  return {\n    onMove(ctx, proposed): BehaviorResult<unknown> | void {\n      drop = null;\n      if (proposed.kind !== 'translate') return;\n      const session = move.session();\n      drop = runDropPass(\n        session,\n        { dx: proposed.dx, dy: proposed.dy },\n        { x: ctx.pointer.worldX, y: ctx.pointer.worldY },\n      );\n      const opaque = drop?.pass?.reflowIds;\n      const reflow = session.layout?.reflow;\n      if (!reflow) return { poses: drop?.reflow, opaque };\n      stepGlide(reflow, gliding, drop?.reflow ?? new Map());\n      return { opaque };\n    },\n\n    onEnd(_ctx, end): Op[] | null | void {\n      noteReleased();\n      if (end.answered) return;\n      const session = move.session();\n      const { delta } = move.frame();\n      // No-op if no movement (sub-threshold drag or zero delta).\n      if (delta.dx === 0 && delta.dy === 0) return;\n      // A drop or a release that claims the selection and writes nothing\n      // commits nothing: the translate must not run in its place.\n      const orAbort = (ops: Op[]): Op[] | null => (ops.length > 0 ? ops : null);\n      // Layout drop commit — takes precedence over reparent-on-drop when a\n      // layout container accepted the drag this gesture. One placement per\n      // dragged child, replayed in the order the preview resolved them.\n      // TODO: geometryProjection for drop-reflow — left pose-only because the\n      // reflow distributes per-child poses with no single global delta; not\n      // exercised by the geometry contract gate.\n      if (drop?.pass) return orAbort(layoutDropOps(session, drop.pass));\n      const release = layoutReleaseOps(session, delta, drop?.dropCenter ?? null);\n      return release === undefined ? undefined : orAbort(release);\n    },\n\n    onCancel: noteReleased,\n\n    onSettled(): void {\n      const session = move.session();\n      const reflow = session.layout?.reflow;\n      // After the commit: each glide settles onto the pose the document now\n      // holds, or back home on a cancel — the dragged ids from where they\n      // were let go.\n      if (reflow) {\n        for (const id of gliding) reflow.settle(id as string);\n        landReleased(session, reflow, released ?? new Map());\n      }\n      gliding.clear();\n    },\n  };\n}\n"],"mappings":";;;;;AAmBA,SAAgBA,EAAW,GAA0C;CAEnE,IAAIC,IAAwB,MACtBC,oBAAU,IAAI,IAAY,GAC5BC,IAAyC,MAEvCC,UAA2B;EAC/B,IAAMC,IAAUC,EAAK,QAAQ;EAC7B,AAAID,EAAQ,QAAQ,WAAQ,IAAWE,EAAcF,GAASC,EAAK,MAAM,CAAC,CAAC,QAAQ;CACrF;CAEA,OAAO;EACL,OAAO,GAAK,GAA0C;GAEpD,IADA,IAAO,MACHE,EAAS,SAAS,aAAa;GACnC,IAAMH,IAAUC,EAAK,QAAQ;GAC7B,IAAOG,EACLJ,GACA;IAAE,IAAIG,EAAS;IAAI,IAAIA,EAAS;GAAG,GACnC;IAAE,GAAGE,EAAI,QAAQ;IAAQ,GAAGA,EAAI,QAAQ;GAAO,CACjD;GACA,IAAMC,IAASV,GAAM,MAAM,WACrBW,IAASP,EAAQ,QAAQ;GAG/B,OAFKO,KACLC,EAAUD,GAAQV,GAASD,GAAM,0BAAU,IAAI,IAAI,CAAC,GAC7C,EAAE,UAAO,KAFI;IAAE,OAAOA,GAAM;IAAQ;GAAO;EAGpD;EAEA,MAAM,GAAM,GAAyB;GAEnC,IADAG,EAAa,GACTU,EAAI,UAAU;GAClB,IAAMT,IAAUC,EAAK,QAAQ,GACvB,EAAE,aAAUA,EAAK,MAAM;GAE7B,IAAIS,EAAM,OAAO,KAAKA,EAAM,OAAO,GAAG;GAGtC,IAAMC,KAAW,MAA4BC,EAAI,SAAS,IAAIA,IAAM;GAOpE,IAAIhB,GAAM,MAAM,OAAOe,EAAQE,EAAcb,GAASJ,EAAK,IAAI,CAAC;GAChE,IAAMkB,IAAUC,EAAiBf,GAASU,GAAOd,GAAM,cAAc,IAAI;GACzE,OAAOkB,MAAY,KAAA,IAAY,KAAA,IAAYH,EAAQG,CAAO;EAC5D;EAEA,UAAUf;EAEV,YAAkB;GAChB,IAAMC,IAAUC,EAAK,QAAQ,GACvBM,IAASP,EAAQ,QAAQ;GAI/B,IAAIO,GAAQ;IACV,KAAK,IAAMS,KAAMnB,GAAS,EAAO,OAAOmB,CAAY;IACpD,EAAahB,GAASO,GAAQT,qBAAY,IAAI,IAAI,CAAC;GACrD;GACA,EAAQ,MAAM;EAChB;CACF;AACF"}

package/dist/interactions/actions/move/behaviors/reparentOnDrop.js

@@ -0,0 +1,15 @@
+import { reparentOps as e, resolveDropTarget as t } from "../commit/reparent.js";
+//#region src/interactions/actions/move/behaviors/reparentOnDrop.ts
+function n(n) {
+	return { onEnd(r, i) {
+		if (i.answered) return;
+		let a = n.session(), { delta: o } = n.frame();
+		if (o.dx === 0 && o.dy === 0) return;
+		let s = a.reparentOnDrop(), c = s === "off" ? null : t(a, i.pointer);
+		return c ? e(a, c, s, o) : void 0;
+	} };
+}
+//#endregion
+export { n as reparentOnDrop };
+
+//# sourceMappingURL=reparentOnDrop.js.map

package/dist/interactions/actions/move/behaviors/reparentOnDrop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reparentOnDrop.js","names":["reparentOnDrop","end","session","move","delta","mode","target","resolveDropTarget","reparentOps"],"sources":["../../../../../src/interactions/actions/move/behaviors/reparentOnDrop.ts"],"sourcesContent":["import type { MoveBehavior } from '../../../gestures/types';\nimport { reparentOps, resolveDropTarget } from '../commit/reparent';\nimport type { MoveGesture } from '../session';\n\n/**\n * The move behavior that reparents the selection under the node the pointer is\n * released over, when the binding's `reparentOnDrop` param asks for it.\n *\n * Built by the move action for one drag and run last, so a binding's behavior\n * or a layout drop that claims the commit preempts it.\n */\nexport function reparentOnDrop(move: MoveGesture): MoveBehavior<unknown> {\n  return {\n    onEnd(_ctx, end) {\n      if (end.answered) return;\n      const session = move.session();\n      const { delta } = move.frame();\n      // No-op if no movement (sub-threshold drag or zero delta).\n      if (delta.dx === 0 && delta.dy === 0) return;\n      // Reparent-on-drop, when opted in via `opts.params.reparentOnDrop`.\n      // Resolves the drop target via the `nodeAtPoint` dep (sourced by\n      // `<SceneCanvas>`) and reparents each moved root under it, then\n      // writes the translated pose in the new parent's frame so the\n      // visual position is preserved across the parent swap.\n      // An end with no drag carries no pointer: the dispatcher's `cancelAll`\n      // reports the world origin.\n      const mode = session.reparentOnDrop();\n      const target = mode !== 'off' ? resolveDropTarget(session, end.pointer) : null;\n      return target ? reparentOps(session, target, mode, delta) : undefined;\n    },\n  };\n}\n"],"mappings":";;AAWA,SAAgBA,EAAe,GAA0C;CACvE,OAAO,EACL,MAAM,GAAM,GAAK;EACf,IAAIC,EAAI,UAAU;EAClB,IAAMC,IAAUC,EAAK,QAAQ,GACvB,EAAE,aAAUA,EAAK,MAAM;EAE7B,IAAIC,EAAM,OAAO,KAAKA,EAAM,OAAO,GAAG;EAQtC,IAAMC,IAAOH,EAAQ,eAAe,GAC9BI,IAASD,MAAS,QAAkD,OAA1CE,EAAkBL,GAASD,EAAI,OAAO;EACtE,OAAOK,IAASE,EAAYN,GAASI,GAAQD,GAAMD,CAAK,IAAI,KAAA;CAC9D,EACF;AACF"}

package/dist/interactions/actions/move/behaviors/snapToContainer.js

@@ -1,5 +1,5 @@
-import { createTransformOp as e } from "../../../../core/ops/transform.js";
-import { createReparentOp as t } from "../../../../core/ops/reparent.js";
+import { createReparentOp as e } from "../../../../core/ops/reparent.js";
+import { createTransformOp as t } from "../../../../core/ops/transform.js";
 import { getScratch as n, scratchKey as r, setScratch as i } from "@weasel-js/routing";
 //#region src/interactions/actions/move/behaviors/snapToContainer.ts
 var a = r("snapToContainer");
@@ -46,29 +46,30 @@ function c(n) {
 		onCancel(e) {
 			s(o(e));
 		},
-		onEnd(n) {
-			let r = o(n);
-			s(r);
-			let i = r.committedSnap ?? n.snap;
-			if (!i) return;
-			let a = [], d = u(n, i);
-			for (let e of n.draggedIds) d.has(e) || d.set(e, n.current.get(e));
-			for (let [r, o] of d) {
-				a.push(e({
-					id: r,
-					from: n.origin.get(r),
-					to: o,
-					label: c
-				}));
-				let s = n.adapter.getParent?.(r) ?? null;
-				s !== i.parentId && a.push(t({
-					id: r,
-					fromParentId: s,
-					toParentId: i.parentId,
+		onEnd(n, r) {
+			let i = o(n);
+			s(i);
+			let a = i.committedSnap ?? n.snap;
+			if (!a) return;
+			let d = [], f = (t) => {
+				let r = n.adapter.getParent?.(t) ?? null;
+				r !== a.parentId && d.push(e({
+					id: t,
+					fromParentId: r,
+					toParentId: a.parentId,
 					label: l
 				}));
-			}
-			return a;
+			}, p = u(n, a);
+			for (let [e, r] of p) d.push(t({
+				id: e,
+				from: n.origin.get(e),
+				to: r,
+				label: c
+			})), f(e);
+			let m = n.draggedIds.filter((e) => !p.has(e));
+			d.push(...r.translateOps(m));
+			for (let e of m) f(e);
+			return d;
 		}
 	};
 }