@weasel-js/core 1.9.4 → 1.10.1

package/dist/interactions/actions/geometryProjection.js.map

@@ -1 +1 @@
-{"version":3,"file":"geometryProjection.js","names":["geometryDataOp","projection","node","next","m","createSetDataOp"],"sources":["../../../src/interactions/actions/geometryProjection.ts"],"sourcesContent":["import { type Mat3 } from '@weasel-js/geom';\nimport { createSetDataOp } from 'core/ops/setData';\nimport type { Op } from 'core/ops/types';\n\n/** Optional consumer seam: given a node and the affine `m` that a pose-transform\n *  action applied to the node's POSE, return updated `data` with the node's\n *  data-held geometry transformed by `m`, or `null` if this node has no\n *  data-held geometry (the kit leaves `data` alone). */\nexport interface GeometryProjection {\n  transform(node: { id?: string; data: unknown; pose: unknown }, m: Mat3): unknown | null;\n}\n\n/** Build the `setData` op for a node when a geometryProjection is wired and\n *  returns non-null. Returns `undefined` (no op) otherwise — keeping the data\n *  op strictly opt-in so adapters without `setData` are never invoked. */\nexport function geometryDataOp(\n  projection: GeometryProjection | undefined,\n  node: { id: string; data: unknown; pose: unknown } | undefined,\n  m: Mat3,\n  label: string,\n): Op | undefined {\n  if (!projection || !node) return undefined;\n  const next = projection.transform(node, m);\n  if (next == null) return undefined;\n  return createSetDataOp({ id: node.id, from: node.data, to: next, label, coalesceKey: `setData:${node.id}` });\n}\n"],"mappings":";;;AAeA,SAAgBA,EACd,GACA,GACA,GACA,GACgB;CAChB,IAAI,CAACC,KAAc,CAACC,GAAM;CAC1B,IAAMC,IAAOF,EAAW,UAAUC,GAAME,CAAC;CACzC,IAAID,KAAQ,MACZ,OAAOE,EAAgB;EAAE,IAAIH,EAAK;EAAI,MAAMA,EAAK;EAAM,IAAIC;EAAM;EAAO,aAAa,WAAWD,EAAK;CAAK,CAAC;AAC7G"}
+{"version":3,"file":"geometryProjection.js","names":["geometryDataOp","projection","node","next","m","createSetDataOp"],"sources":["../../../src/interactions/actions/geometryProjection.ts"],"sourcesContent":["import { type Affine } from '@weasel-js/geom';\nimport { createSetDataOp } from 'core/ops/setData';\nimport type { Op } from 'core/ops/types';\n\n/** Optional consumer seam: given a node and the affine `m` that a pose-transform\n *  action applied to the node's POSE, return updated `data` with the node's\n *  data-held geometry transformed by `m`, or `null` if this node has no\n *  data-held geometry (the kit leaves `data` alone). */\nexport interface GeometryProjection {\n  transform(node: { id?: string; data: unknown; pose: unknown }, m: Affine): unknown | null;\n}\n\n/** Build the `setData` op for a node when a geometryProjection is wired and\n *  returns non-null. Returns `undefined` (no op) otherwise — keeping the data\n *  op strictly opt-in so adapters without `setData` are never invoked. */\nexport function geometryDataOp(\n  projection: GeometryProjection | undefined,\n  node: { id: string; data: unknown; pose: unknown } | undefined,\n  m: Affine,\n  label: string,\n): Op | undefined {\n  if (!projection || !node) return undefined;\n  const next = projection.transform(node, m);\n  if (next == null) return undefined;\n  return createSetDataOp({ id: node.id, from: node.data, to: next, label, coalesceKey: `setData:${node.id}` });\n}\n"],"mappings":";;;AAeA,SAAgBA,EACd,GACA,GACA,GACA,GACgB;CAChB,IAAI,CAACC,KAAc,CAACC,GAAM;CAC1B,IAAMC,IAAOF,EAAW,UAAUC,GAAME,CAAC;CACzC,IAAID,KAAQ,MACZ,OAAOE,EAAgB;EAAE,IAAIH,EAAK;EAAI,MAAMA,EAAK;EAAM,IAAIC;EAAM;EAAO,aAAa,WAAWD,EAAK;CAAK,CAAC;AAC7G"}

package/dist/interactions/actions/gestureFrames.js

@@ -0,0 +1,18 @@
+import { planeOf as e } from "./planeInput.js";
+import { scenePoseFrame as t } from "./poseFrame.js";
+//#region src/interactions/actions/gestureFrames.ts
+function n(n, r, i = t(n)) {
+	return {
+		world: (e) => i.world(e),
+		toWorld: (e, t) => {
+			let n = i.parentWorld(e);
+			return n === null ? t : i.pc.compose(n, t);
+		},
+		toLocal: (e, t) => i.local(e, t),
+		planeOf: (t) => e(r, t)
+	};
+}
+//#endregion
+export { n as sceneGestureFrames };
+
+//# sourceMappingURL=gestureFrames.js.map

package/dist/interactions/actions/gestureFrames.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gestureFrames.js","names":["sceneGestureFrames","scenePoseFrame","scene","frame","id","parent","pose","worldPose","planeOf","view","layer"],"sources":["../../../src/interactions/actions/gestureFrames.ts"],"sourcesContent":["import type { NodeId, Scene } from 'core/scene/types';\nimport type { GestureFrames } from '../gestures/types';\nimport { planeOf } from './planeInput';\nimport { scenePoseFrame, type PoseFrame } from './poseFrame';\n\n/** A scene-backed gesture's {@link GestureFrames}. `view` is the `view` dep. */\nexport function sceneGestureFrames(\n  scene: Scene<unknown, string, unknown>,\n  view: unknown,\n  frame: PoseFrame<unknown> = scenePoseFrame(scene),\n): GestureFrames<unknown> {\n  return {\n    world: (id) => frame.world(id as NodeId),\n    toWorld: (id, pose) => {\n      const parent = frame.parentWorld(id as NodeId);\n      return parent === null ? pose : frame.pc.compose(parent, pose);\n    },\n    toLocal: (id, worldPose) => frame.local(id as NodeId, worldPose),\n    planeOf: (layer) => planeOf(view, layer),\n  };\n}\n"],"mappings":";;;AAMA,SAAgBA,EACd,GACA,GACA,IAA4BC,EAAeC,CAAK,GACxB;CACxB,OAAO;EACL,QAAQ,MAAOC,EAAM,MAAMC,CAAY;EACvC,UAAU,GAAI,MAAS;GACrB,IAAMC,IAASF,EAAM,YAAYC,CAAY;GAC7C,OAAOC,MAAW,OAAOC,IAAOH,EAAM,GAAG,QAAQE,GAAQC,CAAI;EAC/D;EACA,UAAU,GAAI,MAAcH,EAAM,MAAMC,GAAcG,CAAS;EAC/D,UAAU,MAAUC,EAAQC,GAAMC,CAAK;CACzC;AACF"}

package/dist/interactions/actions/gestureLifecycle.js

@@ -1,9 +1,10 @@
+import { SceneArrivalRefused as e } from "../../core/scene/arrivals.js";
 //#region src/interactions/actions/gestureLifecycle.ts
