@weasel-js/core 1.9.3 → 1.10.0

package/dist/canvas/viewRegistry.js

@@ -1,53 +1,51 @@
 import { createViewResolver as e } from "../features/viewports/viewResolver.js";
 import { createContext as t, useContext as n, useMemo as r, useRef as i } from "react";
-import { jsx as a } from "react/jsx-runtime";
+import { createEmitter as a } from "@weasel-js/registry";
+import { jsx as o } from "react/jsx-runtime";
 //#region src/canvas/viewRegistry.tsx
-var o = t(null);
-function s({ children: t }) {
-	let n = i(/* @__PURE__ */ new Map()), s = i(0), c = i(0), d = i(/* @__PURE__ */ new Set()), f = i(null), p = r(() => {
-		let t = () => {
-			c.current++;
-			for (let e of d.current) e();
-		}, r = () => [...n.current.keys()].sort((e, t) => e.order - t.order || n.current.get(e) - n.current.get(t));
+var s = t(null);
+function c({ children: t }) {
+	let n = i(/* @__PURE__ */ new Map()), c = i(0), l = i(0), f = i(null), p = r(() => {
+		let t = a(), r = () => {
+			l.current++, t.emit();
+		}, i = () => [...n.current.keys()].sort((e, t) => e.order - t.order || n.current.get(e) - n.current.get(t));
 		return {
 			resolver: e({
 				views: () => {
-					let e = f.current, t = e?.view() ?? u, n = e?.dims() ?? l;
-					return r().filter((e) => e.interactive).map((e) => e.layer.resolvable(t, n));
+					let e = f.current, t = e?.view() ?? d, n = e?.dims() ?? u;
+					return i().filter((e) => e.interactive).map((e) => e.layer.resolvable(t, n));
 				},
-				root: () => f.current?.view() ?? u,
+				root: () => f.current?.view() ?? d,
 				canvasOrigin: () => f.current?.origin() ?? {
 					left: 0,
 					top: 0
 				},
 				occluded: (e, t) => f.current?.claimsAbove(e, t) ?? !1
 			}),
-			register: (e) => (n.current.set(e, s.current++), t(), () => {
-				n.current.delete(e), t();
-			}),
-			list: r,
-			getVersion: () => c.current,
-			subscribe: (e) => (d.current.add(e), () => {
-				d.current.delete(e);
+			register: (e) => (n.current.set(e, c.current++), r(), () => {
+				n.current.delete(e), r();
 			}),
+			list: i,
+			getVersion: () => l.current,
+			subscribe: t.subscribe,
 			surface: () => f.current,
-			attachSurface: (e) => {
-				f.current = e;
-			}
+			attachSurface: (e) => (f.current = e, () => {
+				f.current === e && (f.current = null);
+			})
 		};
 	}, []);
-	return /* @__PURE__ */ a(o.Provider, {
+	return /* @__PURE__ */ o(s.Provider, {
 		value: p,
 		children: t
 	});
 }
-function c() {
-	return n(o);
+function l() {
+	return n(s);
 }
-var l = {
+var u = {
 	width: 0,
 	height: 0
-}, u = {
+}, d = {
 	x: 0,
 	y: 0,
 	scale: {
@@ -56,6 +54,6 @@ var l = {
 	}
 };
 //#endregion
-export { u as IDENTITY_VIEW, l as UNMEASURED_DIMS, s as ViewRegistryProvider, c as useOptionalViewRegistry };
+export { d as IDENTITY_VIEW, u as UNMEASURED_DIMS, c as ViewRegistryProvider, l as useOptionalViewRegistry };
 
 //# sourceMappingURL=viewRegistry.js.map

package/dist/canvas/viewRegistry.js.map

@@ -1 +1 @@
-{"version":3,"file":"viewRegistry.js","names":["ViewRegistryContext","createContext","ViewRegistryProvider","entriesRef","useRef","seqRef","versionRef","listenersRef","surfaceRef","registry","useMemo","changed","fn","ordered","a","b","createViewResolver","surface","view","IDENTITY_VIEW","dims","UNMEASURED_DIMS","r","x","y","reg","handle","useOptionalViewRegistry","useContext"],"sources":["../../src/canvas/viewRegistry.tsx"],"sourcesContent":["/**\n * The seam between a canvas surface and the views drawn on it.\n *\n * Traffic runs both ways: the surface attaches a handle onto its frame and its\n * layer stack, and each view registers what it contributes back — the viewport\n * node it paints into and the record the gesture dispatcher routes its events\n * to. Both sides are thunks, read at draw and dispatch time, so neither can\n * serve the other a frame that has already moved.\n */\nimport { createContext, useContext, useMemo, useRef, type ReactNode } from 'react';\nimport type { Dims, RenderLayer } from 'core/layers/render';\nimport type { LayerHit } from 'affordances/types';\nimport type { ChromeState } from 'core/selection/chromeState';\nimport type { View } from 'core/viewport/view';\nimport type { ViewportLayer } from 'features/viewports/viewportLayer';\nimport type { DispatcherViewTarget } from '@weasel-js/routing/internal';\nimport { createViewResolver, type ViewResolver } from 'features/viewports/viewResolver';\n\n/**\n * What a view needs from the surface hosting it.\n *\n * @internal Attached by the surface, read by `<CanvasView>`.\n */\nexport interface SurfaceHandle {\n  /** Client-space origin of the canvas element. */\n  origin(): { left: number; top: number };\n  /** The outer camera. */\n  view(): View;\n  /** The canvas's CSS-pixel size. */\n  dims(): Dims;\n  /** The stack a view paints through its own camera, unless it narrows it. */\n  layers(): readonly RenderLayer<unknown>[];\n  requestRedraw(): void;\n  /** The canvas's own view chrome — its selection, its overlay-aware bounds.\n   *  What a `<CanvasView>` answers for itself, answered for view zero. */\n  chromeState(): ChromeState;\n  /** Hit-test the externally registered layers at a world point, against the\n   *  frame and draw envelope of whichever view is asking. The public\n   *  `hitTestExtras` is this with the canvas's own frame and envelope. */\n  hitTestExtras(\n    worldX: number,\n    worldY: number,\n    view: View,\n    dims: Dims,\n    data: unknown,\n    /** Consider only these layers — the ones the asking view paints. A layer\n     *  asked on a frame it was not drawn in answers for the wrong pixels. */\n    only?: readonly RenderLayer<unknown>[],\n  ): { layerId: string; hit: LayerHit } | null;\n  /** Whether a registered layer claims a canvas-local point on the surface's\n   *  own frame. Registered layers paint over every view, so such a point is\n   *  theirs even inside a view's rect. */\n  claimsAbove(x: number, y: number): boolean;\n}\n\n/**\n * What one view contributes to the surface hosting it.\n *\n * @internal Written by `<CanvasView>`, read by the surface. Consumers declare\n *   a view, not a registration.\n */\nexport interface ViewRegistration {\n  id: string;\n  /**\n   * Paint and hit order, low to high. Views declared as props take their array\n   * index; a view mounted as a child takes `Infinity`, so it lands after them\n   * however React happens to order the mount effects.\n   */\n  order: number;\n  /** The viewport node this view paints into. Its `resolvable` is what routes\n   *  input here. */\n  layer: ViewportLayer<unknown>;\n  /** `false` keeps input over the view on the canvas beneath it. */\n  interactive: boolean;\n  /** `false` leaves `layer` for a host to draw — a HUD window's interior — so\n   *  the surface does not paint it too. */\n  paint: boolean;\n  /** Everything about dispatching to this view except its id. */\n  target: Omit<DispatcherViewTarget, 'id'>;\n  /** Whether a scene layer reaches the screen in this view. For input that\n   *  reaches a view without a dispatch — hover — so it judges this view's\n   *  paint rather than the surface's. */\n  layerIsPainted(layerId: string): boolean;\n}\n\n/** @internal */\nexport interface ViewRegistry {\n  /** Returns an unregister. */\n  register(reg: ViewRegistration): () => void;\n  /** Live registrations in paint order. */\n  list(): readonly ViewRegistration[];\n  /** Bumped whenever the list changes. Pair with {@link ViewRegistry.subscribe}\n   *  for `useSyncExternalStore`. */\n  getVersion(): number;\n  subscribe(fn: () => void): () => void;\n  /** Which view a client point belongs to, sticky for a captured pointer.\n   *  One per surface: every caller that routes input — the dispatcher, pinch,\n   *  hover — must agree about where a point landed. */\n  readonly resolver: ViewResolver;\n  /** The hosting surface, or `null` before one attaches. */\n  surface(): SurfaceHandle | null;\n  attachSurface(handle: SurfaceHandle): void;\n}\n\nconst ViewRegistryContext = createContext<ViewRegistry | null>(null);\n\n/** Mounts the registry for one surface. `<SceneCanvas>` mounts one; a view\n *  declaring itself as a child must be inside it. */\nexport function ViewRegistryProvider({ children }: { children: ReactNode }) {\n  const entriesRef = useRef(new Map<ViewRegistration, number>());\n  const seqRef = useRef(0);\n  const versionRef = useRef(0);\n  const listenersRef = useRef(new Set<() => void>());\n  const surfaceRef = useRef<SurfaceHandle | null>(null);\n\n  const registry = useMemo<ViewRegistry>(() => {\n    const changed = (): void => {\n      versionRef.current++;\n      for (const fn of listenersRef.current) fn();\n    };\n    const ordered = (): ViewRegistration[] => [...entriesRef.current.keys()].sort((a, b) => (\n      a.order - b.order || entriesRef.current.get(a)! - entriesRef.current.get(b)!\n    ));\n    const resolver = createViewResolver({\n      views: () => {\n        const surface = surfaceRef.current;\n        const view = surface?.view() ?? IDENTITY_VIEW;\n        const dims = surface?.dims() ?? UNMEASURED_DIMS;\n        return ordered().filter((r) => r.interactive).map((r) => r.layer.resolvable(view, dims));\n      },\n      root: () => surfaceRef.current?.view() ?? IDENTITY_VIEW,\n      canvasOrigin: () => surfaceRef.current?.origin() ?? { left: 0, top: 0 },\n      occluded: (x, y) => surfaceRef.current?.claimsAbove(x, y) ?? false,\n    });\n    return {\n      resolver,\n      register: (reg) => {\n        entriesRef.current.set(reg, seqRef.current++);\n        changed();\n        return () => { entriesRef.current.delete(reg); changed(); };\n      },\n      list: ordered,\n      getVersion: () => versionRef.current,\n      subscribe: (fn) => {\n        listenersRef.current.add(fn);\n        return () => { listenersRef.current.delete(fn); };\n      },\n      surface: () => surfaceRef.current,\n      attachSurface: (handle) => { surfaceRef.current = handle; },\n    };\n  }, []);\n\n  return <ViewRegistryContext.Provider value={registry}>{children}</ViewRegistryContext.Provider>;\n}\n\n/** The surface's view registry, or `null` outside one. */\nexport function useOptionalViewRegistry(): ViewRegistry | null {\n  return useContext(ViewRegistryContext);\n}\n\n/** The `Dims` a surface reports before it has measured itself. */\nexport const UNMEASURED_DIMS: Dims = { width: 0, height: 0 };\n\n/** The camera a view resolves against before its surface attaches. */\nexport const IDENTITY_VIEW: View = { x: 0, y: 0, scale: { x: 1, y: 1 } };\n"],"mappings":";;;;AAwGA,IAAMA,IAAsBC,EAAmC,IAAI;AAInE,SAAgBC,EAAqB,EAAE,eAAqC;CAC1E,IAAMC,IAAaC,kBAAO,IAAI,IAA8B,CAAC,GACvDC,IAASD,EAAO,CAAC,GACjBE,IAAaF,EAAO,CAAC,GACrBG,IAAeH,kBAAO,IAAI,IAAgB,CAAC,GAC3CI,IAAaJ,EAA6B,IAAI,GAE9CK,IAAWC,QAA4B;EAC3C,IAAMC,UAAsB;GAC1B,EAAW;GACX,KAAK,IAAMC,KAAML,EAAa,SAAS,EAAG;EAC5C,GACMM,UAAoC,CAAC,GAAGV,EAAW,QAAQ,KAAK,CAAC,CAAC,CAAC,MAAM,GAAG,MAChFW,EAAE,QAAQC,EAAE,SAASZ,EAAW,QAAQ,IAAIW,CAAC,IAAKX,EAAW,QAAQ,IAAIY,CAAC,CAC3E;EAYD,OAAO;GACL,UAZeC,EAAmB;IAClC,aAAa;KACX,IAAMC,IAAUT,EAAW,SACrBU,IAAOD,GAAS,KAAK,KAAKE,GAC1BC,IAAOH,GAAS,KAAK,KAAKI;KAChC,OAAOR,EAAQ,CAAC,CAAC,QAAQ,MAAMS,EAAE,WAAW,CAAC,CAAC,KAAK,MAAMA,EAAE,MAAM,WAAWJ,GAAME,CAAI,CAAC;IACzF;IACA,YAAYZ,EAAW,SAAS,KAAK,KAAKW;IAC1C,oBAAoBX,EAAW,SAAS,OAAO,KAAK;KAAE,MAAM;KAAG,KAAK;IAAE;IACtE,WAAW,GAAG,MAAMA,EAAW,SAAS,YAAYe,GAAGC,CAAC,KAAK;GAC/D,CAEE;GACA,WAAW,OACTrB,EAAW,QAAQ,IAAIsB,GAAK,EAAO,SAAS,GAC5Cd,EAAQ,SACK;IAAkC,AAAhCR,EAAW,QAAQ,OAAOsB,CAAG,GAAGd,EAAQ;GAAG;GAE5D,MAAME;GACN,kBAAkBP,EAAW;GAC7B,YAAY,OACVC,EAAa,QAAQ,IAAIK,CAAE,SACd;IAAE,EAAa,QAAQ,OAAOA,CAAE;GAAG;GAElD,eAAeJ,EAAW;GAC1B,gBAAgB,MAAW;IAAE,EAAW,UAAUkB;GAAQ;EAC5D;CACF,GAAG,CAAC,CAAC;CAEL,OAAO,kBAAC1B,EAAoB,UAArB;EAA8B,OAAOS;EAAW;CAAuC,CAAA;AAChG;AAGA,SAAgBkB,IAA+C;CAC7D,OAAOC,EAAW5B,CAAmB;AACvC;AAGA,IAAaqB,IAAwB;CAAE,OAAO;CAAG,QAAQ;AAAE,GAG9CF,IAAsB;CAAE,GAAG;CAAG,GAAG;CAAG,OAAO;EAAE,GAAG;EAAG,GAAG;CAAE;AAAE"}
+{"version":3,"file":"viewRegistry.js","names":["ViewRegistryContext","createContext","ViewRegistryProvider","entriesRef","useRef","seqRef","versionRef","surfaceRef","registry","useMemo","listeners","createEmitter","changed","ordered","a","b","createViewResolver","surface","view","IDENTITY_VIEW","dims","UNMEASURED_DIMS","r","x","y","reg","handle","useOptionalViewRegistry","useContext"],"sources":["../../src/canvas/viewRegistry.tsx"],"sourcesContent":["/**\n * The seam between a canvas surface and the views drawn on it.\n *\n * Traffic runs both ways: the surface attaches a handle onto its frame and its\n * layer stack, and each view registers what it contributes back — the viewport\n * node it paints into and the record the gesture dispatcher routes its events\n * to. Both sides are thunks, read at draw and dispatch time, so neither can\n * serve the other a frame that has already moved.\n */\nimport { createContext, useContext, useMemo, useRef, type ReactNode } from 'react';\nimport type { Dims, RenderLayer } from 'core/layers/render';\nimport type { LayerHit } from 'affordances/types';\nimport type { ChromeState } from 'core/selection/chromeState';\nimport type { View } from 'core/viewport/view';\nimport type { ViewportLayer } from 'features/viewports/viewportLayer';\nimport type { DispatcherViewTarget } from '@weasel-js/routing/internal';\nimport { createViewResolver, type ViewResolver } from 'features/viewports/viewResolver';\nimport { createEmitter } from '@weasel-js/registry';\n\n/**\n * What a view needs from the surface hosting it.\n *\n * @internal Attached by the surface, read by `<CanvasView>`.\n */\nexport interface SurfaceHandle {\n  /** Client-space origin of the canvas element. A rect fact: it knows nothing\n   *  of a `clientToWorld` override, so convert with {@link clientToWorld}. */\n  origin(): { left: number; top: number };\n  /** A client point in the surface's own world — the conversion the surface\n   *  itself makes, its `clientToWorld` override included. */\n  clientToWorld(clientX: number, clientY: number): [number, number];\n  /** The outer camera. */\n  view(): View;\n  /** The canvas's CSS-pixel size. */\n  dims(): Dims;\n  /** The stack a view paints through its own camera, unless it narrows it. */\n  layers(): readonly RenderLayer<unknown>[];\n  requestRedraw(): void;\n  /** The canvas's own view chrome — its selection, its overlay-aware bounds.\n   *  What a `<CanvasView>` answers for itself, answered for view zero. */\n  chromeState(): ChromeState;\n  /** Hit-test the externally registered layers at a world point, against the\n   *  frame and draw envelope of whichever view is asking. The public\n   *  `hitTestExtras` is this with the canvas's own frame and envelope. */\n  hitTestExtras(\n    worldX: number,\n    worldY: number,\n    view: View,\n    dims: Dims,\n    data: unknown,\n    /** Consider only these layers — the ones the asking view paints. A layer\n     *  asked on a frame it was not drawn in answers for the wrong pixels. */\n    only?: readonly RenderLayer<unknown>[],\n  ): { layerId: string; hit: LayerHit } | null;\n  /** Whether a registered layer claims a canvas-local point on the surface's\n   *  own frame. Registered layers paint over every view, so such a point is\n   *  theirs even inside a view's rect. */\n  claimsAbove(x: number, y: number): boolean;\n}\n\n/**\n * What one view contributes to the surface hosting it.\n *\n * @internal Written by `<CanvasView>`, read by the surface. Consumers declare\n *   a view, not a registration.\n */\nexport interface ViewRegistration {\n  id: string;\n  /**\n   * Paint and hit order, low to high. Views declared as props take their array\n   * index; a view mounted as a child takes `Infinity`, so it lands after them\n   * however React happens to order the mount effects.\n   */\n  order: number;\n  /** The viewport node this view paints into. Its `resolvable` is what routes\n   *  input here. */\n  layer: ViewportLayer<unknown>;\n  /** `false` keeps input over the view on the canvas beneath it. */\n  interactive: boolean;\n  /** `false` leaves `layer` for a host to draw — a HUD window's interior — so\n   *  the surface does not paint it too. */\n  paint: boolean;\n  /** Everything about dispatching to this view except its id. */\n  target: Omit<DispatcherViewTarget, 'id'>;\n  /** Whether a scene layer reaches the screen in this view. For input that\n   *  reaches a view without a dispatch — hover — so it judges this view's\n   *  paint rather than the surface's. */\n  layerIsPainted(layerId: string): boolean;\n}\n\n/** @internal */\nexport interface ViewRegistry {\n  /** Returns an unregister. */\n  register(reg: ViewRegistration): () => void;\n  /** Live registrations in paint order. */\n  list(): readonly ViewRegistration[];\n  /** Bumped whenever the list changes. Pair with {@link ViewRegistry.subscribe}\n   *  for `useSyncExternalStore`. */\n  getVersion(): number;\n  subscribe(fn: () => void): () => void;\n  /** Which view a client point belongs to, sticky for a captured pointer.\n   *  One per surface: every caller that routes input — the dispatcher, pinch,\n   *  hover — must agree about where a point landed. */\n  readonly resolver: ViewResolver;\n  /** The hosting surface, or `null` before one attaches. */\n  surface(): SurfaceHandle | null;\n  /** Returns a detach, which leaves a handle attached since alone. */\n  attachSurface(handle: SurfaceHandle): () => void;\n}\n\nconst ViewRegistryContext = createContext<ViewRegistry | null>(null);\n\n/** Mounts the registry for one surface. `<SceneCanvas>` mounts one; a view\n *  declaring itself as a child must be inside it. */\nexport function ViewRegistryProvider({ children }: { children: ReactNode }) {\n  const entriesRef = useRef(new Map<ViewRegistration, number>());\n  const seqRef = useRef(0);\n  const versionRef = useRef(0);\n  const surfaceRef = useRef<SurfaceHandle | null>(null);\n\n  const registry = useMemo<ViewRegistry>(() => {\n    const listeners = createEmitter();\n    const changed = (): void => {\n      versionRef.current++;\n      listeners.emit();\n    };\n    const ordered = (): ViewRegistration[] => [...entriesRef.current.keys()].sort((a, b) => (\n      a.order - b.order || entriesRef.current.get(a)! - entriesRef.current.get(b)!\n    ));\n    const resolver = createViewResolver({\n      views: () => {\n        const surface = surfaceRef.current;\n        const view = surface?.view() ?? IDENTITY_VIEW;\n        const dims = surface?.dims() ?? UNMEASURED_DIMS;\n        return ordered().filter((r) => r.interactive).map((r) => r.layer.resolvable(view, dims));\n      },\n      root: () => surfaceRef.current?.view() ?? IDENTITY_VIEW,\n      canvasOrigin: () => surfaceRef.current?.origin() ?? { left: 0, top: 0 },\n      occluded: (x, y) => surfaceRef.current?.claimsAbove(x, y) ?? false,\n    });\n    return {\n      resolver,\n      register: (reg) => {\n        entriesRef.current.set(reg, seqRef.current++);\n        changed();\n        return () => { entriesRef.current.delete(reg); changed(); };\n      },\n      list: ordered,\n      getVersion: () => versionRef.current,\n      subscribe: listeners.subscribe,\n      surface: () => surfaceRef.current,\n      attachSurface: (handle) => {\n        surfaceRef.current = handle;\n        return () => { if (surfaceRef.current === handle) surfaceRef.current = null; };\n      },\n    };\n  }, []);\n\n  return <ViewRegistryContext.Provider value={registry}>{children}</ViewRegistryContext.Provider>;\n}\n\n/** The surface's view registry, or `null` outside one. */\nexport function useOptionalViewRegistry(): ViewRegistry | null {\n  return useContext(ViewRegistryContext);\n}\n\n/** The `Dims` a surface reports before it has measured itself. */\nexport const UNMEASURED_DIMS: Dims = { width: 0, height: 0 };\n\n/** The camera a view resolves against before its surface attaches. */\nexport const IDENTITY_VIEW: View = { x: 0, y: 0, scale: { x: 1, y: 1 } };\n"],"mappings":";;;;;AA8GA,IAAMA,IAAsBC,EAAmC,IAAI;AAInE,SAAgBC,EAAqB,EAAE,eAAqC;CAC1E,IAAMC,IAAaC,kBAAO,IAAI,IAA8B,CAAC,GACvDC,IAASD,EAAO,CAAC,GACjBE,IAAaF,EAAO,CAAC,GACrBG,IAAaH,EAA6B,IAAI,GAE9CI,IAAWC,QAA4B;EAC3C,IAAMC,IAAYC,EAAc,GAC1BC,UAAsB;GAE1B,AADA,EAAW,WACXF,EAAU,KAAK;EACjB,GACMG,UAAoC,CAAC,GAAGV,EAAW,QAAQ,KAAK,CAAC,CAAC,CAAC,MAAM,GAAG,MAChFW,EAAE,QAAQC,EAAE,SAASZ,EAAW,QAAQ,IAAIW,CAAC,IAAKX,EAAW,QAAQ,IAAIY,CAAC,CAC3E;EAYD,OAAO;GACL,UAZeC,EAAmB;IAClC,aAAa;KACX,IAAMC,IAAUV,EAAW,SACrBW,IAAOD,GAAS,KAAK,KAAKE,GAC1BC,IAAOH,GAAS,KAAK,KAAKI;KAChC,OAAOR,EAAQ,CAAC,CAAC,QAAQ,MAAMS,EAAE,WAAW,CAAC,CAAC,KAAK,MAAMA,EAAE,MAAM,WAAWJ,GAAME,CAAI,CAAC;IACzF;IACA,YAAYb,EAAW,SAAS,KAAK,KAAKY;IAC1C,oBAAoBZ,EAAW,SAAS,OAAO,KAAK;KAAE,MAAM;KAAG,KAAK;IAAE;IACtE,WAAW,GAAG,MAAMA,EAAW,SAAS,YAAYgB,GAAGC,CAAC,KAAK;GAC/D,CAEE;GACA,WAAW,OACTrB,EAAW,QAAQ,IAAIsB,GAAK,EAAO,SAAS,GAC5Cb,EAAQ,SACK;IAAkC,AAAhCT,EAAW,QAAQ,OAAOsB,CAAG,GAAGb,EAAQ;GAAG;GAE5D,MAAMC;GACN,kBAAkBP,EAAW;GAC7B,WAAWI,EAAU;GACrB,eAAeH,EAAW;GAC1B,gBAAgB,OACd,EAAW,UAAUmB,SACR;IAAE,AAAInB,EAAW,YAAYmB,MAAQ,EAAW,UAAU;GAAM;EAEjF;CACF,GAAG,CAAC,CAAC;CAEL,OAAO,kBAAC1B,EAAoB,UAArB;EAA8B,OAAOQ;EAAW;CAAuC,CAAA;AAChG;AAGA,SAAgBmB,IAA+C;CAC7D,OAAOC,EAAW5B,CAAmB;AACvC;AAGA,IAAaqB,IAAwB;CAAE,OAAO;CAAG,QAAQ;AAAE,GAG9CF,IAAsB;CAAE,GAAG;CAAG,GAAG;CAAG,OAAO;EAAE,GAAG;EAAG,GAAG;CAAE;AAAE"}

package/dist/canvas/watchElementMove.js

@@ -0,0 +1,43 @@
+//#region src/canvas/watchElementMove.ts
+function e(e, t) {
+	if (typeof IntersectionObserver > "u") return () => {};
+	let n = e.ownerDocument.documentElement, r = null, i = null, a, o = () => {
+		clearTimeout(a), r?.disconnect(), r = null, i?.disconnect(), i = null;
+	}, s = () => {
+		typeof ResizeObserver < "u" && (i = new ResizeObserver(() => {
+			let n = e.getBoundingClientRect();
+			n.width !== 0 && n.height !== 0 && (t(), c(1));
+		}), i.observe(e));
+	}, c = (i) => {
+		o();
+		let l = e.getBoundingClientRect();
+		if (l.width === 0 || l.height === 0) {
+			s();
+			return;
+		}
+		let u = [
+			Math.floor(l.top),
+			Math.floor(n.clientWidth - l.right),
+			Math.floor(n.clientHeight - l.bottom),
+			Math.floor(l.left)
+		], d = (e) => Math.abs(e.left - l.left) > .5 || Math.abs(e.top - l.top) > .5 || Math.abs(e.width - l.width) > .5 || Math.abs(e.height - l.height) > .5, f = !0;
+		r = new IntersectionObserver((n) => {
+			let r = n[0].intersectionRatio;
+			if (f ? n.length > 1 || d(n[0].boundingClientRect) : r !== i) {
+				t(), c(1);
+				return;
+			}
+			f = !1, r !== i && (r === 0 ? a = setTimeout(() => {
+				d(e.getBoundingClientRect()) && t(), c(1e-7);
+			}, 1e3) : c(r));
+		}, {
+			rootMargin: u.map((e) => `${-e}px`).join(" "),
+			threshold: Math.max(0, Math.min(1, i)) || 1
+		}), r.observe(e);
+	};
+	return c(1), o;
+}
+//#endregion
+export { e as watchElementMove };
+
+//# sourceMappingURL=watchElementMove.js.map

package/dist/canvas/watchElementMove.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"watchElementMove.js","names":["watchElementMove","root","element","observer","sized","retry","stop","awaitSize","box","onMove","frame","insets","movedTo","now","first","ratio","entries","threshold","inset"],"sources":["../../src/canvas/watchElementMove.ts"],"sourcesContent":["/**\n * Call `onMove` when `element`'s box moves in the viewport for a reason no\n * event reports: a sibling collapsing, content loading above it. A scroll or a\n * resize of the element may also call it; a caller already listening for those\n * hears a second, harmless report. Returns the function that stops watching.\n *\n * There is no observer for position, so this frames the element's current box\n * with an `IntersectionObserver` whose root margin is that box exactly. Any move\n * changes how much of the element the frame holds, which the observer reports,\n * and the frame is then rebuilt around the new box.\n *\n * A frame only watches from its first report on, so that report is checked\n * against the box the frame was built around: a move in between is reported too.\n */\nexport function watchElementMove(element: Element, onMove: () => void): () => void {\n  if (typeof IntersectionObserver === 'undefined') return () => {};\n  const root = element.ownerDocument.documentElement;\n  let observer: IntersectionObserver | null = null;\n  let sized: ResizeObserver | null = null;\n  let retry: ReturnType<typeof setTimeout> | undefined;\n\n  const stop = (): void => {\n    clearTimeout(retry);\n    observer?.disconnect();\n    observer = null;\n    sized?.disconnect();\n    sized = null;\n  };\n\n  /** A box with no area cannot be framed, so wait for it to have one. */\n  const awaitSize = (): void => {\n    if (typeof ResizeObserver === 'undefined') return;\n    sized = new ResizeObserver(() => {\n      const box = element.getBoundingClientRect();\n      if (box.width === 0 || box.height === 0) return;\n      onMove();\n      frame(1);\n    });\n    sized.observe(element);\n  };\n\n  const frame = (threshold: number): void => {\n    stop();\n    const box = element.getBoundingClientRect();\n    if (box.width === 0 || box.height === 0) {\n      awaitSize();\n      return;\n    }\n    const insets = [\n      Math.floor(box.top),\n      Math.floor(root.clientWidth - box.right),\n      Math.floor(root.clientHeight - box.bottom),\n      Math.floor(box.left),\n    ];\n    // Half a pixel of slack: two measurements that disagreed by rounding would report every\n    // frame, and the floored frame cannot see a move that small anyway.\n    const movedTo = (now: DOMRectReadOnly): boolean =>\n      Math.abs(now.left - box.left) > 0.5 || Math.abs(now.top - box.top) > 0.5\n      || Math.abs(now.width - box.width) > 0.5 || Math.abs(now.height - box.height) > 0.5;\n    let first = true;\n    observer = new IntersectionObserver(\n      (entries) => {\n        const ratio = entries[0].intersectionRatio;\n        const moved = first\n          ? entries.length > 1 || movedTo(entries[0].boundingClientRect)\n          : ratio !== threshold;\n        if (moved) {\n          onMove();\n          frame(1);\n          return;\n        }\n        first = false;\n        if (ratio === threshold) return;\n        // A box partly off the root never reaches the threshold asked for, so\n        // ask for what it does reach. One wholly off it reports zero for\n        // every frame, wherever it goes; look again once it may have come back.\n        if (ratio !== 0) frame(ratio);\n        else {\n          retry = setTimeout(() => {\n            if (movedTo(element.getBoundingClientRect())) onMove();\n            frame(1e-7);\n          }, 1000);\n        }\n      },\n      { rootMargin: insets.map((inset) => `${-inset}px`).join(' '), threshold: Math.max(0, Math.min(1, threshold)) || 1 },\n    );\n    observer.observe(element);\n  };\n\n  frame(1);\n  return stop;\n}\n"],"mappings":";AAcA,SAAgBA,EAAiB,GAAkB,GAAgC;CACjF,IAAI,OAAO,uBAAyB,KAAa,aAAa,CAAC;CAC/D,IAAMC,IAAOC,EAAQ,cAAc,iBAC/BC,IAAwC,MACxCC,IAA+B,MAC/BC,GAEEC,UAAmB;EAKvB,AAJA,aAAaD,CAAK,GAClBF,GAAU,WAAW,GACrB,IAAW,MACXC,GAAO,WAAW,GAClB,IAAQ;CACV,GAGMG,UAAwB;EAC5B,AAAI,OAAO,iBAAmB,QAC9B,IAAQ,IAAI,qBAAqB;GAC/B,IAAMC,IAAMN,EAAQ,sBAAsB;GAC1C,AAAIM,EAAI,UAAU,KAAKA,EAAI,WAAW,MACtCC,EAAO,GACPC,EAAM,CAAC;EACT,CAAC,GACDN,EAAM,QAAQF,CAAO;CACvB,GAEMQ,KAAS,MAA4B;EACzC,EAAK;EACL,IAAMF,IAAMN,EAAQ,sBAAsB;EAC1C,IAAIM,EAAI,UAAU,KAAKA,EAAI,WAAW,GAAG;GACvC,EAAU;GACV;EACF;EACA,IAAMG,IAAS;GACb,KAAK,MAAMH,EAAI,GAAG;GAClB,KAAK,MAAMP,EAAK,cAAcO,EAAI,KAAK;GACvC,KAAK,MAAMP,EAAK,eAAeO,EAAI,MAAM;GACzC,KAAK,MAAMA,EAAI,IAAI;EACrB,GAGMI,KAAW,MACf,KAAK,IAAIC,EAAI,OAAOL,EAAI,IAAI,IAAI,MAAO,KAAK,IAAIK,EAAI,MAAML,EAAI,GAAG,IAAI,MAClE,KAAK,IAAIK,EAAI,QAAQL,EAAI,KAAK,IAAI,MAAO,KAAK,IAAIK,EAAI,SAASL,EAAI,MAAM,IAAI,IAC9EM,IAAQ;EA2BZ,AA1BA,IAAW,IAAI,sBACZ,MAAY;GACX,IAAMC,IAAQC,EAAQ,EAAE,CAAC;GAIzB,IAHcF,IACVE,EAAQ,SAAS,KAAKJ,EAAQI,EAAQ,EAAE,CAAC,kBAAkB,IAC3DD,MAAUE,GACH;IAET,AADAR,EAAO,GACPC,EAAM,CAAC;IACP;GACF;GAEA,AADA,IAAQ,IACJK,MAAUE,MAIVF,MAAU,IAEZ,IAAQ,iBAAiB;IAEvB,AADIH,EAAQV,EAAQ,sBAAsB,CAAC,KAAGO,EAAO,GACrDC,EAAM,IAAI;GACZ,GAAG,GAAI,IALQA,EAAMK,CAAK;EAO9B,GACA;GAAE,YAAYJ,EAAO,KAAK,MAAU,GAAG,CAACO,EAAM,GAAG,CAAC,CAAC,KAAK,GAAG;GAAG,WAAW,KAAK,IAAI,GAAG,KAAK,IAAI,GAAGD,CAAS,CAAC,KAAK;EAAE,CACpH,GACAd,EAAS,QAAQD,CAAO;CAC1B;CAGA,OADAQ,EAAM,CAAC,GACAJ;AACT"}

package/dist/canvas/wrapNodeOutput.js.map

@@ -1 +1 @@
-{"version":3,"file":"wrapNodeOutput.js","names":["wrapNodeOutput","rotated","wrapWithPoseRotation","cmds","pose","alpha"],"sources":["../../src/canvas/wrapNodeOutput.ts"],"sourcesContent":["/**\n * The per-node wraps a scene render applies on top of whatever `drawOne`\n * returned — pose rotation, then a per-id alpha multiplier. They sit outside\n * `drawOne` on purpose: consumer-supplied painters get rotation and dimming\n * without having to reimplement either.\n *\n * Shared by the main canvas (`buildSceneLayer`) and the detached renders\n * (`buildSceneViewCommands`) so a scene painted off-screen matches the same\n * scene painted on it.\n */\nimport type { DrawCommand } from '../renderer';\nimport { wrapWithPoseRotation } from './poseRotation';\n\n/** Rotate `cmds` about the pose's AABB center and multiply by `alpha`.\n *  Both wraps are skipped when they would be no-ops (zero/absent rotation,\n *  alpha exactly 1, empty command list), so an upright opaque node emits the\n *  painter's commands untouched. Alpha nests OUTSIDE rotation. */\nexport function wrapNodeOutput(\n  cmds: DrawCommand[],\n  pose: unknown,\n  alpha: number,\n): DrawCommand[] {\n  const rotated = wrapWithPoseRotation(cmds, pose);\n  if (alpha !== 1 && rotated.length > 0) {\n    return [{ kind: 'group', alpha, children: rotated }];\n  }\n  return rotated;\n}\n"],"mappings":";;AAiBA,SAAgBA,EACd,GACA,GACA,GACe;CACf,IAAMC,IAAUC,EAAqBC,GAAMC,CAAI;CAI/C,OAHIC,MAAU,KAAKJ,EAAQ,SAAS,IAC3B,CAAC;EAAE,MAAM;EAAS;EAAO,UAAUA;CAAQ,CAAC,IAE9CA;AACT"}
+{"version":3,"file":"wrapNodeOutput.js","names":["wrapNodeOutput","rotated","wrapWithPoseRotation","cmds","pose","alpha"],"sources":["../../src/canvas/wrapNodeOutput.ts"],"sourcesContent":["/**\n * The per-node wraps a scene render applies on top of whatever `drawOne`\n * returned — pose rotation, then a per-id alpha multiplier. They sit outside\n * `drawOne` on purpose: consumer-supplied painters get rotation and dimming\n * without having to reimplement either.\n *\n * Shared by the main canvas (`buildSceneLayer`) and the detached renders\n * (`buildSceneViewCommands`) so a scene painted off-screen matches the same\n * scene painted on it.\n */\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport { wrapWithPoseRotation } from './poseRotation';\n\n/** Rotate `cmds` about the pose's AABB center and multiply by `alpha`.\n *  Both wraps are skipped when they would be no-ops (zero/absent rotation,\n *  alpha exactly 1, empty command list), so an upright opaque node emits the\n *  painter's commands untouched. Alpha nests OUTSIDE rotation. */\nexport function wrapNodeOutput(\n  cmds: DrawCommand[],\n  pose: unknown,\n  alpha: number,\n): DrawCommand[] {\n  const rotated = wrapWithPoseRotation(cmds, pose);\n  if (alpha !== 1 && rotated.length > 0) {\n    return [{ kind: 'group', alpha, children: rotated }];\n  }\n  return rotated;\n}\n"],"mappings":";;AAiBA,SAAgBA,EACd,GACA,GACA,GACe;CACf,IAAMC,IAAUC,EAAqBC,GAAMC,CAAI;CAI/C,OAHIC,MAAU,KAAKJ,EAAQ,SAAS,IAC3B,CAAC;EAAE,MAAM;EAAS;EAAO,UAAUA;CAAQ,CAAC,IAE9CA;AACT"}

package/dist/clipboard.d.ts

@@ -1,7 +1,9 @@
 import { NodeId } from '@weasel-js/routing';
-import { j as ClipboardSnapshot, I as InsertAdapter } from './types-A37hYkeR.js';
+import { d as PasteOmission, j as ClipboardSnapshot, I as InsertAdapter } from './types-CIKDwlsP.js';
 import '@weasel-js/history';
 import '@weasel-js/geom';
+import './poseDescriptor-Bqk-11Rl.js';
+import '@weasel-js/animator';
 
 type Replacer$1 = (key: string, value: unknown) => unknown;
 /** Options for `useClipboardOps`. */
@@ -11,6 +13,10 @@ interface UseClipboardOpsOptions {
     getSelection: () => NodeId[];
     /** Called after a successful paste with the ids of the newly inserted objects. */
     onPaste?: (newIds: NodeId[]) => void;
+    /** Called when a paste left copied nodes out, with each one and the reason
+     *  — an edge whose endpoints were not copied with it, say. Also called for
+     *  a paste that made nothing. */
+    onPasteOmitted?: (omitted: PasteOmission[]) => void;
     /** Label for the history entry produced by paste. Default 'Paste'. */
     pasteLabel?: string;
     /** Pulled once per paste() call. When non-null, threaded to commitPaste
@@ -58,11 +64,11 @@ type Replacer = (key: string, value: unknown) => unknown;
 type Reviver = (key: string, value: unknown) => unknown;
 /** Serialize snapshot items into the versioned wire text.
  *
- *  Function-valued fields (e.g. a container's `clipFromPose`) are dropped by
- *  JSON serialization — OS-pasted clip containers arrive unclipped.
- *  Consumers who need clips to survive the OS round-trip can translate
- *  function ↔ registry key in their `jsonReplacer`/reviver pair (the
- *  scene-serialization `clipFromPoseKey` precedent). */
+ *  JSON drops a function-valued field (a container's `clipFromPose`, a
+ *  node's `derivePath`). A scene adapter's snapshot also carries each one's
+ *  `SceneRegistry` key (`clipFromPoseKey`, `derivePathKey`, …), which does
+ *  cross, and its paste restores the function from the pasting scene's
+ *  registry. A function that is not registered does not survive. */
 declare function buildWeaselClipboardText(items: unknown[], replacer?: Replacer): string;
 /** Cheap check: could this text be a weasel clipboard payload? Substring
  *  pre-check, then a guarded parse + marker/version test. */
@@ -70,12 +76,7 @@ declare function sniffWeaselClipboardText(text: string): boolean;
 /**
  * Embed a weasel clipboard payload in an SVG document as a `<metadata>`
  * child of the root — legal SVG 1.1, ignored by external tools — so one
- * `text/plain` flavor serves both audiences: external tools parse the SVG,
- * weasel extracts the JSON for full fidelity on draw→draw DOM paste.
- *
- * The payload rides in CDATA so JSON's `<` / `&` need no entity escaping; a
- * literal `]]>` inside the payload is split across CDATA sections
- * (`]]]]><![CDATA[>`), which {@link extractWeaselClipboardFromSvg} rejoins.
+ * `text/plain` flavor serves both audiences.
  *
  * Intended for OUR serializer's output only (`serializeSvg` — single
  * `<svg ...>` open tag, XML-escaped attributes). When no open tag is found
@@ -83,13 +84,9 @@ declare function sniffWeaselClipboardText(text: string): boolean;
  */
 declare function embedWeaselMetadataInSvg(svgText: string, payloadText: string): string;
 /**
- * Recover an embedded weasel clipboard payload from SVG text: read the first
- * `<metadata>` block, rejoin its CDATA sections (concatenation restores the
- * `]]>` split by {@link embedWeaselMetadataInSvg}; plain non-CDATA content
- * passes through as-is), and return the payload text iff it sniffs as the
- * weasel wire format — else null (external/non-weasel metadata declines).
- *
- * A text scan, not an XML parse — the payload is small and ours.
+ * The weasel clipboard payload embedded in SVG text by
+ * {@link embedWeaselMetadataInSvg}, or null when the first `<metadata>` block
+ * is absent or not the weasel wire format. A text scan, not an XML parse.
  */
 declare function extractWeaselClipboardFromSvg(svgText: string): string | null;
 /** Parse wire text to snapshot items, or null when malformed/mismatched

package/dist/{types-B_9g6hMM.d.ts → clone-2a5hVbBd.d.ts}

@@ -1,13 +1,34 @@
-import { S as SnapTarget, P as PlaneMap, M as MoveAdapter, I as InsertAdapter } from './types-A37hYkeR.js';
+import { a as PlaneMap, S as SnapTarget, M as MoveAdapter } from './types-CIKDwlsP.js';
 import { Op } from '@weasel-js/history';
 import { Bounds, ModifierState, View, ResizeAnchor } from '@weasel-js/routing';
 
-/** Pointer position in both world and client coords. */
+/**
+ * What a behavior needs to take a pose between the frame a node stores it in
+ * and world. A node under a container whose pose is a frame stores its pose
+ * in that frame, so a stored pose and a world pose are different values
+ * there; under the default composition they are the same and every method is
+ * an identity.
+ */
+interface GestureFrames<TPose> {
+    /** `id`'s pose in world, as the scene shows it now: the gesture's preview
+     *  once one is published. */
+    world(id: string): TPose;
+    /** `pose`, as `id` stores it, in world. */
+    toWorld(id: string, pose: TPose): TPose;
+    /** `worldPose` as `id` stores it: what a pose op or a preview takes. */
+    toLocal(id: string, worldPose: TPose): TPose;
+    /** How the world the gesture edits in maps into the world `layer`'s nodes
+     *  are stored in, read now. Null when they are the same world. */
+    planeOf(layer: string): PlaneMap | null;
+}
+
+/** Pointer position in world coords, and in client coords when the event carried them
+ *  (a keystroke, a UI-driven trigger, and a synthetic probe do not). */
 interface PointerState {
     worldX: number;
     worldY: number;
-    clientX: number;
-    clientY: number;
+    clientX?: number;
+    clientY?: number;
 }
 /**
  * Per-gesture context passed to behaviors. `current` is the running pose
@@ -39,6 +60,12 @@ interface GestureContext<TPose, TNode extends {
      * through this before comparing them with a pose.
      */
     plane?: PlaneMap | null;
+    /**
+     * Frame math over the scene the gesture edits; see {@link GestureFrames}.
+     * Set by move, resize, rotate, and clone. Absent where no node is behind
+     * the gesture's poses: an insert's points, a lasso's.
+     */
+    frames?: GestureFrames<TPose>;
     adapter: MoveAdapter<TNode, TPose>;
     /**
      * Per-gesture mutable store. Keys should be namespaced by behavior name to avoid
@@ -60,21 +87,36 @@ interface SnapStrategy<TPose> {
  * non-undefined return wins (Op[] = commit those, null = abort, undefined =
  * defer); later answers are ignored. So a behavior holding state outside the
  * gesture (published guides, a timer) releases it in onEnd even when an
- * earlier behavior decides. `end.answered` says one did: a behavior that acts
- * on the scene itself from onEnd (starts an animation, applies ops) only
- * cleans up then. A canceled gesture (Esc, pointercancel) runs every
- * behavior's `onCancel` instead, which releases the same state.
+ * earlier behavior decides, or throws: every onEnd still runs, the first
+ * error is rethrown after, and nothing commits. `end.answered` says one did
+ * either: a behavior that acts on the scene itself from onEnd (starts an
+ * animation, applies ops) only cleans up then. A canceled gesture (Esc, pointercancel) runs every
+ * behavior's `onCancel` instead, which releases the same state. `TEnd` is
+ * what `onEnd` is told; an action with more to offer than `BehaviorEnd`
+ * extends it (`MoveEnd`).
  *
  * `defaultTransient`: when one behavior of a move, resize or rotate sets it
  * and the binding leaves `transient` unset, the gesture commits through
  * `scene.untracked` (no history entry). An explicit `transient` wins.
  */
-interface ActionBehavior<TPose, TProposed, TMoveResult> {
+interface ActionBehavior<TPose, TProposed, TMoveResult, TEnd extends BehaviorEnd = BehaviorEnd> {
     defaultTransient?: boolean;
     onStart?(ctx: GestureContext<TPose>): void;
     onMove?(ctx: GestureContext<TPose>, proposed: TProposed): TMoveResult | void;
-    onEnd?(ctx: GestureContext<TPose>, end: BehaviorEnd): Op[] | null | void;
+    onEnd?(ctx: GestureContext<TPose>, end: TEnd): Op[] | null | void;
     onCancel?(ctx: GestureContext<TPose>): void;
+    /**
+     * Called once per gesture, for every behavior whose `onStart` ran, after
+     * the commit's ops have applied (or the cancel has run) and after the
+     * gesture's preview overrides are dropped. `committed` is false when the
+     * gesture was canceled, aborted by a behavior (`onEnd` returned `null`),
+     * released with nothing to commit, or refused by a container its ops
+     * dropped something into, and true otherwise: the action or
+     * a behavior made the commit, a behavior claiming it with no ops
+     * included. For move, resize, and rotate it is the value `onGestureEnd`
+     * receives.
+     */
+    onSettled?(ctx: GestureContext<TPose>, committed: boolean): void;
 }
 /** What a behavior's `onEnd` is told about the commit, beside the gesture. */
 interface BehaviorEnd {
@@ -85,14 +127,7 @@ interface BehaviorEnd {
 /**
  * Uniform group transform proposed by a gesture and shaped by behaviors.
  * Applied identically to every dragged id so a multi-select gesture cannot
- * drift apart (the historical bug: snap shifted only the primary, secondaries
- * kept the raw cursor delta).
- *
- * v1 of the migration: only `'translate'` is wired end-to-end. `'scale'` and
- * `'rotate'` exist for forward compatibility — `useResize` already remaps
- * each leaf via `geom.remapBounds`, and `useRotate` is single-id-pivot-bound,
- * so neither suffers the multi-select drift `'translate'` did. Migrate those
- * gestures to emit `GroupTransform` in a follow-up.
+ * drift apart. Only `'translate'` is wired end-to-end.
  */
 type GroupTransform = {
     kind: 'translate';
@@ -117,30 +152,53 @@ type GroupTransform = {
 /**
  * Per-frame result a `MoveBehavior.onMove` can return.
  *
- * `transform` is the new uniform-group-transform channel: the gesture applies
- * it to every dragged id, eliminating multi-select drift.
+ * `pose` is the legacy channel: a primary-id-only override, routed through
+ * a back-compat shim that derives a `translate` transform from the pose diff
+ * against `origin.get(primaryId)`. Prefer `transform`.
  *
- * `pose` is the legacy channel: a primary-id-only override. The hook routes
- * it through a back-compat shim that derives a `translate` transform from
- * the pose diff against `origin.get(primaryId)`. Prefer `transform` in new
- * behaviors; `pose` will be removed after one release cycle.
- *
- * `snap` announces a visual snap target; unchanged from the legacy contract.
+ * `snap` announces a visual snap target.
  */
 interface BehaviorResult<TPose> {
     /** Replace the proposed transform. Applied uniformly to every id. */
     transform?: GroupTransform;
     /** @deprecated Return `transform` instead. Legacy primary-only pose override; supported via internal shim. */
     pose?: TPose;
+    /** Preview poses for individual ids, each in its node's stored frame. For
+     *  a dragged id the pose replaces the group transform this frame: a
+     *  behavior that will commit its nodes where one translation cannot put
+     *  them, such as a slot each — except a descendant a moving frame
+     *  carries, which rides its frame whatever is posed for it. Any other id
+     *  is shown there for this frame only, and committing it is the
+     *  behavior's job; where a layout drop reflows the same id with no reflow
+     *  transition, the layout's pose wins. A later behavior's pose for an id
+     *  replaces an earlier one's. */
+    poses?: ReadonlyMap<string, TPose>;
+    /** Ids whose preview paints at full opacity this frame rather than as a
+     *  ghost, added to those of the other behaviors. */
+    opaque?: Iterable<string>;
     snap?: SnapTarget<TPose> | null;
 }
 /** @deprecated Renamed to `BehaviorResult`. Kept as an alias for one release cycle. */
 type BehaviorMoveResult<TPose> = BehaviorResult<TPose>;
-/** A behavior plugged into `useMove` — shapes the proposed transform during a drag.
- *  Behaviors receive a `GroupTransform` (currently always `'translate'` for
- *  `useMove`) and return a `BehaviorResult` shaping it (or, legacy, an
- *  override pose run through the back-compat shim). */
-type MoveBehavior<TPose> = ActionBehavior<TPose, GroupTransform, BehaviorResult<TPose>>;
+/** What a move behavior's `onEnd` is told. */
+interface MoveEnd extends BehaviorEnd {
+    /** The action's default translate commit for the dragged roots in `ids`
+     *  and the descendants that follow them, by the drag as the behaviors
+     *  shaped it. For a behavior that claims the commit but places only some of
+     *  the nodes: it returns these beside its own ops. An id that is not a
+     *  dragged root is ignored. */
+    translateOps(ids: Iterable<string>): Op[];
+    /** Where the pointer was let go, in world coordinates; without one on the
+     *  release, the last move's. `ctx.pointer` always holds the last move's. */
+    pointer: {
+        x: number;
+        y: number;
+    };
+}
+/** A behavior on a move — shapes the proposed transform during a drag.
+ *  Behaviors receive a `GroupTransform` (currently always `'translate'`) and
+ *  return a `BehaviorResult` shaping it. */
+type MoveBehavior<TPose> = ActionBehavior<TPose, GroupTransform, BehaviorResult<TPose>, MoveEnd>;
 
 /** Per-frame proposed resize: pose plus the anchor pinning the opposite corner. */
 interface ResizeProposed<TPose extends Bounds> {
@@ -151,20 +209,18 @@ interface ResizeProposed<TPose extends Bounds> {
 interface ResizeMoveResult<TPose extends Bounds> {
     pose?: TPose;
 }
-/** A bounds-frame constraint plugged into `useResize` / `resizeAction`.
+/** A bounds-frame constraint plugged into `resizeAction`.
  *  Reads/writes `{x,y,width,height}` and can override the proposed pose
  *  on each frame (e.g. lock-aspect, clamp-min-size, snap-to-grid). */
 type BoundsConstraint<TPose extends Bounds> = ActionBehavior<TPose, ResizeProposed<TPose>, ResizeMoveResult<TPose>>;
-/** Live overlay state exposed by `useResize` for rendering the in-flight resize ghost. */
+/** Live overlay state for rendering the in-flight resize ghost. */
 interface ResizeOverlay<TPose> {
     id: string;
     currentPose: TPose;
     targetPose: TPose;
     anchor: ResizeAnchor;
-    /** Per-leaf scaled poses when the gesture is resizing a group.
-     *  Keys are the expanded leaf ids (from `expandIds`); values are the
-     *  per-leaf poses produced by scaling each leaf's origin pose against
-     *  the group's origin/proposed union rects. Absent for single-leaf
+    /** Per-leaf scaled poses when the gesture is resizing a group, keyed by
+     *  the expanded leaf ids (from `expandIds`). Absent for single-leaf
      *  resizes. */
     leafPoses?: Map<string, TPose>;
 }
@@ -175,13 +231,17 @@ interface RotateProposed<TPose> {
     /** Proposed rotation angle (radians). */
     rotation: number;
 }
-/** Per-frame result a `RotateBehavior.onMove` can return to override the proposed pose. */
+/** Per-frame result a `RotateBehavior.onMove` can return to override the proposed turn. */
 interface RotateMoveResult<TPose> {
+    /** A pose whose rotation, read through its descriptor, the selection turns to. */
     pose?: TPose;
+    /** The angle to turn to, in radians, for a behavior that changes only the
+     *  angle. Wins over `pose`. */
+    rotation?: number;
 }
-/** A behavior plugged into `useRotate`. */
+/** A behavior on a rotate. */
 type RotateBehavior<TPose> = ActionBehavior<TPose, RotateProposed<TPose>, RotateMoveResult<TPose>>;
-/** Live overlay state exposed by `useRotate` for rendering the in-flight rotation ghost. */
+/** Live overlay state for rendering the in-flight rotation ghost. */
 interface RotateOverlay<TPose> {
     id: string;
     currentPose: TPose;
@@ -210,18 +270,18 @@ interface InsertMoveResult {
     current?: InsertPoint;
 }
 /** Behaviors operate over the two world points; bounds and pose are derived
- *  by the hook from the (possibly modified) points each frame. */
+ *  from the (possibly modified) points each frame. */
 type InsertBehavior<TPose> = ActionBehavior<TPose, InsertProposed<TPose>, InsertMoveResult>;
-/** Live overlay state exposed by `useInsert` for rendering the in-flight insert preview. */
+/** Live overlay state for rendering the in-flight insert preview. */
 interface InsertOverlay<TPose> {
     start: InsertPoint;
     current: InsertPoint;
     /** Axis-aligned bounding rect derived from `start`/`current`. */
     bounds: Bounds;
-    /** TPose constructed from `bounds` via the hook's `posefromBounds`. */
+    /** TPose constructed from `bounds`. */
     pose: TPose;
 }
-/** Live overlay state exposed by `useAreaSelect` for rendering the marquee. */
+/** Live overlay state for rendering the marquee. */
 interface AreaSelectOverlay {
     start: {
         worldX: number;
@@ -251,10 +311,10 @@ interface LassoSelectProposed {
 /** onMove for lasso-select doesn't shape ops; behaviors only need to react
  *  in onEnd. We return void from onMove. */
 type LassoSelectMoveResult = void;
-/** A behavior plugged into `useLassoSelect`. */
+/** A behavior on a lasso-select. */
 type LassoSelectBehavior = ActionBehavior<LassoSelectPose, LassoSelectProposed, LassoSelectMoveResult>;
-/** Live overlay state exposed by `useLassoSelect` for rendering the
- *  in-progress polyline + dashed close-line. */
+/** Live overlay state for rendering the in-progress polyline + dashed
+ *  close-line. */
 interface LassoSelectOverlay {
     vertices: ReadonlyArray<{
         x: number;
@@ -266,7 +326,7 @@ interface LassoSelectOverlay {
     };
     shiftHeld: boolean;
 }
-/** Frames a point-snap behavior can return for the hook to back-solve. */
+/** Frames a point-snap behavior can return for the resize to back-solve. */
 type PointSnapFrame = 'dragged-corner' | 'fixed-corner' | 'center' | 'origin';
 /** Per-frame world-space context handed to `PointSnapBehavior.onMove`.
  *  `draggedCorner` and `fixedCorner` are `null` for edge drags
@@ -300,34 +360,23 @@ interface PointSnapResult {
     worldX: number;
     worldY: number;
 }
-/** A point-snap behavior plugged into `useResize`'s `pointSnapBehaviors`. */
+/** A point-snap behavior, plugged into `ResizePolicy.pointSnap`. */
 interface PointSnapBehavior<TPose extends Bounds> {
     id?: string;
     onMove(ctx: PointSnapContext<TPose>): PointSnapResult | null | undefined;
 }
-/** Pose carried through clone gestures: ids being cloned plus the pointer/offset state. */
-interface ClonePose {
-    ids: string[];
-    offset: {
-        dx: number;
-        dy: number;
-    };
-    worldX: number;
-    worldY: number;
-}
-/** Layer category a clone targets — kit-level placeholder; consumers may narrow. */
-type CloneLayer = 'structures' | 'zones' | 'plantings';
-/** A behavior plugged into `useClone`; gates on modifier state and emits ops at gesture end. */
-interface CloneBehavior {
-    id: string;
-    /** Decides whether this gesture should activate at start. */
-    activates: (modifiers: ModifierState) => boolean;
-    /** On end, returns ops to commit (or [] for no-op). */
-    onEnd: (pose: ClonePose, ctx: {
-        adapter: InsertAdapter<{
-            id: string;
-        }>;
-    }) => Op[];
-}
+/** What a `CloneBehavior.onMove` can return: the translation to use for
+ *  every copy, and a snap target to announce. */
+type CloneBehaviorResult<TPose> = Pick<BehaviorResult<TPose>, 'transform' | 'snap'>;
+/**
+ * A behavior on the `clone` action's binding. It is told the originals: the
+ * selected roots as `draggedIds`, with `origin` and `current` holding the
+ * world pose of each node a copy is placed from, before and after the drag.
+ * `onMove` reshapes the translation; `onEnd` may claim the commit with ops of
+ * its own, which land in place of the copies, or abort it with `null`. A move
+ * behavior that only reshapes the translation, `snap(strategy)` among them,
+ * is one of these.
+ */
+type CloneBehavior<TPose> = ActionBehavior<TPose, GroupTransform, CloneBehaviorResult<TPose>>;
 
-export type { ActionBehavior as A, BoundsConstraint as B, CloneBehavior as C, GestureContext as G, InsertBehavior as I, LassoSelectBehavior as L, MoveBehavior as M, PointSnapBehavior as P, RotateBehavior as R, SnapStrategy as S, AreaSelectOverlay as a, BehaviorEnd as b, BehaviorMoveResult as c, BehaviorResult as d, CloneLayer as e, ClonePose as f, GroupTransform as g, InsertMoveResult as h, InsertOverlay as i, InsertPoint as j, InsertProposed as k, LassoSelectMoveResult as l, LassoSelectOverlay as m, LassoSelectPose as n, LassoSelectProposed as o, PointSnapContext as p, PointSnapFrame as q, PointSnapResult as r, PointerState as s, ResizeMoveResult as t, ResizeOverlay as u, ResizeProposed as v, RotateMoveResult as w, RotateOverlay as x, RotateProposed as y };
+export type { ActionBehavior as A, BoundsConstraint as B, CloneBehavior as C, GestureContext as G, InsertBehavior as I, LassoSelectBehavior as L, MoveBehavior as M, PointSnapBehavior as P, RotateBehavior as R, SnapStrategy as S, AreaSelectOverlay as a, BehaviorEnd as b, BehaviorMoveResult as c, BehaviorResult as d, CloneBehaviorResult as e, GestureFrames as f, GroupTransform as g, InsertMoveResult as h, InsertOverlay as i, InsertPoint as j, InsertProposed as k, LassoSelectMoveResult as l, LassoSelectOverlay as m, LassoSelectPose as n, LassoSelectProposed as o, MoveEnd as p, PointSnapContext as q, PointSnapFrame as r, PointSnapResult as s, PointerState as t, ResizeMoveResult as u, ResizeOverlay as v, ResizeProposed as w, RotateMoveResult as x, RotateOverlay as y, RotateProposed as z };

package/dist/clone.d.ts

@@ -1,10 +1,7 @@
-import { C as CloneBehavior } from './types-B_9g6hMM.js';
-import './types-A37hYkeR.js';
+export { C as CloneBehavior, e as CloneBehaviorResult } from './clone-2a5hVbBd.js';
+import './types-CIKDwlsP.js';
 import '@weasel-js/history';
 import '@weasel-js/geom';
 import '@weasel-js/routing';
-
-/** Clone-on-alt-drag behavior for `useClone`; activates when Alt/Option is held at drag start. */
-declare function cloneByAltDrag(): CloneBehavior;
-
-export { cloneByAltDrag };
+import './poseDescriptor-Bqk-11Rl.js';
+import '@weasel-js/animator';

package/dist/clone.js

@@ -1,2 +0,0 @@
-import { cloneByAltDrag as e } from "./interactions/actions/clone/behaviors/cloneByAltDrag.js";
-export { e as cloneByAltDrag };

package/dist/core/device/index.js

@@ -1,4 +1,5 @@
-import { DeviceProfileProvider as e, useDeviceProfile as t } from "./useDeviceProfile.js";
-import { ANCHOR_HIT_BASE_PX as n, HANDLE_BASE_PX as r, ROTATION_HANDLE_BASE_PX as i } from "./targets.js";
-import { COARSE_TARGET_SCALE as a, DEFAULT_DEVICE_PROFILE as o, resolveDeviceProfile as s } from "@weasel-js/routing";
-export { n as ANCHOR_HIT_BASE_PX, a as COARSE_TARGET_SCALE, o as DEFAULT_DEVICE_PROFILE, e as DeviceProfileProvider, r as HANDLE_BASE_PX, i as ROTATION_HANDLE_BASE_PX, s as resolveDeviceProfile, t as useDeviceProfile };
+import { watchDevicePixelRatio as e } from "./watchDevicePixelRatio.js";
+import { DeviceProfileProvider as t, useDeviceProfile as n } from "./useDeviceProfile.js";
+import { ANCHOR_HIT_BASE_PX as r, HANDLE_BASE_PX as i, ROTATION_HANDLE_BASE_PX as a } from "./targets.js";
+import { COARSE_TARGET_SCALE as o, DEFAULT_DEVICE_PROFILE as s, resolveDeviceProfile as c } from "@weasel-js/routing";
+export { r as ANCHOR_HIT_BASE_PX, o as COARSE_TARGET_SCALE, s as DEFAULT_DEVICE_PROFILE, t as DeviceProfileProvider, i as HANDLE_BASE_PX, a as ROTATION_HANDLE_BASE_PX, c as resolveDeviceProfile, n as useDeviceProfile, e as watchDevicePixelRatio };