-function e(e) {
+function t(e) {
 	let t = {};
 	return e.label !== void 0 && (t.label = e.label), e.transient !== void 0 && (t.transient = e.transient), e.onGestureStart && (t.onGestureStart = e.onGestureStart), e.onGestureEnd && (t.onGestureEnd = e.onGestureEnd), t;
 }
-function t(e, t, n = []) {
+function n(e, t, n = []) {
 	let r = e ?? {}, i = !1, a = !1;
 	return {
 		label: r.label ?? t,
@@ -17,28 +18,54 @@ function t(e, t, n = []) {
 		}
 	};
 }
-function n(e, t, n) {
-	if (t.transient) {
-		e.scene.untracked(() => {
-			for (let t of n) t.apply(e.adapter);
-		});
-		return;
+function r(t, n, r) {
+	if (n.transient) {
+		try {
+			t.scene.untracked(() => {
+				for (let e of r) e.apply(t.adapter);
+			});
+		} catch (t) {
+			if (!(t instanceof e)) throw t;
+			return !1;
+		}
+		return !0;
 	}
-	let r = t.labelFor(n);
-	e.applyOps ? e.applyOps(n, r) : e.scene.applyBatch(n, r, e.adapter);
-}
-function r(e, t) {
-	let n;
-	for (let r of e) {
-		let e = r.onEnd?.(t, { answered: n !== void 0 });
-		n === void 0 && e !== void 0 && (n = e);
+	let i = n.labelFor(r);
+	return t.applyOps ? (t.applyOps(r, i), !0) : t.scene.applyBatch(r, i, t.adapter);
+}
+function i(e, t, ...[n]) {
+	let r, i = !1;
+	return a(e, (e) => {
+		try {
+			let a = e.onEnd?.(t, {
+				...n,
+				answered: i || r !== void 0
+			});
+			r === void 0 && a !== void 0 && (r = a);
+		} catch (e) {
+			throw i = !0, e;
+		}
+	}), r;
+}
+function a(e, t) {
+	let n = [];
+	for (let r of e) try {
+		t(r);
+	} catch (e) {
+		n.push(e);
 	}
-	return n;
+	if (n.length > 0) throw n[0];
+}
+function o(e, t) {
+	a(e, (e) => e.onCancel?.(t));
+}
+function s(e, t, n) {
+	a(e, (e) => e.onSettled?.(t, n));
 }
-function i(e, t) {
-	for (let n of e) n.onCancel?.(t);
+function c(e, t) {
+	e.hold.drop(), e.previews.clear(), a([() => s(e.behaviors, e.ctx, t), () => e.lifecycle.end(t)], (e) => e());
 }
 //#endregion
-export { n as commitGestureOps, e as gestureLifecycleParams, t as readGestureLifecycle, r as reduceBehaviorEnd, i as runBehaviorCancel };
+export { c as closeGesture, r as commitGestureOps, t as gestureLifecycleParams, n as readGestureLifecycle, i as reduceBehaviorEnd, o as runBehaviorCancel, s as runBehaviorSettled };
 
 //# sourceMappingURL=gestureLifecycle.js.map

package/dist/interactions/actions/gestureLifecycle.js.map

@@ -1 +1 @@
-{"version":3,"file":"gestureLifecycle.js","names":["gestureLifecycleParams","out","o","readGestureLifecycle","source","started","ended","defaultLabel","ops","behaviors","b","ids","committed","commitGestureOps","lifecycle","op","target","label","reduceBehaviorEnd","answer","r","ctx","runBehaviorCancel"],"sources":["../../../src/interactions/actions/gestureLifecycle.ts"],"sourcesContent":["/**\n * The lifecycle the ongoing transform actions (`move`, `resize`, `rotate`)\n * share: what their committed batch is called in history, whether it is\n * recorded at all, and the callbacks fired as the gesture opens and closes.\n *\n * Move and rotate read it from their binding's params; resize reads it from\n * the `resizePolicy` dep, where the rest of its options already live.\n */\nimport type { Op } from 'core/ops/types';\nimport type { Scene } from 'core/scene/types';\nimport type { BehaviorEnd } from 'interactions/gestures/types';\n\n/** The lifecycle options, as a binding's params or the resize policy carry\n *  them. */\nexport interface GestureLifecycleOptions {\n  /** History label for the committed batch. Unset, the batch takes its first\n   *  op's label (a layout drop or a behavior names its own), else the\n   *  action's. */\n  label?: string;\n  /** Commit through `scene.untracked`: the edit lands, but no undo entry\n   *  records it and the consumer `applyOps` hook is bypassed. Unset, any\n   *  behavior's `defaultTransient: true` turns it on. */\n  transient?: boolean;\n  /** Fired once the gesture starts changing poses, with the ids it moves. */\n  onGestureStart?(ids: string[]): void;\n  /** Fired once per `onGestureStart`: `true` when the gesture wrote to the\n   *  document, `false` on cancel, abort, or a release with nothing to write. */\n  onGestureEnd?(committed: boolean): void;\n}\n\n/** The params entries for {@link GestureLifecycleOptions}, with the unset\n *  keys left out. */\nexport function gestureLifecycleParams(o: GestureLifecycleOptions): Record<string, unknown> {\n  const out: Record<string, unknown> = {};\n  if (o.label !== undefined) out.label = o.label;\n  if (o.transient !== undefined) out.transient = o.transient;\n  if (o.onGestureStart) out.onGestureStart = o.onGestureStart;\n  if (o.onGestureEnd) out.onGestureEnd = o.onGestureEnd;\n  return out;\n}\n\n/** A gesture's resolved lifecycle. `start` and `end` fire their callbacks at\n *  most once each, and `end` only after `start`. */\nexport interface GestureLifecycle {\n  /** The label ops built by the action itself carry. */\n  readonly label: string;\n  /** The history label for committing `ops`. */\n  labelFor(ops: readonly Op[]): string;\n  readonly transient: boolean;\n  start(ids: readonly string[]): void;\n  end(committed: boolean): void;\n}\n\nexport function readGestureLifecycle(\n  source: GestureLifecycleOptions | Record<string, unknown> | undefined,\n  defaultLabel: string,\n  behaviors: readonly { defaultTransient?: boolean }[] = [],\n): GestureLifecycle {\n  const o = (source ?? {}) as GestureLifecycleOptions;\n  let started = false;\n  let ended = false;\n  return {\n    label: o.label ?? defaultLabel,\n    labelFor: (ops) => o.label ?? ops[0]?.label ?? defaultLabel,\n    transient: o.transient ?? behaviors.some((b) => b.defaultTransient === true),\n    start(ids) {\n      if (started) return;\n      started = true;\n      o.onGestureStart?.([...ids]);\n    },\n    end(committed) {\n      if (!started || ended) return;\n      ended = true;\n      o.onGestureEnd?.(committed);\n    },\n  };\n}\n\n/** Commit a gesture's ops: untracked when transient, else through the\n *  consumer `applyOps` hook when one is wired, else into the scene's history. */\nexport function commitGestureOps(\n  target: {\n    scene: Scene<unknown, string, unknown>;\n    applyOps?: (ops: Op[], label: string) => void;\n    adapter: unknown;\n  },\n  lifecycle: GestureLifecycle,\n  ops: Op[],\n): void {\n  if (lifecycle.transient) {\n    target.scene.untracked(() => {\n      for (const op of ops) op.apply(target.adapter);\n    });\n    return;\n  }\n  const label = lifecycle.labelFor(ops);\n  if (target.applyOps) target.applyOps(ops, label);\n  else target.scene.applyBatch(ops, label, target.adapter);\n}\n\n/** Runs every behavior's `onEnd` in order; the first that answers decides the\n *  commit and later answers are ignored. `null` aborts, `Op[]` claims it (an\n *  empty array included), and `undefined` means every behavior deferred to the\n *  action's own commit. */\nexport function reduceBehaviorEnd<TCtx>(\n  behaviors: readonly { onEnd?(ctx: TCtx, end: BehaviorEnd): Op[] | null | void }[],\n  ctx: TCtx,\n): Op[] | null | undefined {\n  let answer: Op[] | null | undefined;\n  for (const b of behaviors) {\n    const r = b.onEnd?.(ctx, { answered: answer !== undefined });\n    if (answer === undefined && r !== undefined) answer = r;\n  }\n  return answer;\n}\n\n/** Runs every behavior's `onCancel`, for a gesture closing without a commit. */\nexport function runBehaviorCancel<TCtx>(\n  behaviors: readonly { onCancel?(ctx: TCtx): void }[],\n  ctx: TCtx,\n): void {\n  for (const b of behaviors) b.onCancel?.(ctx);\n}\n"],"mappings":";AAgCA,SAAgBA,EAAuB,GAAqD;CAC1F,IAAMC,IAA+B,CAAC;CAKtC,OAJIC,EAAE,UAAU,KAAA,MAAW,EAAI,QAAQA,EAAE,QACrCA,EAAE,cAAc,KAAA,MAAW,EAAI,YAAYA,EAAE,YAC7CA,EAAE,mBAAgB,EAAI,iBAAiBA,EAAE,iBACzCA,EAAE,iBAAc,EAAI,eAAeA,EAAE,eAClCD;AACT;AAcA,SAAgBE,EACd,GACA,GACA,IAAuD,CAAC,GACtC;CAClB,IAAMD,IAAKE,KAAU,CAAC,GAClBC,IAAU,IACVC,IAAQ;CACZ,OAAO;EACL,OAAOJ,EAAE,SAASK;EAClB,WAAW,MAAQL,EAAE,SAASM,EAAI,EAAE,EAAE,SAASD;EAC/C,WAAWL,EAAE,aAAaO,EAAU,MAAM,MAAMC,EAAE,qBAAqB,EAAI;EAC3E,MAAM,GAAK;GACT,AAAIL,MACJ,IAAU,IACVH,EAAE,iBAAiB,CAAC,GAAGS,CAAG,CAAC;EAC7B;EACA,IAAI,GAAW;GACb,AAAKN,KAAW,OAChB,IAAQ,IACRH,EAAE,eAAeU,CAAS;EAC5B;CACF;AACF;AAIA,SAAgBC,EACd,GAKA,GACA,GACM;CACN,IAAIC,EAAU,WAAW;EACvB,EAAO,MAAM,gBAAgB;GAC3B,KAAK,IAAMC,KAAMP,GAAK,EAAG,MAAMQ,EAAO,OAAO;EAC/C,CAAC;EACD;CACF;CACA,IAAMC,IAAQH,EAAU,SAASN,CAAG;CACpC,AAAIQ,EAAO,WAAUA,EAAO,SAASR,GAAKS,CAAK,IAC1CD,EAAO,MAAM,WAAWR,GAAKS,GAAOD,EAAO,OAAO;AACzD;AAMA,SAAgBE,EACd,GACA,GACyB;CACzB,IAAIC;CACJ,KAAK,IAAMT,KAAKD,GAAW;EACzB,IAAMW,IAAIV,EAAE,QAAQW,GAAK,EAAE,UAAUF,MAAW,KAAA,EAAU,CAAC;EAC3D,AAAIA,MAAW,KAAA,KAAaC,MAAM,KAAA,MAAW,IAASA;CACxD;CACA,OAAOD;AACT;AAGA,SAAgBG,EACd,GACA,GACM;CACN,KAAK,IAAMZ,KAAKD,GAAW,EAAE,WAAWY,CAAG;AAC7C"}
+{"version":3,"file":"gestureLifecycle.js","names":["gestureLifecycleParams","out","o","readGestureLifecycle","source","started","ended","defaultLabel","ops","behaviors","b","ids","committed","commitGestureOps","lifecycle","op","target","err","SceneArrivalRefused","label","reduceBehaviorEnd","own","answer","threw","runEvery","r","ctx","errors","item","items","runBehaviorCancel","runBehaviorSettled","closeGesture","gesture","step"],"sources":["../../../src/interactions/actions/gestureLifecycle.ts"],"sourcesContent":["/**\n * The lifecycle the ongoing transform actions (`move`, `resize`, `rotate`)\n * share: what their committed batch is called in history, whether it is\n * recorded at all, and the callbacks fired as the gesture opens and closes.\n *\n * Move and rotate read it from their binding's params; resize reads it from\n * the `resizePolicy` dep, where the rest of its options already live.\n */\nimport type { Op } from 'core/ops/types';\nimport { SceneArrivalRefused } from 'core/scene/arrivals';\nimport type { Scene } from 'core/scene/types';\nimport type { BehaviorEnd } from 'interactions/gestures/types';\nimport type { NodeId, PoseHold } from 'core/scene/types';\n\n/** The lifecycle options, as a binding's params or the resize policy carry\n *  them. */\nexport interface GestureLifecycleOptions {\n  /** History label for the committed batch. Unset, the batch takes its first\n   *  op's label (a layout drop or a behavior names its own), else the\n   *  action's. */\n  label?: string;\n  /** Commit through `scene.untracked`: the edit lands, but no undo entry\n   *  records it and the consumer `applyOps` hook is bypassed. Unset, any\n   *  behavior's `defaultTransient: true` turns it on. */\n  transient?: boolean;\n  /** Fired once the gesture starts changing poses, with the ids it moves. */\n  onGestureStart?(ids: string[]): void;\n  /** Fired once per `onGestureStart`: `true` when the gesture wrote to the\n   *  document, `false` on cancel, abort, or a release with nothing to write. */\n  onGestureEnd?(committed: boolean): void;\n}\n\n/** The params entries for {@link GestureLifecycleOptions}, with the unset\n *  keys left out. */\nexport function gestureLifecycleParams(o: GestureLifecycleOptions): Record<string, unknown> {\n  const out: Record<string, unknown> = {};\n  if (o.label !== undefined) out.label = o.label;\n  if (o.transient !== undefined) out.transient = o.transient;\n  if (o.onGestureStart) out.onGestureStart = o.onGestureStart;\n  if (o.onGestureEnd) out.onGestureEnd = o.onGestureEnd;\n  return out;\n}\n\n/** A gesture's resolved lifecycle. `start` and `end` fire their callbacks at\n *  most once each, and `end` only after `start`. */\nexport interface GestureLifecycle {\n  /** The label ops built by the action itself carry. */\n  readonly label: string;\n  /** The history label for committing `ops`. */\n  labelFor(ops: readonly Op[]): string;\n  readonly transient: boolean;\n  start(ids: readonly string[]): void;\n  end(committed: boolean): void;\n}\n\nexport function readGestureLifecycle(\n  source: GestureLifecycleOptions | Record<string, unknown> | undefined,\n  defaultLabel: string,\n  behaviors: readonly { defaultTransient?: boolean }[] = [],\n): GestureLifecycle {\n  const o = (source ?? {}) as GestureLifecycleOptions;\n  let started = false;\n  let ended = false;\n  return {\n    label: o.label ?? defaultLabel,\n    labelFor: (ops) => o.label ?? ops[0]?.label ?? defaultLabel,\n    transient: o.transient ?? behaviors.some((b) => b.defaultTransient === true),\n    start(ids) {\n      if (started) return;\n      started = true;\n      o.onGestureStart?.([...ids]);\n    },\n    end(committed) {\n      if (!started || ended) return;\n      ended = true;\n      o.onGestureEnd?.(committed);\n    },\n  };\n}\n\n/** Commit a gesture's ops: untracked when transient, else through the\n *  consumer `applyOps` hook when one is wired, else into the scene's history.\n *  Returns whether the commit landed: false when a container refused what\n *  the ops brought it, which the scene reverts. A consumer's `applyOps` may\n *  keep the document elsewhere, so it is taken at its word. */\nexport function commitGestureOps(\n  target: {\n    scene: Scene<unknown, string, unknown>;\n    applyOps?: (ops: Op[], label: string) => void;\n    adapter: unknown;\n  },\n  lifecycle: GestureLifecycle,\n  ops: Op[],\n): boolean {\n  if (lifecycle.transient) {\n    try {\n      target.scene.untracked(() => {\n        for (const op of ops) op.apply(target.adapter);\n      });\n    } catch (err) {\n      // `untracked` lets a refused arrival out; `applyBatch` swallows it.\n      if (!(err instanceof SceneArrivalRefused)) throw err;\n      return false;\n    }\n    return true;\n  }\n  const label = lifecycle.labelFor(ops);\n  if (!target.applyOps) return target.scene.applyBatch(ops, label, target.adapter);\n  target.applyOps(ops, label);\n  return true;\n}\n\n/** The trailing argument of {@link reduceBehaviorEnd}: what `TEnd` adds to\n *  `BehaviorEnd`, required exactly when it adds something. */\ntype OwnEndFields<TEnd extends BehaviorEnd> = keyof Omit<TEnd, keyof BehaviorEnd> extends never\n  ? [own?: Omit<TEnd, keyof BehaviorEnd>]\n  : [own: Omit<TEnd, keyof BehaviorEnd>];\n\n/** Runs every behavior's `onEnd` in order; the first that answers decides the\n *  commit and later answers are ignored. `null` aborts, `Op[]` claims it (an\n *  empty array included), and `undefined` means every behavior deferred to the\n *  action's own commit. An action whose behaviors take more than a plain\n *  `BehaviorEnd` passes the rest as `own`; each `onEnd` gets it beside\n *  `answered`. One that throws does not stop the rest, which are told the\n *  commit is decided; its error is rethrown after, so nothing commits. */\nexport function reduceBehaviorEnd<TCtx, TEnd extends BehaviorEnd = BehaviorEnd>(\n  behaviors: readonly { onEnd?(ctx: TCtx, end: TEnd): Op[] | null | void }[],\n  ctx: TCtx,\n  ...[own]: OwnEndFields<TEnd>\n): Op[] | null | undefined {\n  let answer: Op[] | null | undefined;\n  let threw = false;\n  runEvery(behaviors, (b) => {\n    try {\n      const r = b.onEnd?.(ctx, { ...own, answered: threw || answer !== undefined } as TEnd);\n      if (answer === undefined && r !== undefined) answer = r;\n    } catch (err) {\n      threw = true;\n      throw err;\n    }\n  });\n  return answer;\n}\n\n/** Runs `step` for every item, a throwing one included, then rethrows the\n *  first error. For steps that each release something of their own. */\nfunction runEvery<T>(items: readonly T[], step: (item: T) => void): void {\n  const errors: unknown[] = [];\n  for (const item of items) {\n    try {\n      step(item);\n    } catch (err) {\n      errors.push(err);\n    }\n  }\n  if (errors.length > 0) throw errors[0];\n}\n\n/** Runs every behavior's `onCancel`, for a gesture closing without a commit.\n *  One that throws does not stop the rest; its error is rethrown after. */\nexport function runBehaviorCancel<TCtx>(\n  behaviors: readonly { onCancel?(ctx: TCtx): void }[],\n  ctx: TCtx,\n): void {\n  runEvery(behaviors, (b) => b.onCancel?.(ctx));\n}\n\n/** Runs every behavior's `onSettled`, once the gesture's commit has landed or\n *  its cancel has run. One that throws does not stop the rest; its error is\n *  rethrown after. */\nexport function runBehaviorSettled<TCtx>(\n  behaviors: readonly { onSettled?(ctx: TCtx, committed: boolean): void }[],\n  ctx: TCtx,\n  committed: boolean,\n): void {\n  runEvery(behaviors, (b) => b.onSettled?.(ctx, committed));\n}\n\n/** What {@link closeGesture} closes. */\nexport interface ClosingGesture<TCtx> {\n  hold: PoseHold<unknown>;\n  /** The action's own buffer of this frame's poses, emptied at the close. */\n  previews: Map<NodeId, unknown>;\n  behaviors: readonly { onSettled?(ctx: TCtx, committed: boolean): void }[];\n  ctx: TCtx;\n  lifecycle: GestureLifecycle;\n}\n\n/**\n * The close a transform action runs from its `finally`, commit or cancel:\n * drop the preview overrides, tell the behaviors, then fire `onGestureEnd`,\n * which fires even when a behavior's `onSettled` throws; the first error is\n * rethrown.\n */\nexport function closeGesture<TCtx>(gesture: ClosingGesture<TCtx>, committed: boolean): void {\n  gesture.hold.drop();\n  gesture.previews.clear();\n  runEvery([\n    () => runBehaviorSettled(gesture.behaviors, gesture.ctx, committed),\n    () => gesture.lifecycle.end(committed),\n  ], (step) => step());\n}\n"],"mappings":";;AAkCA,SAAgBA,EAAuB,GAAqD;CAC1F,IAAMC,IAA+B,CAAC;CAKtC,OAJIC,EAAE,UAAU,KAAA,MAAW,EAAI,QAAQA,EAAE,QACrCA,EAAE,cAAc,KAAA,MAAW,EAAI,YAAYA,EAAE,YAC7CA,EAAE,mBAAgB,EAAI,iBAAiBA,EAAE,iBACzCA,EAAE,iBAAc,EAAI,eAAeA,EAAE,eAClCD;AACT;AAcA,SAAgBE,EACd,GACA,GACA,IAAuD,CAAC,GACtC;CAClB,IAAMD,IAAKE,KAAU,CAAC,GAClBC,IAAU,IACVC,IAAQ;CACZ,OAAO;EACL,OAAOJ,EAAE,SAASK;EAClB,WAAW,MAAQL,EAAE,SAASM,EAAI,EAAE,EAAE,SAASD;EAC/C,WAAWL,EAAE,aAAaO,EAAU,MAAM,MAAMC,EAAE,qBAAqB,EAAI;EAC3E,MAAM,GAAK;GACT,AAAIL,MACJ,IAAU,IACVH,EAAE,iBAAiB,CAAC,GAAGS,CAAG,CAAC;EAC7B;EACA,IAAI,GAAW;GACb,AAAKN,KAAW,OAChB,IAAQ,IACRH,EAAE,eAAeU,CAAS;EAC5B;CACF;AACF;AAOA,SAAgBC,EACd,GAKA,GACA,GACS;CACT,IAAIC,EAAU,WAAW;EACvB,IAAI;GACF,EAAO,MAAM,gBAAgB;IAC3B,KAAK,IAAMC,KAAMP,GAAK,EAAG,MAAMQ,EAAO,OAAO;GAC/C,CAAC;EACH,SAASC,GAAK;GAEZ,IAAI,EAAEA,aAAeC,IAAsB,MAAMD;GACjD,OAAO;EACT;EACA,OAAO;CACT;CACA,IAAME,IAAQL,EAAU,SAASN,CAAG;CAGpC,OAFKQ,EAAO,YACZA,EAAO,SAASR,GAAKW,CAAK,GACnB,MAFsBH,EAAO,MAAM,WAAWR,GAAKW,GAAOH,EAAO,OAAO;AAGjF;AAeA,SAAgBI,EACd,GACA,GACA,GAAG,CAACC,IACqB;CACzB,IAAIC,GACAC,IAAQ;CAUZ,OATAC,EAASf,IAAY,MAAM;EACzB,IAAI;GACF,IAAMgB,IAAIf,EAAE,QAAQgB,GAAK;IAAE,GAAGL;IAAK,UAAUE,KAASD,MAAW,KAAA;GAAU,CAAS;GACpF,AAAIA,MAAW,KAAA,KAAaG,MAAM,KAAA,MAAW,IAASA;EACxD,SAASR,GAAK;GAEZ,MADA,IAAQ,IACFA;EACR;CACF,CAAC,GACMK;AACT;AAIA,SAASE,EAAY,GAAqB,GAA+B;CACvE,IAAMG,IAAoB,CAAC;CAC3B,KAAK,IAAMC,KAAQC,GACjB,IAAI;EACF,EAAKD,CAAI;CACX,SAASX,GAAK;EACZ,EAAO,KAAKA,CAAG;CACjB;CAEF,IAAIU,EAAO,SAAS,GAAG,MAAMA,EAAO;AACtC;AAIA,SAAgBG,EACd,GACA,GACM;CACN,EAASrB,IAAY,MAAMC,EAAE,WAAWgB,CAAG,CAAC;AAC9C;AAKA,SAAgBK,EACd,GACA,GACA,GACM;CACN,EAAStB,IAAY,MAAMC,EAAE,YAAYgB,GAAKd,CAAS,CAAC;AAC1D;AAkBA,SAAgBoB,EAAmB,GAA+B,GAA0B;CAG1F,AAFAC,EAAQ,KAAK,KAAK,GAClBA,EAAQ,SAAS,MAAM,GACvBT,EAAS,OACDO,EAAmBE,EAAQ,WAAWA,EAAQ,KAAKrB,CAAS,SAC5DqB,EAAQ,UAAU,IAAIrB,CAAS,CACvC,IAAI,MAASsB,EAAK,CAAC;AACrB"}

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

@@ -0,0 +1,79 @@
+import { scenePaintedPoseOf as e } from "../../../canvas/derivedPath.js";
+import { runBehaviorSettled as t } from "../gestureLifecycle.js";
+import { inPlane as n, insertLayer as r } from "../planeInput.js";
+import { shapeKindInfo as i } from "../../../core/shapeKinds.js";
+import { copiesWithin as a } from "../../../canvas/copiesAbove.js";
+import { insertKind as o, insertShape as s } from "./shape.js";
+import { cancelInsert as c, commitInsert as l } from "./commit.js";
+import { beginInsert as u } from "./session.js";
+import { carryStart as d, nextFrame as f } from "./frame.js";
+import { resolveParams as p } from "@weasel-js/routing";
+//#region src/interactions/actions/insert/action.ts
+var m = n({
+	id: "insert",
+	label: "Insert",
+	group: "insert",
+	eligible: { capability: "creates-shapes" },
+	requires: [
+		"insert",
+		"insertLive",
+		"insertInto",
+		"selection",
+		"snap",
+		"textEdit",
+		"scene",
+		"applyOps",
+		"view"
+	],
+	invoker: {
+		timing: "ongoing",
+		start(n, r) {
+			let m = u(n, r);
+			if (!m) return {};
+			let { session: h, readers: g } = m, _ = m.frame, v = {
+				open: !0,
+				userRotation: 0,
+				repositioning: !1
+			}, y = n.deps.insertLive;
+			y && (y.gesture = v);
+			let b = n.deps.scene, x = n.deps.insertInto?.get() ?? null, S = b ? a(b, x, e(b)) : [];
+			return {
+				kind: "insert",
+				onMove(e) {
+					v.repositioning && d(h, _.pointer, e.world), _ = f(h, g, _, e);
+				},
+				overlay() {
+					if (!v.open) return null;
+					let e = p(h.opts?.params);
+					if (!i(o(e))?.insertPreview) return null;
+					let { bounds: t, extras: n, start: r } = s(e, _, _.points, v.userRotation);
+					return {
+						kind: "insertPreview",
+						shape: n.kind,
+						bounds: t,
+						extras: n,
+						anchorPoint: {
+							x: r.x,
+							y: r.y
+						},
+						...S.length > 0 ? { copies: S } : {}
+					};
+				},
+				onEnd(e, n) {
+					v.open = !1, y?.gesture === v && (y.gesture = null);
+					let r = !1;
+					try {
+						n === "cancel" ? c(h) : r = l(h, _, e.drag?.points ?? _.points, v.userRotation);
+					} finally {
+						t(h.behaviors, h.gestureCtx, r);
+					}
+				}
+			};
+		}
+	},
+	enabled: () => !0
+}, r);
+//#endregion
+export { m as insertAction };
+
+//# sourceMappingURL=action.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"action.js","names":["insertAction","inPlane","begun","beginInsert","ctx","opts","frame","gesture","live","scene","into","copies","copiesWithin","scenePaintedPoseOf","carryStart","session","moveCtx","nextFrame","readers","resolved","resolveParams","shapeKindInfo","insertKind","insertShape","extras","start","committed","reason","cancelInsert","commitInsert","endCtx","insertLayer"],"sources":["../../../../src/interactions/actions/insert/action.ts"],"sourcesContent":["import type { Action, NodeId } from '@weasel-js/routing';\nimport type { InvocationCtx, OngoingHandle, BindingOpts, OngoingOverlay } from '@weasel-js/routing';\nimport { resolveParams } from '@weasel-js/routing';\nimport { shapeKindInfo } from 'core/shapeKinds';\nimport type { KitInsertShape } from 'core/shapeKinds';\nimport { runBehaviorSettled } from '../gestureLifecycle';\nimport { inPlane, insertLayer } from '../planeInput';\nimport { copiesWithin } from 'canvas/copiesAbove';\nimport { scenePaintedPoseOf } from 'canvas/derivedPath';\nimport { cancelInsert, commitInsert } from './commit';\nimport { carryStart, nextFrame } from './frame';\nimport type { InsertLiveGesture } from './live';\nimport { beginInsert } from './session';\nimport { insertKind, insertShape } from './shape';\n\n/**\n * @experimental\n * Drag-to-insert. The node `kind` is read from `opts.params.kind`.\n *\n * Grid snapping comes from the optional `snap` dep, applied to the drag's\n * start and current point (never to freehand pencil samples). Behaviors from\n * the binding's `opts.behaviors` (`InsertBehavior[]`) run over the two points\n * after that; on release the first answer wins (`null` aborts, `Op[]` commits\n * in place of the insert).\n *\n * The new node has no scene id until commit, so the live preview is the\n * `overlay()` surface with `kind: 'insertPreview'`. A consumer-defined kind\n * the kit cannot draw skips the preview and still commits on release.\n */\nexport const insertAction: Action & { requires: string[] } = inPlane({\n  id: 'insert',\n  label: 'Insert',\n  group: 'insert',\n  eligible: { capability: 'creates-shapes' },\n  requires: ['insert', 'insertLive', 'insertInto', 'selection', 'snap', 'textEdit', 'scene', 'applyOps', 'view'],\n  invoker: {\n    timing: 'ongoing',\n    start(ctx: InvocationCtx, opts?: BindingOpts): OngoingHandle {\n      const begun = beginInsert(ctx, opts);\n      if (!begun) return {};\n      const { session, readers } = begun;\n      let frame = begun.frame;\n      const gesture: InsertLiveGesture = { open: true, userRotation: 0, repositioning: false };\n      const live = ctx.deps.insertLive;\n      if (live) live.gesture = gesture;\n      // Where the shape will land decides the copies it will be drawn in.\n      const scene = ctx.deps.scene;\n      const into = (ctx.deps.insertInto?.get() ?? null) as NodeId | null;\n      const copies = scene ? copiesWithin(scene, into, scenePaintedPoseOf(scene)) : [];\n\n      return {\n        kind: 'insert',\n        onMove(moveCtx: InvocationCtx): void {\n          if (gesture.repositioning) carryStart(session, frame.pointer, moveCtx.world);\n          frame = nextFrame(session, readers, frame, moveCtx);\n        },\n        overlay(): OngoingOverlay | null {\n          if (!gesture.open) return null;\n          // Resolve params on every overlay() so thunked params (polygon\n          // sides ticking via ArrowUp mid-drag) reflect in the live preview.\n          const resolved = resolveParams(session.opts?.params);\n          if (!shapeKindInfo(insertKind(resolved))?.insertPreview) return null;\n          const { bounds, extras, start } = insertShape(resolved, frame, frame.points, gesture.userRotation);\n          return {\n            kind: 'insertPreview',\n            shape: extras.kind as KitInsertShape,\n            bounds,\n            extras,\n            // Anchor dot at the click point: radial shapes have no vertex\n            // there, and in center mode it marks the growth axis.\n            anchorPoint: { x: start.x, y: start.y },\n            ...(copies.length > 0 ? { copies } : {}),\n          };\n        },\n        onEnd(endCtx: InvocationCtx, reason: 'commit' | 'cancel'): void {\n          gesture.open = false;\n          if (live?.gesture === gesture) live.gesture = null;\n          let committed = false;\n          try {\n            if (reason === 'cancel') cancelInsert(session);\n            else committed = commitInsert(session, frame, endCtx.drag?.points ?? frame.points, gesture.userRotation);\n          } finally {\n            runBehaviorSettled(session.behaviors, session.gestureCtx, committed);\n          }\n        },\n      };\n    },\n  },\n  /** Insert needs no selection; anything but `true` blocks dispatcher-routed inserts. */\n  enabled: () => true as const,\n}, insertLayer);\n"],"mappings":";;;;;;;;;;;AA6BA,IAAaA,IAAgDC,EAAQ;CACnE,IAAI;CACJ,OAAO;CACP,OAAO;CACP,UAAU,EAAE,YAAY,iBAAiB;CACzC,UAAU;EAAC;EAAU;EAAc;EAAc;EAAa;EAAQ;EAAY;EAAS;EAAY;CAAM;CAC7G,SAAS;EACP,QAAQ;EACR,MAAM,GAAoB,GAAmC;GAC3D,IAAMC,IAAQC,EAAYC,GAAKC,CAAI;GACnC,IAAI,CAACH,GAAO,OAAO,CAAC;GACpB,IAAM,EAAE,YAAS,eAAYA,GACzBI,IAAQJ,EAAM,OACZK,IAA6B;IAAE,MAAM;IAAM,cAAc;IAAG,eAAe;GAAM,GACjFC,IAAOJ,EAAI,KAAK;GACtB,AAAII,MAAM,EAAK,UAAUD;GAEzB,IAAME,IAAQL,EAAI,KAAK,OACjBM,IAAQN,EAAI,KAAK,YAAY,IAAI,KAAK,MACtCO,IAASF,IAAQG,EAAaH,GAAOC,GAAMG,EAAmBJ,CAAK,CAAC,IAAI,CAAC;GAE/E,OAAO;IACL,MAAM;IACN,OAAO,GAA8B;KAEnC,AADIF,EAAQ,iBAAeO,EAAWC,GAAST,EAAM,SAASU,EAAQ,KAAK,GAC3E,IAAQC,EAAUF,GAASG,GAASZ,GAAOU,CAAO;IACpD;IACA,UAAiC;KAC/B,IAAI,CAACT,EAAQ,MAAM,OAAO;KAG1B,IAAMY,IAAWC,EAAcL,EAAQ,MAAM,MAAM;KACnD,IAAI,CAACM,EAAcC,EAAWH,CAAQ,CAAC,CAAC,EAAE,eAAe,OAAO;KAChE,IAAM,EAAE,WAAQ,WAAQ,aAAUI,EAAYJ,GAAUb,GAAOA,EAAM,QAAQC,EAAQ,YAAY;KACjG,OAAO;MACL,MAAM;MACN,OAAOiB,EAAO;MACd;MACA;MAGA,aAAa;OAAE,GAAGC,EAAM;OAAG,GAAGA,EAAM;MAAE;MACtC,GAAId,EAAO,SAAS,IAAI,EAAE,UAAO,IAAI,CAAC;KACxC;IACF;IACA,MAAM,GAAuB,GAAmC;KAE9D,AADA,EAAQ,OAAO,IACXH,GAAM,YAAYD,MAAS,EAAK,UAAU;KAC9C,IAAImB,IAAY;KAChB,IAAI;MACF,AAAIC,MAAW,WAAUC,EAAab,CAAO,IACxC,IAAYc,EAAad,GAAST,GAAOwB,EAAO,MAAM,UAAUxB,EAAM,QAAQC,EAAQ,YAAY;KACzG,UAAU;MACR,EAAmBQ,EAAQ,WAAWA,EAAQ,YAAYW,CAAS;KACrE;IACF;GACF;EACF;CACF;CAEA,eAAe;AACjB,GAAGK,CAAW"}

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

@@ -0,0 +1,28 @@
+import { commitGestureOps as e, readGestureLifecycle as t, reduceBehaviorEnd as n, runBehaviorCancel as r } from "../gestureLifecycle.js";
+import { defaultCommitAdapter as i } from "../defaultCommitAdapter.js";
+import { insertShape as a, isCommittableExtent as o } from "./shape.js";
+import { resolveParams as s } from "@weasel-js/routing";
+//#region src/interactions/actions/insert/commit.ts
+function c(e) {
+	r(e.behaviors, e.gestureCtx), e.priorSelection.length > 0 && e.selection?.set([...e.priorSelection]);
+}
+function l(r, c, l, u) {
+	let d = s(r.opts?.params);
+	if (r.behaviors.length > 0) {
+		let a = n(r.behaviors, r.gestureCtx);
+		if (a === null) return !1;
+		if (a !== void 0) return r.scene ? e({
+			scene: r.scene,
+			applyOps: r.applyOps,
+			adapter: i(r.scene, r.selection?.adapterMethods)
+		}, t(d, "Insert", r.behaviors), a) : !1;
+	}
+	let { bounds: f, extras: p } = a(d, c, l, u);
+	if (!o(f, p.kind)) return !1;
+	let m = r.dep.commit(f, p);
+	return m !== null && p.kind === "text" && r.textEdit?.startEdit(String(m), { caret: 0 }), m !== null;
+}
+//#endregion
+export { c as cancelInsert, l as commitInsert };
+
+//# sourceMappingURL=commit.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"commit.js","names":["cancelInsert","runBehaviorCancel","session","commitInsert","resolved","resolveParams","r","reduceBehaviorEnd","commitGestureOps","defaultCommitAdapter","readGestureLifecycle","insertShape","frame","points","userRotation","isCommittableExtent","bounds","extras","id"],"sources":["../../../../src/interactions/actions/insert/commit.ts"],"sourcesContent":["import type { DragSample } from '@weasel-js/routing';\nimport { resolveParams } from '@weasel-js/routing';\nimport { defaultCommitAdapter } from '../defaultCommitAdapter';\nimport { commitGestureOps, readGestureLifecycle, reduceBehaviorEnd, runBehaviorCancel } from '../gestureLifecycle';\nimport type { InsertFrame, InsertSession } from './session';\nimport { insertShape, isCommittableExtent } from './shape';\n\n/** Cancel the insert: tell the behaviors, and put the selection the draw\n *  cleared back. */\nexport function cancelInsert(\n  session: Pick<InsertSession, 'behaviors' | 'gestureCtx' | 'priorSelection' | 'selection'>,\n): void {\n  runBehaviorCancel(session.behaviors, session.gestureCtx);\n  if (session.priorSelection.length > 0) session.selection?.set([...session.priorSelection]);\n}\n\n/** Commit the insert. Returns whether it committed: a behavior's ops reached\n *  the scene, or the `insert` dep minted a node. `points` is the pointer\n *  trail as the release left it. */\nexport function commitInsert(\n  session: InsertSession,\n  frame: Pick<InsertFrame, 'shaped' | 'altHeld'>,\n  points: ReadonlyArray<DragSample> | null,\n  userRotation: number,\n): boolean {\n  // Resolve params at commit time so thunked params (polygon\n  // `sides` adjusted mid-drag, etc.) see the latest tool state.\n  const resolved = resolveParams(session.opts?.params);\n\n  if (session.behaviors.length > 0) {\n    const r = reduceBehaviorEnd(session.behaviors, session.gestureCtx);\n    if (r === null) return false;\n    if (r !== undefined) {\n      if (!session.scene) return false;\n      return commitGestureOps(\n        {\n          scene: session.scene,\n          applyOps: session.applyOps,\n          adapter: defaultCommitAdapter(session.scene, session.selection?.adapterMethods),\n        },\n        readGestureLifecycle(resolved, 'Insert', session.behaviors),\n        r,\n      );\n    }\n  }\n\n  const { bounds, extras } = insertShape(resolved, frame, points, userRotation);\n  // Sub-threshold drag — no insert.\n  if (!isCommittableExtent(bounds, extras.kind)) return false;\n\n  const id = session.dep.commit(bounds, extras);\n\n  // A freshly dragged text box is empty, so it draws nothing and the\n  // tool's own `click on selected body → enterTextEdit` binding has\n  // nothing visible to click. Drop straight into the caret instead —\n  // which is also what every other editor does with a text tool.\n  // `textEdit` is optional: without it the box is still committed,\n  // exactly as before.\n  if (id !== null && extras.kind === 'text') {\n    session.textEdit?.startEdit(String(id), { caret: 0 });\n  }\n  return id !== null;\n}\n"],"mappings":";;;;;AASA,SAAgBA,EACd,GACM;CAEN,AADAC,EAAkBC,EAAQ,WAAWA,EAAQ,UAAU,GACnDA,EAAQ,eAAe,SAAS,KAAGA,EAAQ,WAAW,IAAI,CAAC,GAAGA,EAAQ,cAAc,CAAC;AAC3F;AAKA,SAAgBC,EACd,GACA,GACA,GACA,GACS;CAGT,IAAMC,IAAWC,EAAcH,EAAQ,MAAM,MAAM;CAEnD,IAAIA,EAAQ,UAAU,SAAS,GAAG;EAChC,IAAMI,IAAIC,EAAkBL,EAAQ,WAAWA,EAAQ,UAAU;EACjE,IAAII,MAAM,MAAM,OAAO;EACvB,IAAIA,MAAM,KAAA,GAER,OADKJ,EAAQ,QACNM,EACL;GACE,OAAON,EAAQ;GACf,UAAUA,EAAQ;GAClB,SAASO,EAAqBP,EAAQ,OAAOA,EAAQ,WAAW,cAAc;EAChF,GACAQ,EAAqBN,GAAU,UAAUF,EAAQ,SAAS,GAC1DI,CACF,IAT2B;CAW/B;CAEA,IAAM,EAAE,WAAQ,cAAWK,EAAYP,GAAUQ,GAAOC,GAAQC,CAAY;CAE5E,IAAI,CAACC,EAAoBC,GAAQC,EAAO,IAAI,GAAG,OAAO;CAEtD,IAAMC,IAAKhB,EAAQ,IAAI,OAAOc,GAAQC,CAAM;CAW5C,OAHIC,MAAO,QAAQD,EAAO,SAAS,UACjCf,EAAQ,UAAU,UAAU,OAAOgB,CAAE,GAAG,EAAE,OAAO,EAAE,CAAC,GAE/CA,MAAO;AAChB"}

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

@@ -0,0 +1,65 @@
+//#region src/interactions/actions/insert/extras.ts
+function e(e, t, n, r, i, a) {
+	let o = e?.kind ?? "rect";
+	switch (o) {
+		case "rect":
+		case "ellipse": return { kind: o };
+		case "line": return {
+			kind: "line",
+			a: {
+				x: t,
+				y: n
+			},
+			b: {
+				x: r,
+				y: i
+			}
+		};
+		case "polygon": {
+			let a = Number(e?.sides ?? 6), o = r === t && i === n ? 0 : Math.atan2(i - n, r - t), s = {
+				kind: "polygon",
+				sides: a,
+				rotation: e?.rotation === void 0 ? o : Number(e.rotation)
+			};
+			if (e?.originMode === "center") {
+				let e = r - t, a = i - n;
+				s.center = {
+					x: t,
+					y: n
+				}, s.radius = Math.hypot(e, a);
+			} else e?.center !== void 0 && (s.center = e.center), e?.radius !== void 0 && (s.radius = e.radius);
+			return s;
+		}
+		case "star": {
+			let a = Number(e?.points ?? 5), o = Number(e?.innerRadiusRatio ?? .5), s = r === t && i === n ? 0 : Math.atan2(i - n, r - t), c = {
+				kind: "star",
+				points: a,
+				innerRadiusRatio: o,
+				rotation: e?.rotation === void 0 ? s : Number(e.rotation)
+			};
+			if (e?.originMode === "center") {
+				let e = r - t, a = i - n;
+				c.center = {
+					x: t,
+					y: n
+				}, c.outerRadius = Math.hypot(e, a);
+			} else e?.center !== void 0 && (c.center = e.center), e?.outerRadius !== void 0 && (c.outerRadius = e.outerRadius);
+			return c;
+		}
+		case "pencil": return {
+			kind: "pencil",
+			samples: e?.samples ?? a ?? []
+		};
+		default: return {
+			...e ?? {},
+			kind: o
+		};
+	}
+}
+function t(e, t) {
+	t !== 0 && (e.kind === "star" || e.kind === "polygon") && (e.rotation += t);
+}
+//#endregion
+export { t as applyUserRotation, e as buildExtras };
+
+//# sourceMappingURL=extras.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"extras.js","names":["buildExtras","kind","params","\"kind\"","startX","startY","currentX","currentY","sides","\"sides\"","dragAngle","extras","\"rotation\"","\"originMode\"","dx","dy","\"center\"","\"radius\"","pts","\"points\"","ir","\"innerRadiusRatio\"","\"outerRadius\"","\"samples\"","points","applyUserRotation","userRotation"],"sources":["../../../../src/interactions/actions/insert/extras.ts"],"sourcesContent":["import type { DragSample } from '@weasel-js/routing';\nimport type { InsertExtras } from '../depSchema';\n\n/** Build a typed `InsertExtras` from the static params + gesture context.\n *  Kit-built-in kinds (line / polygon / star / pencil) read kind-specific\n *  fields; unknown kinds pass the raw params through as `{ kind, ... }`. */\nexport function buildExtras(\n  params: Record<string, unknown> | undefined,\n  startX: number,\n  startY: number,\n  currentX: number,\n  currentY: number,\n  points: ReadonlyArray<DragSample> | null,\n): InsertExtras {\n  const kind = ((params?.['kind'] as string | undefined) ?? 'rect');\n  switch (kind) {\n    case 'rect':\n    case 'ellipse':\n      return { kind } as InsertExtras;\n    case 'line':\n      // Use the live drag endpoints (not AABB) so the line preserves the\n      // user's drag direction — drag from bottom-left to top-right makes a\n      // line that slopes up, not the bounds diagonal.\n      return { kind: 'line', a: { x: startX, y: startY }, b: { x: currentX, y: currentY } };\n    case 'polygon': {\n      const sides = Number(params?.['sides'] ?? 6);\n      // When the tool omits rotation, point the first vertex along the\n      // drag vector so dragging in a direction orients the shape that\n      // way. Sub-pixel drags (no direction yet) fall back to 0.\n      const dragAngle = (currentX === startX && currentY === startY)\n        ? 0\n        : Math.atan2(currentY - startY, currentX - startX);\n      const rotation = params?.['rotation'] !== undefined\n        ? Number(params['rotation'])\n        : dragAngle;\n      const extras: InsertExtras = { kind: 'polygon', sides, rotation };\n      // Drag-from-center: tool's Alt binding passes `originMode:'center'`.\n      // Compute polygon center + radius from the drag vector so the shape\n      // anchors on the click point. Without this, the dep falls back to\n      // inscribing in the AABB (drag-from-corner default).\n      if (params?.['originMode'] === 'center') {\n        const dx = currentX - startX;\n        const dy = currentY - startY;\n        (extras as { center?: unknown }).center = { x: startX, y: startY };\n        (extras as { radius?: unknown }).radius = Math.hypot(dx, dy);\n      } else {\n        if (params?.['center'] !== undefined) (extras as { center?: unknown }).center = params['center'];\n        if (params?.['radius'] !== undefined) (extras as { radius?: unknown }).radius = params['radius'];\n      }\n      return extras;\n    }\n    case 'star': {\n      const pts = Number(params?.['points'] ?? 5);\n      const ir = Number(params?.['innerRadiusRatio'] ?? 0.5);\n      const dragAngle = (currentX === startX && currentY === startY)\n        ? 0\n        : Math.atan2(currentY - startY, currentX - startX);\n      const rotation = params?.['rotation'] !== undefined\n        ? Number(params['rotation'])\n        : dragAngle;\n      const extras: InsertExtras = { kind: 'star', points: pts, innerRadiusRatio: ir, rotation };\n      if (params?.['originMode'] === 'center') {\n        const dx = currentX - startX;\n        const dy = currentY - startY;\n        (extras as { center?: unknown }).center = { x: startX, y: startY };\n        (extras as { outerRadius?: unknown }).outerRadius = Math.hypot(dx, dy);\n      } else {\n        if (params?.['center'] !== undefined) (extras as { center?: unknown }).center = params['center'];\n        if (params?.['outerRadius'] !== undefined) (extras as { outerRadius?: unknown }).outerRadius = params['outerRadius'];\n      }\n      return extras;\n    }\n    case 'pencil':\n      // Prefer tool-supplied samples (param) when present — pencil tools may\n      // capture richer per-sample data (pressure/tilt). Fall back to the\n      // dispatcher's accumulated pointer trail.\n      return {\n        kind: 'pencil',\n        samples: (params?.['samples'] as ReadonlyArray<DragSample> | undefined)\n          ?? points\n          ?? [],\n      };\n    default:\n      // Consumer-defined kind: pass everything through so a custom insert\n      // dep can read its own fields.\n      return { ...(params ?? {}), kind } as InsertExtras;\n  }\n}\n\n/** Add a user-driven rotation offset onto kinds that carry rotation. Rect\n *  / ellipse / line / pencil don't expose a rotation field on their\n *  extras today, so they ignore the offset. */\nexport function applyUserRotation(extras: InsertExtras, userRotation: number): void {\n  if (userRotation === 0) return;\n  if (extras.kind === 'star' || extras.kind === 'polygon') {\n    (extras as { rotation: number }).rotation += userRotation;\n  }\n}\n"],"mappings":";AAMA,SAAgBA,EACd,GACA,GACA,GACA,GACA,GACA,GACc;CACd,IAAMC,IAASC,GAASC,QAAkC;CAC1D,QAAQF,GAAR;EACE,KAAK;EACL,KAAK,WACH,OAAO,EAAE,QAAK;EAChB,KAAK,QAIH,OAAO;GAAE,MAAM;GAAQ,GAAG;IAAE,GAAGG;IAAQ,GAAGC;GAAO;GAAG,GAAG;IAAE,GAAGC;IAAU,GAAGC;GAAS;EAAE;EACtF,KAAK,WAAW;GACd,IAAMC,IAAQ,OAAON,GAASO,SAAY,CAAC,GAIrCC,IAAaJ,MAAaF,KAAUG,MAAaF,IACnD,IACA,KAAK,MAAME,IAAWF,GAAQC,IAAWF,CAAM,GAI7CO,IAAuB;IAAE,MAAM;IAAW;IAAO,UAHtCT,GAASU,aAAgB,KAAA,IAEtCF,IADA,OAAOR,EAAOU,QAAW;GAEmC;GAKhE,IAAIV,GAASW,eAAkB,UAAU;IACvC,IAAMC,IAAKR,IAAWF,GAChBW,IAAKR,IAAWF;IAEtB,AADA,EAAiC,SAAS;KAAE,GAAGD;KAAQ,GAAGC;IAAO,GACjE,EAAiC,SAAS,KAAK,MAAMS,GAAIC,CAAE;GAC7D,OAEE,AADIb,GAASc,WAAc,KAAA,MAAW,EAAiC,SAASd,EAAOc,SACnFd,GAASe,WAAc,KAAA,MAAW,EAAiC,SAASf,EAAOe;GAEzF,OAAON;EACT;EACA,KAAK,QAAQ;GACX,IAAMO,IAAM,OAAOhB,GAASiB,UAAa,CAAC,GACpCC,IAAK,OAAOlB,GAASmB,oBAAuB,EAAG,GAC/CX,IAAaJ,MAAaF,KAAUG,MAAaF,IACnD,IACA,KAAK,MAAME,IAAWF,GAAQC,IAAWF,CAAM,GAI7CO,IAAuB;IAAE,MAAM;IAAQ,QAAQO;IAAK,kBAAkBE;IAAI,UAH/DlB,GAASU,aAAgB,KAAA,IAEtCF,IADA,OAAOR,EAAOU,QAAW;GAE4D;GACzF,IAAIV,GAASW,eAAkB,UAAU;IACvC,IAAMC,IAAKR,IAAWF,GAChBW,IAAKR,IAAWF;IAEtB,AADA,EAAiC,SAAS;KAAE,GAAGD;KAAQ,GAAGC;IAAO,GACjE,EAAsC,cAAc,KAAK,MAAMS,GAAIC,CAAE;GACvE,OAEE,AADIb,GAASc,WAAc,KAAA,MAAW,EAAiC,SAASd,EAAOc,SACnFd,GAASoB,gBAAmB,KAAA,MAAW,EAAsC,cAAcpB,EAAOoB;GAExG,OAAOX;EACT;EACA,KAAK,UAIH,OAAO;GACL,MAAM;GACN,SAAUT,GAASqB,WACdC,KACA,CAAC;EACR;EACF,SAGE,OAAO;GAAE,GAAItB,KAAU,CAAC;GAAI;EAAK;CACrC;AACF;AAKA,SAAgBuB,EAAkB,GAAsB,GAA4B;CAClF,AAAIC,MAAiB,MACjBf,EAAO,SAAS,UAAUA,EAAO,SAAS,eAC5C,EAAiC,YAAYe;AAEjD"}

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

@@ -0,0 +1,55 @@
+import { pointerStateOf as e } from "../pointerState.js";
+import { computeBounds as t, effectiveOriginMode as n, snapTo15Degrees as r } from "./geometry.js";
+import { GESTURE_KEY as i } from "./session.js";
+import { resolveParams as a } from "@weasel-js/routing";
+//#region src/interactions/actions/insert/frame.ts
+function o(o, s, c, l) {
+	let u = a(o.opts?.params), d = u?.kind ?? "rect", f = o.gestureCtx, p = f.origin.get(i), m = {
+		x: c.pointer.x,
+		y: c.pointer.y
+	};
+	if (d === "line" && c.shiftHeld && (m = r(p, m)), m = o.snap(m), o.behaviors.length > 0) {
+		f.modifiers = { ...l.modifiers }, f.pointer = e(c.pointer, l), f.view = s.view(), f.plane = s.plane(), f.current.set(i, m);
+		let r = n(u?.originMode, c.altHeld);
+		for (let e of o.behaviors) {
+			let n = t(p.x, p.y, m.x, m.y, r), i = e.onMove?.(f, {
+				start: p,
+				current: m,
+				bounds: n,
+				pose: n
+			});
+			i && (i.start && (p = i.start), i.current && (m = i.current));
+		}
+		f.current.set(i, m);
+	}
+	return {
+		start: p,
+		current: m
+	};
+}
+function s(e, t, n) {
+	let r = e.snap(t), a = e.snap(n), o = e.gestureCtx.origin, s = o.get(i);
+	o.set(i, {
+		x: s.x + a.x - r.x,
+		y: s.y + a.y - r.y
+	});
+}
+function c(e, t, n, r) {
+	let i = {
+		pointer: {
+			x: r.world.x,
+			y: r.world.y
+		},
+		altHeld: r.modifiers.alt,
+		shiftHeld: r.modifiers.shift
+	};
+	return {
+		...i,
+		points: r.drag?.points ? r.drag.points : n.points,
+		shaped: o(e, t, i, r)
+	};
+}
+//#endregion
+export { s as carryStart, c as nextFrame };
+
+//# sourceMappingURL=frame.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"frame.js","names":["shapeEndpoints","resolved","resolveParams","session","kind","\"kind\"","gctx","start","GESTURE_KEY","current","raw","snapTo15Degrees","moveCtx","pointerStateOf","readers","mode","effectiveOriginMode","\"originMode\"","b","bounds","computeBounds","r","carryStart","a","from","to","origin","nextFrame","prev"],"sources":["../../../../src/interactions/actions/insert/frame.ts"],"sourcesContent":["import type { InvocationCtx } from '@weasel-js/routing';\nimport { pointerStateOf } from '../pointerState';\nimport { resolveParams } from '@weasel-js/routing';\nimport type { GestureReaders } from '../../gestures/shared/screenTolerance';\nimport type { InsertPoint } from '../../gestures/types';\nimport { computeBounds, effectiveOriginMode, snapTo15Degrees } from './geometry';\nimport { GESTURE_KEY, type InsertFrame, type InsertSession } from './session';\n\n/**\n * Shape the raw pointer into the drag's endpoints, in order: the line tool's\n * Shift-constrain (on the raw pointer, around the shaped start, so the locked\n * angle survives), the `snap` dep, then each behavior's `onMove`, each seeing\n * the points the one before it returned.\n */\nfunction shapeEndpoints(\n  session: Pick<InsertSession, 'opts' | 'snap' | 'behaviors' | 'gestureCtx'>,\n  readers: GestureReaders,\n  raw: Pick<InsertFrame, 'pointer' | 'altHeld' | 'shiftHeld'>,\n  moveCtx: Pick<InvocationCtx, 'modifiers' | 'screen'>,\n): { start: InsertPoint; current: InsertPoint } {\n  const resolved = resolveParams(session.opts?.params);\n  const kind = (resolved?.['kind'] as string | undefined) ?? 'rect';\n  const gctx = session.gestureCtx;\n  let start = gctx.origin.get(GESTURE_KEY) as InsertPoint;\n  let current = { x: raw.pointer.x, y: raw.pointer.y };\n  if (kind === 'line' && raw.shiftHeld) {\n    current = snapTo15Degrees(start, current);\n  }\n  current = session.snap(current);\n\n  if (session.behaviors.length > 0) {\n    gctx.modifiers = { ...moveCtx.modifiers };\n    gctx.pointer = pointerStateOf(raw.pointer, moveCtx);\n    gctx.view = readers.view();\n    gctx.plane = readers.plane();\n    gctx.current.set(GESTURE_KEY, current);\n    const mode = effectiveOriginMode(resolved?.['originMode'], raw.altHeld);\n    for (const b of session.behaviors) {\n      const bounds = computeBounds(start.x, start.y, current.x, current.y, mode);\n      const r = b.onMove?.(gctx, { start, current, bounds, pose: bounds });\n      if (!r) continue;\n      if (r.start) start = r.start;\n      if (r.current) current = r.current;\n    }\n    gctx.current.set(GESTURE_KEY, current);\n  }\n  return { start, current };\n}\n\n/** Move the drag's start point by the pointer's step from `from` to `to`, so\n *  the shape travels with the pointer instead of resizing. The step is taken\n *  between snapped points, keeping a grid-snapped start on the grid. */\nexport function carryStart(\n  session: Pick<InsertSession, 'snap' | 'gestureCtx'>,\n  from: InsertPoint,\n  to: InsertPoint,\n): void {\n  const a = session.snap(from);\n  const b = session.snap(to);\n  const origin = session.gestureCtx.origin;\n  const start = origin.get(GESTURE_KEY) as InsertPoint;\n  origin.set(GESTURE_KEY, { x: start.x + b.x - a.x, y: start.y + b.y - a.y });\n}\n\n/** One pump event's pointer, modifiers, and trail, and the endpoints they\n *  shape to. Each behavior's `onMove` runs once per call. */\nexport function nextFrame(\n  session: InsertSession,\n  readers: GestureReaders,\n  prev: Pick<InsertFrame, 'points'>,\n  moveCtx: InvocationCtx,\n): InsertFrame {\n  const raw = {\n    pointer: { x: moveCtx.world.x, y: moveCtx.world.y },\n    // Each pointermove carries fresh modifier state from the dispatcher;\n    // releasing / pressing a key mid-drag takes effect on the next move tick\n    // (true modifier-only events don't fire without a cursor change).\n    altHeld: moveCtx.modifiers.alt,\n    shiftHeld: moveCtx.modifiers.shift,\n  };\n  return {\n    ...raw,\n    // The dispatcher mutates its own per-gesture trail in place but\n    // attaches the array reference to each InvocationCtx.drag — keep\n    // the latest reference in case the dispatcher swaps it.\n    points: moveCtx.drag?.points ? moveCtx.drag.points : prev.points,\n    shaped: shapeEndpoints(session, readers, raw, moveCtx),\n  };\n}\n"],"mappings":";;;;;AAcA,SAASA,EACP,GACA,GACA,GACA,GAC8C;CAC9C,IAAMC,IAAWC,EAAcC,EAAQ,MAAM,MAAM,GAC7CC,IAAQH,GAAWI,QAAkC,QACrDC,IAAOH,EAAQ,YACjBI,IAAQD,EAAK,OAAO,IAAIE,CAAW,GACnCC,IAAU;EAAE,GAAGC,EAAI,QAAQ;EAAG,GAAGA,EAAI,QAAQ;CAAE;CAMnD,IALIN,MAAS,UAAUM,EAAI,cACzB,IAAUC,EAAgBJ,GAAOE,CAAO,IAE1C,IAAUN,EAAQ,KAAKM,CAAO,GAE1BN,EAAQ,UAAU,SAAS,GAAG;EAKhC,AAJA,EAAK,YAAY,EAAE,GAAGS,EAAQ,UAAU,GACxC,EAAK,UAAUC,EAAeH,EAAI,SAASE,CAAO,GAClD,EAAK,OAAOE,EAAQ,KAAK,GACzB,EAAK,QAAQA,EAAQ,MAAM,GAC3BR,EAAK,QAAQ,IAAIE,GAAaC,CAAO;EACrC,IAAMM,IAAOC,EAAoBf,GAAWgB,YAAeP,EAAI,OAAO;EACtE,KAAK,IAAMQ,KAAKf,EAAQ,WAAW;GACjC,IAAMgB,IAASC,EAAcb,EAAM,GAAGA,EAAM,GAAGE,EAAQ,GAAGA,EAAQ,GAAGM,CAAI,GACnEM,IAAIH,EAAE,SAASZ,GAAM;IAAE;IAAO;IAAS;IAAQ,MAAMa;GAAO,CAAC;GACnE,AAAKE,MACDA,EAAE,UAAO,IAAQA,EAAE,QACnBA,EAAE,YAAS,IAAUA,EAAE;EAC7B;EACA,EAAK,QAAQ,IAAIb,GAAaC,CAAO;CACvC;CACA,OAAO;EAAE;EAAO;CAAQ;AAC1B;AAKA,SAAgBa,EACd,GACA,GACA,GACM;CACN,IAAMC,IAAIpB,EAAQ,KAAKqB,CAAI,GACrBN,IAAIf,EAAQ,KAAKsB,CAAE,GACnBC,IAASvB,EAAQ,WAAW,QAC5BI,IAAQmB,EAAO,IAAIlB,CAAW;CACpC,EAAO,IAAIA,GAAa;EAAE,GAAGD,EAAM,IAAIW,EAAE,IAAIK,EAAE;EAAG,GAAGhB,EAAM,IAAIW,EAAE,IAAIK,EAAE;CAAE,CAAC;AAC5E;AAIA,SAAgBI,EACd,GACA,GACA,GACA,GACa;CACb,IAAMjB,IAAM;EACV,SAAS;GAAE,GAAGE,EAAQ,MAAM;GAAG,GAAGA,EAAQ,MAAM;EAAE;EAIlD,SAASA,EAAQ,UAAU;EAC3B,WAAWA,EAAQ,UAAU;CAC/B;CACA,OAAO;EACL,GAAGF;EAIH,QAAQE,EAAQ,MAAM,SAASA,EAAQ,KAAK,SAASgB,EAAK;EAC1D,QAAQ5B,EAAeG,GAASW,GAASJ,GAAKE,CAAO;CACvD;AACF"}

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/repositionAction.js

@@ -0,0 +1,31 @@
+import { heldKeySpec as e } from "@weasel-js/routing";
+//#region src/interactions/actions/insert/repositionAction.ts
+var t = {
+	id: "insert.reposition",
+	label: "Insert — reposition",
+	group: "insert",
+	eligible: { capability: "creates-shapes" },
+	invoker: {
+		timing: "ongoing",
+		start: (e) => {
+			let t = e.deps.insertLive?.gesture;
+			return !t || !t.open ? {} : (t.repositioning = !0, {
+				kind: "insert.reposition",
+				onEnd: () => {
+					t.repositioning = !1;
+				}
+			});
+		}
+	},
+	requires: ["insertLive"]
+}, n = {
+	spec: {
+		...e(" "),
+		phase: "engaged"
+	},
+	actionId: "insert.reposition"
+};
+//#endregion
+export { n as INSERT_REPOSITION_BINDING, t as insertRepositionAction };
+
+//# sourceMappingURL=repositionAction.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"repositionAction.js","names":["insertRepositionAction","gesture","ctx","INSERT_REPOSITION_BINDING","heldKeySpec"],"sources":["../../../../src/interactions/actions/insert/repositionAction.ts"],"sourcesContent":["import { heldKeySpec, type Action, type GestureBinding } from '@weasel-js/routing';\nimport type { InsertLiveGesture } from './live';\n\n/**\n * @experimental\n * Companion to `insertAction`: while its key is held, dragging moves the\n * shape being drawn instead of resizing it; letting go resumes resizing from\n * where the shape now sits. No-op when no insert is in flight.\n */\nexport const insertRepositionAction: Action = {\n  id: 'insert.reposition',\n  label: 'Insert — reposition',\n  group: 'insert',\n  eligible: { capability: 'creates-shapes' },\n  invoker: {\n    timing: 'ongoing',\n    start: (ctx) => {\n      const gesture = ctx.deps.insertLive?.gesture as InsertLiveGesture | null | undefined;\n      if (!gesture || !gesture.open) return {};\n      gesture.repositioning = true;\n      return {\n        kind: 'insert.reposition',\n        onEnd: () => { gesture.repositioning = false; },\n      };\n    },\n  },\n  requires: ['insertLive'],\n};\n\n/**\n * The binding a shape-drawing tool adds so holding Space mid-draw repositions\n * the shape. Gated to the tool's own engaged phase, so Space between drags is\n * left to the offhand hand tool. Shift and Alt may be down with it, so a\n * constrained or from-center draw can be moved without letting go of them.\n */\nexport const INSERT_REPOSITION_BINDING: GestureBinding = {\n  spec: { ...heldKeySpec(' '), phase: 'engaged' },\n  actionId: 'insert.reposition',\n};\n"],"mappings":";;AASA,IAAaA,IAAiC;CAC5C,IAAI;CACJ,OAAO;CACP,OAAO;CACP,UAAU,EAAE,YAAY,iBAAiB;CACzC,SAAS;EACP,QAAQ;EACR,QAAQ,MAAQ;GACd,IAAMC,IAAUC,EAAI,KAAK,YAAY;GAGrC,OAFI,CAACD,KAAW,CAACA,EAAQ,OAAa,CAAC,KACvC,EAAQ,gBAAgB,IACjB;IACL,MAAM;IACN,aAAa;KAAE,EAAQ,gBAAgB;IAAO;GAChD;EACF;CACF;CACA,UAAU,CAAC,YAAY;AACzB,GAQaE,IAA4C;CACvD,MAAM;EAAE,GAAGC,EAAY,GAAG;EAAG,OAAO;CAAU;CAC9C,UAAU;AACZ"}

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