@weasel-js/core 1.7.0 → 1.7.2

package/dist/canvas/useViewHelpers.js

@@ -0,0 +1,120 @@
+import { unionAABB as e } from "../core/geometry/unionBounds.js";
+import { aggregatePreviewIds as t, firstPreviewBounds as n, firstPreviewPose as r, toolPreviewSources as i } from "./toolPreview.js";
+import { buildChromeState as a } from "../core/selection/chromeState.js";
+import { useCallback as o, useMemo as s } from "react";
+import { useLatest as c } from "@weasel-js/react";
+//#region src/canvas/useViewHelpers.ts
+var l = () => {}, u = () => !0;
+function d(e, t) {
+	return typeof e.getWorldPose == "function" ? e.getWorldPose(t) : e.getPose(t);
+}
+function f(f) {
+	let { adapter: p, geometry: m, boundsOf: h, boundsOfPose: g, selection: _, tools: v, gestureSource: y, previewPoseExtra: b, previewIdsExtra: x, getIsVisible: S } = f, C = o((e, t) => g ? g(e, t) : m.getBounds(t), [g, m]), w = s(() => {
+		if (h) return h;
+		if (p) return (e) => {
+			try {
+				let t = d(p, e), n = m.getBounds(t), r = m.getRotation?.(t);
+				return r ? {
+					...n,
+					rotation: r
+				} : n;
+			} catch {
+				return null;
+			}
+		};
+	}, [
+		h,
+		p,
+		m
+	]), T = o((e) => {
+		if (!p) return null;
+		try {
+			return d(p, e);
+		} catch {
+			return null;
+		}
+	}, [p]), E = _.length > 1, D = c({
+		previewPoseExtra: b,
+		previewIdsExtra: x
+	}), O = s(() => h ?? w, [h, w]), k = o((e) => {
+		if (v) {
+			let t = r(v, e);
+			if (t != null) return t;
+		}
+		let t = D.current.previewPoseExtra;
+		if (t) {
+			let n = t(e);
+			if (n != null) return n;
+		}
+		return null;
+	}, [v, D]), A = o((e) => {
+		if (v) {
+			let t = n(v, e);
+			if (t) return t;
+			let i = r(v, e);
+			if (i != null) return C(e, i);
+		}
+		let t = D.current.previewPoseExtra;
+		if (t) {
+			let n = t(e);
+			if (n != null) return C(e, n);
+		}
+		return null;
+	}, [
+		v,
+		C,
+		D
+	]), j = o((e) => A(e) || (O ? O(e) : null), [A, O]), M = s(() => a({
+		selection: _,
+		multiActive: E,
+		effectiveBoundsOf: j,
+		modifiers: {
+			alt: !1,
+			shift: !1,
+			meta: !1,
+			ctrl: !1
+		},
+		canRotate: (e) => {
+			if (!m.supportsRotation) return !0;
+			let t = T(e);
+			return t == null || m.supportsRotation(t);
+		}
+	}), [
+		_,
+		E,
+		j,
+		m,
+		T
+	]);
+	return {
+		helpers: {
+			getEffectivePose: (e) => k(e) ?? T(e),
+			getEffectiveBounds: j,
+			getGestureBounds: () => {
+				let n = t(v), r = y?.ids();
+				if (r) for (let e of r) n.add(e);
+				let i = [];
+				for (let e of n) i.push(A(e));
+				let a = y?.bounds();
+				if (a) for (let e of a) i.push(e);
+				return e(i);
+			},
+			subscribeGestures: (e) => y?.subscribe(e) ?? l,
+			getGestureVersion: () => y?.getVersion() ?? 0,
+			getChromeState: () => M,
+			getPreviewSources: () => [...i(v), ...y?.previewSources() ?? []],
+			getGestureOverlays: () => y?.overlays() ?? [],
+			getIsVisible: () => S?.() ?? u
+		},
+		chromeState: M,
+		committedPoseOf: T,
+		effectiveBoundsOf: O,
+		previewToolPose: k,
+		previewToolBounds: A,
+		previewExtraRef: D
+	};
+}
+//#endregion
+export { f as useViewHelpers };
+
+//# sourceMappingURL=useViewHelpers.js.map

package/dist/canvas/useViewHelpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useViewHelpers.js","names":["noOpUnsubscribe","alwaysVisible","worldPoseOf","adapter","id","useViewHelpers","opts","boxOf","useCallback","boundsOfPose","pose","geometry","baseBoundsOf","useMemo","boundsOf","b","rot","committedPoseOf","multiActive","selection","previewExtraRef","useLatest","effectiveBoundsOf","previewToolPose","tools","p","firstPreviewPose","extra","previewToolBounds","firstPreviewBounds","boundsWithPreview","chromeState","buildChromeState","ids","aggregatePreviewIds","extraIds","gestureSource","parts","extraBounds","unionAABB","fn","toolPreviewSources","getIsVisible"],"sources":["../../src/canvas/useViewHelpers.ts"],"sourcesContent":["import { useCallback, useMemo } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { firstPreviewPose, firstPreviewBounds, aggregatePreviewIds, toolPreviewSources } from './toolPreview';\nimport type { GestureSource, GesturePreviewSource } from './gestureBounds';\nimport type { OngoingOverlay } from '@weasel-js/routing';\nimport { unionAABB } from 'core/geometry/unionBounds';\nimport { buildChromeState, type ChromeState } from 'core/selection/chromeState';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport type { NodeId } from 'core/scene/types';\nimport type { ToolsApi } from '../tools/overlayBinding';\nimport type { DebugSink } from '../debug/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\n\nconst noOpUnsubscribe = (): void => {};\n\nconst alwaysVisible = (): boolean => true;\n\n/**\n * The half of {@link CanvasHelpers} that belongs to one view — everything\n * answered by a camera's own tools, gestures and selection. A canvas hosting\n * several viewports needs one of these per view; the surface half is shared.\n */\nexport interface CanvasViewHelpers<TPose> {\n  /** Pose currently displayed for `id` — drag/resize/rotate overlay if active,\n   *  otherwise the committed pose from the adapter. Returns `null` if the id\n   *  isn't known. */\n  getEffectivePose(id: string): TPose | null;\n  /** Overlay-aware bounds for `id`. */\n  getEffectiveBounds(id: string): Bounds | null;\n  /**\n   * World-space AABB of everything the in-flight gesture proposes — the\n   * displaced poses of nodes being moved / resized / rotated / cloned, plus\n   * any nascent insert that has no scene node yet. `null` when no gesture is\n   * in flight.\n   *\n   * This reports the *gesture*, not the document: committed content the\n   * gesture isn't touching is excluded, so a consumer that wants the union\n   * with the rest of the scene still walks its own ids through\n   * `getEffectiveBounds`. It exists because every other lookup here is keyed\n   * by node id, which can't answer \"where is the shape the user is drawing\n   * right now\" — a drag-to-insert has no id until pointer-up.\n   *\n   * Select-only gestures are deliberately excluded: a marquee or lasso has\n   * geometry but proposes no content, and a consumer sizing itself to the\n   * gesture must not grow because the user swept a selection rectangle.\n   *\n   * The result is a plain AABB — never rotated. Rotated parts are folded in\n   * by their rotated extent (a union of several oriented boxes has no single\n   * orientation to report).\n   */\n  getGestureBounds(): Bounds | null;\n  /**\n   * Subscribe to the gesture layer's change signal — the other half of the\n   * `useSyncExternalStore` contract for everything on this object that moves\n   * during a drag (`getEffectivePose`, `getEffectiveBounds`,\n   * `getGestureBounds`). Returns an unsubscribe.\n   *\n   * Fires once per dispatcher pump: gesture start, every pointermove that\n   * reaches an in-flight handle, end, and cancel — plus UI-driven ongoing\n   * actions (a slider bound to an ongoing action pumps the same way). It\n   * fires on the pump, not on a diff: a pump that changed nothing observable\n   * still notifies, so don't hang expensive work directly off the callback.\n   *\n   * It does **not** cover committed scene edits (subscribe to the scene for\n   * those) or previews a consumer's own tool publishes from React state\n   * (that tool re-renders on its own).\n   *\n   * Without a gesture source wired — a bare `<Canvas>` — this is a no-op\n   * subscription that never fires.\n   */\n  subscribeGestures(fn: () => void): () => void;\n  /**\n   * Monotonic counter bumped on exactly the events `subscribeGestures` fires\n   * on. Pair the two for `useSyncExternalStore`:\n   *\n   * ```ts\n   * const gestureVersion = useSyncExternalStore(\n   *   useCallback((cb) => helpersRef.current?.subscribeGestures(cb) ?? (() => {}), []),\n   *   () => helpersRef.current?.getGestureVersion() ?? 0,\n   * );\n   * ```\n   *\n   * Starts at 0 and only increases. `0` is also what a bare `<Canvas>` with\n   * no gesture source reports, forever.\n   */\n  getGestureVersion(): number;\n  /** Returns the live ChromeState built once per render. Affordances and\n   *  custom layers that need overlay-aware selection state (selection ids,\n   *  bounds, multi-union AABB, modifier flags) read from this. */\n  getChromeState(): ChromeState;\n  /**\n   * Everything publishing an in-flight preview for this view, in resolution\n   * order: tool-side first (hotkey → active → registry → ambient), then the\n   * handles in flight on this view's dispatcher. Readers take the first\n   * non-null answer per id.\n   *\n   * A ghost layer must read this off its draw envelope rather than close over\n   * a dispatcher: one layer array paints every view, so a closure ghosts view\n   * zero's drag into every panel.\n   */\n  getPreviewSources(): readonly GesturePreviewSource[];\n  /** Overlay shapes this view's in-flight handles publish — marquee, lasso,\n   *  insert preview, raw commands. Same envelope rule as\n   *  {@link CanvasViewHelpers.getPreviewSources}. */\n  getGestureOverlays(): readonly OngoingOverlay[];\n  /**\n   * Chrome-caps visibility predicate, keyed by chrome id. Overlay layers and\n   * affordances call it per element to decide whether to draw / hit-test.\n   *\n   * The rule table is the surface's; the context it resolves against is this\n   * view's selection, camera and in-flight action — so the predicate belongs\n   * here rather than on {@link CanvasSurfaceHelpers}. Unwired, it is the\n   * universal `() => true`.\n   */\n  getIsVisible(): (id: string) => boolean;\n}\n\n/**\n * The half of {@link CanvasHelpers} that belongs to the surface — one GL\n * context, one debug sink, however many views are drawn on it.\n */\nexport interface CanvasSurfaceHelpers {\n  /** Active debug sink, when `<Canvas debug=...>` is enabled. Layers that\n   *  want to participate in `hitboxes`/`bounds`/etc. visualization can\n   *  call into this from their `draw` callback. Returns `null` when\n   *  debug is off — no-op for production renders. */\n  getDebug(): DebugSink | null;\n}\n\n/** Live overlay-aware lookups exposed to custom layers via `helpersRef`.\n *  What a layer receives as its `data` argument, unchanged: the two halves\n *  are split so a per-view set can be built independently of the surface's,\n *  not to make layers ask for one. */\nexport interface CanvasHelpers<TPose> extends CanvasViewHelpers<TPose>, CanvasSurfaceHelpers {\n  /**\n   * The view this draw is for: a `<CanvasView>` id, or `null` for the\n   * surface's own camera. One layer array paints every view, so a layer that\n   * belongs in some views and not others — a minimap's indicator — declines\n   * the rest by this id.\n   */\n  readonly viewId: string | null;\n}\n\nexport interface UseViewHelpersOpts<TPose> {\n  /** Only `getPose` is read here — the narrow slice keeps this hook off the\n   *  full adapter contract. */\n  adapter: { getPose(id: string): TPose } | undefined;\n  geometry: PoseDescriptor<TPose>;\n  /** Consumer-supplied bounds resolver. Falls back to the adapter's pose. */\n  boundsOf: ((id: string) => Bounds | null) | undefined;\n  /** Bounds of `id` drawn at an in-flight `pose`. Falls back to the\n   *  geometry's box of that pose, which is wrong wherever the surface draws a\n   *  node somewhere its pose does not say — a parallax plane. */\n  boundsOfPose?: ((id: string, pose: TPose) => Bounds | null) | undefined;\n  selection: readonly NodeId[];\n  tools: ToolsApi | undefined;\n  gestureSource: GestureSource | undefined;\n  /** Dispatcher-published preview overlays, read through a ref so a change\n   *  mid-gesture doesn't rebuild the memos that depend on them. */\n  previewPoseExtra: ((id: string) => unknown) | undefined;\n  previewIdsExtra: (() => Iterable<string> | null) | undefined;\n  /** Chrome-caps predicate for this view. Absent means everything is visible. */\n  getIsVisible?: (() => (id: string) => boolean) | undefined;\n}\n\nexport interface ViewHelpersBundle<TPose> {\n  helpers: CanvasViewHelpers<TPose>;\n  chromeState: ChromeState;\n  /** Committed pose straight from the adapter, no overlay applied. */\n  committedPoseOf(id: string): TPose | null;\n  /** Bounds resolver after the `boundsOf` / adapter fallback, before previews. */\n  effectiveBoundsOf: ((id: string) => Bounds | null) | undefined;\n  previewToolPose(id: string): TPose | null;\n  previewToolBounds(id: string): Bounds | null;\n  /** Live dispatcher preview extras, for callers outside this bundle. */\n  previewExtraRef: React.MutableRefObject<{\n    previewPoseExtra: ((id: string) => unknown) | undefined;\n    previewIdsExtra: (() => Iterable<string> | null) | undefined;\n  }>;\n}\n\n/**\n * Build one view's overlay-aware state: its chrome and the lookups its layers\n * draw and hit-test against.\n *\n * This is a hook, so it runs once per component. That is the point — N views\n * cannot be a loop inside one component, but they can be N components each\n * calling this once.\n */\n/** The composed pose when the adapter resolves one, its stored pose otherwise.\n *  Adapters predating `getWorldPose` are absolute-pose, where the two agree. */\nfunction worldPoseOf<TPose>(\n  adapter: { getPose(id: string): TPose; getWorldPose?(id: string): TPose },\n  id: string,\n): TPose {\n  return typeof adapter.getWorldPose === 'function' ? adapter.getWorldPose(id) : adapter.getPose(id);\n}\n\nexport function useViewHelpers<TPose>(\n  opts: UseViewHelpersOpts<TPose>,\n): ViewHelpersBundle<TPose> {\n  const {\n    adapter, geometry, boundsOf, boundsOfPose, selection, tools, gestureSource,\n    previewPoseExtra, previewIdsExtra, getIsVisible,\n  } = opts;\n  const boxOf = useCallback(\n    (id: string, pose: TPose): Bounds | null =>\n      (boundsOfPose ? boundsOfPose(id, pose) : geometry.getBounds(pose)),\n    [boundsOfPose, geometry],\n  );\n\n  const baseBoundsOf = useMemo(() => {\n    if (boundsOf) return boundsOf;\n    if (!adapter) return undefined;\n    return (id: string): Bounds | null => {\n      try {\n        // World: chrome is drawn over the picture, so it has to agree with\n        // where the renderer put the node, not with where its pose is stored.\n        const pose = worldPoseOf(adapter, id);\n        const b = geometry.getBounds(pose);\n        const rot = geometry.getRotation?.(pose);\n        return rot ? { ...b, rotation: rot } : b;\n      } catch {\n        return null;\n      }\n    };\n  }, [boundsOf, adapter, geometry]);\n\n  const committedPoseOf = useCallback((id: string): TPose | null => {\n    if (!adapter) return null;\n    try {\n      return worldPoseOf(adapter, id);\n    } catch {\n      return null;\n    }\n  }, [adapter]);\n\n  const multiActive = selection.length > 1;\n\n  const previewExtraRef = useLatest({ previewPoseExtra, previewIdsExtra });\n\n  const effectiveBoundsOf = useMemo(() => boundsOf ?? baseBoundsOf, [boundsOf, baseBoundsOf]);\n\n  // The live overlay a gesture proposes for `id`: the active tool's published\n  // preview first, then the dispatcher's preview extras. `null` when nothing\n  // is mid-gesture — callers fall through to committed state.\n  const previewToolPose = useCallback((id: string): TPose | null => {\n    if (tools) {\n      const p = firstPreviewPose(tools, id);\n      if (p != null) return p as TPose;\n    }\n    const extra = previewExtraRef.current.previewPoseExtra;\n    if (extra) {\n      const p = extra(id);\n      if (p != null) return p as TPose;\n    }\n    return null;\n  }, [tools, previewExtraRef]);\n  const previewToolBounds = useCallback((id: string): Bounds | null => {\n    if (tools) {\n      const b = firstPreviewBounds(tools, id);\n      if (b) return b;\n      const p = firstPreviewPose(tools, id);\n      if (p != null) return boxOf(id, p as TPose);\n    }\n    const extra = previewExtraRef.current.previewPoseExtra;\n    if (extra) {\n      const p = extra(id);\n      if (p != null) return boxOf(id, p as TPose);\n    }\n    return null;\n  }, [tools, boxOf, previewExtraRef]);\n\n  /**\n   * Bounds for `id` with any in-flight gesture folded in — what the user can\n   * see, not what is committed. Both the chrome state and the layer helpers\n   * answer bounds questions with this, so resize handles cannot end up a frame\n   * away from the shape they belong to.\n   */\n  const boundsWithPreview = useCallback((id: string): Bounds | null => {\n    const previewed = previewToolBounds(id);\n    if (previewed) return previewed;\n    return effectiveBoundsOf ? effectiveBoundsOf(id) : null;\n  }, [previewToolBounds, effectiveBoundsOf]);\n\n  const chromeState: ChromeState = useMemo(\n    () => buildChromeState({\n      selection,\n      multiActive,\n      effectiveBoundsOf: boundsWithPreview,\n      modifiers: { alt: false, shift: false, meta: false, ctrl: false },\n      // Rotation-capability predicate. Reads the committed pose (gestures\n      // don't change descriptor capability) and asks the geometry. Absent\n      // adapter / unknown ids fall back to `true` so the affordance stays\n      // visible — preserves pre-existing behavior for consumers that wire\n      // bounds without an adapter.\n      canRotate: (id) => {\n        if (!geometry.supportsRotation) return true;\n        const pose = committedPoseOf(id);\n        if (pose == null) return true;\n        return geometry.supportsRotation(pose);\n      },\n    }),\n    [selection, multiActive, boundsWithPreview, geometry, committedPoseOf],\n  );\n\n  const helpers: CanvasViewHelpers<TPose> = {\n    getEffectivePose: (id: string): TPose | null => {\n      const tp = previewToolPose(id);\n      if (tp != null) return tp;\n      return committedPoseOf(id);\n    },\n    getEffectiveBounds: boundsWithPreview,\n    getGestureBounds: (): Bounds | null => {\n      // In-flight ids come from both preview sources the ghost layer walks:\n      // tool-published `previewIds()` and the dispatcher's in-flight handles\n      // (via `gestureSource.ids()`). Using the same sets keeps this from\n      // disagreeing with what the user sees ghosted.\n      const ids = aggregatePreviewIds(tools);\n      const extraIds = gestureSource?.ids();\n      if (extraIds) for (const id of extraIds) ids.add(id);\n\n      const parts: (Bounds | null)[] = [];\n      for (const id of ids) parts.push(previewToolBounds(id));\n      // Nascent inserts have no id to look up — they arrive as ready-made\n      // world AABBs.\n      const extraBounds = gestureSource?.bounds();\n      if (extraBounds) for (const b of extraBounds) parts.push(b);\n      return unionAABB(parts);\n    },\n    subscribeGestures: (fn: () => void): (() => void) =>\n      gestureSource?.subscribe(fn) ?? noOpUnsubscribe,\n    getGestureVersion: (): number => gestureSource?.getVersion() ?? 0,\n    getChromeState: () => chromeState,\n    getPreviewSources: (): readonly GesturePreviewSource[] => [\n      ...toolPreviewSources(tools),\n      ...(gestureSource?.previewSources() ?? []),\n    ],\n    getGestureOverlays: (): readonly OngoingOverlay[] => gestureSource?.overlays() ?? [],\n    getIsVisible: (): ((id: string) => boolean) => getIsVisible?.() ?? alwaysVisible,\n  };\n\n  return {\n    helpers,\n    chromeState,\n    committedPoseOf,\n    effectiveBoundsOf,\n    previewToolPose,\n    previewToolBounds,\n    previewExtraRef,\n  };\n}\n"],"mappings":"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"}

package/dist/canvas/viewInputs.js

@@ -0,0 +1,17 @@
+import { createContext as e, useContext as t } from "react";
+import { jsx as n } from "react/jsx-runtime";
+//#region src/canvas/viewInputs.tsx
+var r = e(null);
+function i({ value: e, children: t }) {
+	return /* @__PURE__ */ n(r.Provider, {
+		value: e,
+		children: t
+	});
+}
+function a() {
+	return t(r);
+}
+//#endregion
+export { i as ViewInputsProvider, a as useOptionalViewInputs };
+
+//# sourceMappingURL=viewInputs.js.map

package/dist/canvas/viewInputs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"viewInputs.js","names":["ViewInputsContext","createContext","ViewInputsProvider","useOptionalViewInputs","useContext"],"sources":["../../src/canvas/viewInputs.tsx"],"sourcesContent":["/**\n * What {@link useViewHelpers} needs that belongs to the surface rather than to\n * one view: the adapter, the geometry, the bounds resolver and the tools.\n *\n * These are read during a view's render, so they travel as context rather than\n * on the `SurfaceHandle`, which is not attached until an effect runs.\n */\nimport { createContext, useContext, type ReactNode } from 'react';\nimport type { UseViewHelpersOpts } from './useViewHelpers';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type { NodeId } from 'core/scene/types';\nimport type { View } from 'core/viewport/view';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { PlaneMap } from 'core/viewport/parallax';\nimport type { RuleCtx } from 'features/chrome-caps';\nimport type { PickView } from './SceneCanvas/useSceneSelectTool';\n\n/**\n * The part of a chrome-caps rule context that belongs to one view. Everything\n * else a `RuleCtx` carries — mode, capabilities, device, focus — is the\n * surface's and the same for every view drawn on it.\n */\nexport interface ViewRuleInputs {\n  selection: readonly NodeId[];\n  view: View;\n  /** What that view's dispatcher currently has in flight. */\n  action: { kind: string | null; id: string | null };\n}\n\n/**\n * @internal Provided by the surface, consumed by `<CanvasView>`.\n *\n * The scene-shaped half only. What a gesture is doing right now is read from\n * the asking view's own dispatcher, not from here.\n */\nexport interface SurfaceViewInputs\n  extends Pick<UseViewHelpersOpts<unknown>, 'adapter' | 'geometry' | 'tools'> {\n  /** A node's box for chrome, drawn under `view` — the camera of the view\n   *  asking, since a node on a parallax plane lands somewhere else in each. */\n  boundsOf: ((id: string, view?: View | null) => Bounds | null) | undefined;\n  /** How `view`'s world maps into the parallax plane `id` is drawn through,\n   *  or null when its layer moves with the camera. */\n  planeOfNode?: ((id: string, view?: View | null) => PlaneMap | null) | undefined;\n  /** `boundsOf` for `id` drawn at an in-flight `pose`, under `view`. */\n  boundsOfPose?: ((id: string, pose: unknown, view?: View | null) => Bounds | null) | undefined;\n  /** Every id under a world point, bottom-first. `view` is the view the\n   *  point was produced under — a screen-pixel tolerance cannot be converted\n   *  without its scale, nor a layer judged without its paint, and the world\n   *  point carries neither. */\n  pickEvery?: (worldX: number, worldY: number, view?: PickView | null) => string[];\n  /** The one id a click resolves to, collapsing parent/child the way the\n   *  select tool does. Falls back to `pickEvery`'s last when absent. */\n  pickBest?: (worldX: number, worldY: number, view?: PickView | null) => string | null;\n  /** A hit node's routing-trait kind, so `target: 'kind:text'` bindings match. */\n  kindOfNode?: (id: string) => string | undefined;\n  /**\n   * The surface's chrome-caps rule table, evaluated against a view's own\n   * context. The rules are surface-wide on purpose — one consumer table, one\n   * set of kit defaults — but a rule keyed on selection, camera or the\n   * in-flight action answers differently per view, so the caller supplies the\n   * context and both the paint gate and the dispatcher's eligibility filter\n   * read the same one.\n   */\n  chromeCaps?: {\n    /** `undefined` when the surface gates nothing — no mode registry wired,\n     *  which is what `<SceneCanvas>` reports for its own view too. */\n    ruleCtx(inputs: ViewRuleInputs): RuleCtx | undefined;\n    isVisible(inputs: ViewRuleInputs): (id: string) => boolean;\n  };\n  /** The surface's selection, which a view shares unless it was given one of\n   *  its own. */\n  selectionApi: SelectionApi;\n  /** The rotate badge the surface's selection overlay paints, which every\n   *  view drawing that overlay has to make grabbable where it is drawn. */\n  rotationBadge?: { distancePx: number; sizePx: number } | null;\n}\n\nconst ViewInputsContext = createContext<SurfaceViewInputs | null>(null);\n\n/** @internal */\nexport function ViewInputsProvider(\n  { value, children }: { value: SurfaceViewInputs; children: ReactNode },\n) {\n  return <ViewInputsContext.Provider value={value}>{children}</ViewInputsContext.Provider>;\n}\n\n/** The hosting surface's view-helper inputs, or `null` outside one. */\nexport function useOptionalViewInputs(): SurfaceViewInputs | null {\n  return useContext(ViewInputsContext);\n}\n"],"mappings":";;;AA6EA,IAAMA,IAAoBC,EAAwC,IAAI;AAGtE,SAAgBC,EACd,EAAE,UAAO,eACT;CACA,OAAO,kBAACF,EAAkB,UAAnB;EAAmC;EAAQ;CAAqC,CAAA;AACzF;AAGA,SAAgBG,IAAkD;CAChE,OAAOC,EAAWJ,CAAiB;AACrC"}

package/dist/canvas/viewRegistry.js

@@ -0,0 +1,61 @@
+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";
+//#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));
+		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));
+				},
+				root: () => f.current?.view() ?? u,
+				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);
+			}),
+			surface: () => f.current,
+			attachSurface: (e) => {
+				f.current = e;
+			}
+		};
+	}, []);
+	return /* @__PURE__ */ a(o.Provider, {
+		value: p,
+		children: t
+	});
+}
+function c() {
+	return n(o);
+}
+var l = {
+	width: 0,
+	height: 0
+}, u = {
+	x: 0,
+	y: 0,
+	scale: {
+		x: 1,
+		y: 1
+	}
+};
+//#endregion
+export { u as IDENTITY_VIEW, l as UNMEASURED_DIMS, s as ViewRegistryProvider, c as useOptionalViewRegistry };
+
+//# sourceMappingURL=viewRegistry.js.map

package/dist/canvas/viewRegistry.js.map

@@ -0,0 +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"}

package/dist/canvas/wrapNodeOutput.js

@@ -0,0 +1,14 @@
+import { wrapWithPoseRotation as e } from "./poseRotation.js";
+//#region src/canvas/wrapNodeOutput.ts
+function t(t, n, r) {
+	let i = e(t, n);
+	return r !== 1 && i.length > 0 ? [{
+		kind: "group",
+		alpha: r,
+		children: i
+	}] : i;
+}
+//#endregion
+export { t as wrapNodeOutput };
+
+//# sourceMappingURL=wrapNodeOutput.js.map

package/dist/canvas/wrapNodeOutput.js.map

@@ -0,0 +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"}

package/dist/clipboard.d.ts

@@ -1,7 +1,7 @@
 import { NodeId } from '@weasel-js/routing';
-import { C as ClipboardSnapshot, I as InsertAdapter } from './types-D-9QWBy5.js';
+import { j as ClipboardSnapshot, I as InsertAdapter } from './types-A37hYkeR.js';
 import '@weasel-js/history';
-import './path-JEV2c5If.js';
+import '@weasel-js/geom';
 
 type Replacer$1 = (key: string, value: unknown) => unknown;
 /** Options for `useClipboardOps`. */
@@ -26,12 +26,17 @@ interface UseClipboardOpsOptions {
      *  `application/x-weasel-clipboard+json` plus `text/plain` carrying the
      *  same JSON. Apps override to add richer flavors (e.g. real SVG) or to
      *  replace the text flavor. Return an empty object to skip the OS write
-     *  entirely. */
-    produceFlavors?: (snapshot: ClipboardSnapshot) => Record<string, string>;
+     *  entirely. A value may be a promise — an SVG flavor waiting on
+     *  `warmSvg`, say: the write is still issued inside the copy gesture and
+     *  the clipboard takes the text when it resolves. The producer itself runs
+     *  synchronously, so it reads the selection as it stood at the copy. */
+    produceFlavors?: (snapshot: ClipboardSnapshot) => ClipboardFlavors;
     /** Replacer for the kit-default JSON flavor (typed arrays etc.). Ignored
      *  when `produceFlavors` is supplied. */
     jsonReplacer?: Replacer$1;
 }
+/** MIME type to payload, as `produceFlavors` returns it. */
+type ClipboardFlavors = Record<string, string | Promise<string>>;
 /** Return shape of `useClipboardOps`: imperative `copy`, `paste`, and `isEmpty` functions. */
 interface UseClipboardOpsReturn {
     copy(): void;
@@ -91,4 +96,4 @@ declare function extractWeaselClipboardFromSvg(svgText: string): string | null;
  *  (callers decline to the next content handler). */
 declare function parseWeaselClipboardText(text: string, reviver?: Reviver): unknown[] | null;
 
-export { type UseClipboardOpsOptions, type UseClipboardOpsReturn, WEASEL_CLIPBOARD_MIME, WEASEL_CLIPBOARD_MIME_WEB, buildWeaselClipboardText, embedWeaselMetadataInSvg, extractWeaselClipboardFromSvg, parseWeaselClipboardText, sniffWeaselClipboardText, useClipboardOps };
+export { type ClipboardFlavors, type UseClipboardOpsOptions, type UseClipboardOpsReturn, WEASEL_CLIPBOARD_MIME, WEASEL_CLIPBOARD_MIME_WEB, buildWeaselClipboardText, embedWeaselMetadataInSvg, extractWeaselClipboardFromSvg, parseWeaselClipboardText, sniffWeaselClipboardText, useClipboardOps };

package/dist/clipboard.js

@@ -1,5 +1,3 @@
-export { WEASEL_CLIPBOARD_MIME, WEASEL_CLIPBOARD_MIME_WEB, buildWeaselClipboardText, embedWeaselMetadataInSvg, extractWeaselClipboardFromSvg, parseWeaselClipboardText, sniffWeaselClipboardText, useClipboardOps } from './chunk-WPNA6L5O.js';
-import './chunk-UPZY4ART.js';
-import './chunk-NE27EOLP.js';
-//# sourceMappingURL=clipboard.js.map
-//# sourceMappingURL=clipboard.js.map
+import { WEASEL_CLIPBOARD_MIME as e, WEASEL_CLIPBOARD_MIME_WEB as t, buildWeaselClipboardText as n, embedWeaselMetadataInSvg as r, extractWeaselClipboardFromSvg as i, parseWeaselClipboardText as a, sniffWeaselClipboardText as o } from "./interactions/actions/clipboard/wireFormat.js";
+import { useClipboardOps as s } from "./interactions/actions/clipboard/clipboardOps.js";
+export { e as WEASEL_CLIPBOARD_MIME, t as WEASEL_CLIPBOARD_MIME_WEB, n as buildWeaselClipboardText, r as embedWeaselMetadataInSvg, i as extractWeaselClipboardFromSvg, a as parseWeaselClipboardText, o as sniffWeaselClipboardText, s as useClipboardOps };

package/dist/clone.d.ts

@@ -1,7 +1,7 @@
-import { C as CloneBehavior } from './types-qYpyTAiZ.js';
+import { C as CloneBehavior } from './types-B_9g6hMM.js';
+import './types-A37hYkeR.js';
 import '@weasel-js/history';
-import './types-D-9QWBy5.js';
-import './path-JEV2c5If.js';
+import '@weasel-js/geom';
 import '@weasel-js/routing';
 
 /** Clone-on-alt-drag behavior for `useClone`; activates when Alt/Option is held at drag start. */

package/dist/clone.js

@@ -1,5 +1,2 @@
-export { cloneByAltDrag } from './chunk-M24CLARN.js';
-import './chunk-UPZY4ART.js';
-import './chunk-NE27EOLP.js';
-//# sourceMappingURL=clone.js.map
-//# sourceMappingURL=clone.js.map
+import { cloneByAltDrag as e } from "./interactions/actions/clone/behaviors/cloneByAltDrag.js";
+export { e as cloneByAltDrag };

package/dist/core/adapters/arrayAdapter.js

@@ -0,0 +1,85 @@
+import { RECT_POSE_DESCRIPTOR as e, poseDescriptorForNode as t, translatePoseViaDescriptor as n } from "../geometry/poseDescriptor.js";
+import { applyOpsTo as r } from "../applyOps.js";
+import { polygonRegion as i, poseOutline as a, rectRegion as o, regionBoundsOf as s, regionTakes as c } from "../geometry/regionHit.js";
+//#region src/core/adapters/arrayAdapter.ts
+function l(e, t) {
+	return {
+		...e,
+		...t
+	};
+}
+var u = 0;
+function d() {
+	let e = globalThis.crypto;
+	return e && typeof e.randomUUID == "function" ? e.randomUUID() : `paste-${u++}`;
+}
+function f(u) {
+	let { ref: f, setItems: p, toPose: m, fromPose: h = l, getParent: g = () => null, setParent: _ = () => {}, getChildren: v, selectionRef: y, setSelection: b = () => {}, createDefault: x, nextId: S = d, silhouette: C } = u, w = u.poseDescriptor ?? e, T = y ? () => y.current : () => [], E = (e, n) => {
+		let r = [];
+		for (let i of f.current) {
+			let o = m(i), l = s(i, o, t(w, i));
+			c(e, n, o, l, () => C?.(i, o) ?? a(o, l)) && r.push(i.id);
+		}
+		return r;
+	}, D = {
+		getNode: (e) => f.current.find((t) => t.id === e),
+		getNodes: () => f.current,
+		getPose: (e) => {
+			let t = f.current.find((t) => t.id === e);
+			if (!t) throw Error(`arrayAdapter.getPose: id "${e}" not found`);
+			return m(t);
+		},
+		setPose: (e, t) => {
+			p((n) => n.map((n) => n.id === e ? h(n, t) : n));
+		},
+		getParent: g,
+		setParent: _,
+		insertNode: (e, t) => p((n) => t === void 0 || t < 0 || t >= n.length ? [...n, e] : [
+			...n.slice(0, t),
+			e,
+			...n.slice(t)
+		]),
+		removeNode: (e) => p((t) => t.filter((t) => t.id !== e)),
+		getSelection: T,
+		setSelection: b,
+		hitTestArea: (e) => E(o(e), "intersect"),
+		hitTestLasso: (e, t) => {
+			let n = i(e);
+			return n ? E(n, t) : [];
+		},
+		applyOps(e) {
+			r(this, e);
+		},
+		commitInsert: x ? (e) => x(e) : () => null,
+		commitPaste: (e, r, i) => {
+			let a = e.items;
+			if (a.length === 0) return [];
+			let o = r.dx, s = r.dy;
+			if (i?.dropPoint) {
+				let e = Infinity, n = Infinity, r = -Infinity, c = -Infinity;
+				for (let i of a) {
+					let a = t(w, i).getBounds(m(i));
+					a.x < e && (e = a.x), a.y < n && (n = a.y), a.x + a.width > r && (r = a.x + a.width), a.y + a.height > c && (c = a.y + a.height);
+				}
+				if (Number.isFinite(e) && Number.isFinite(n)) {
+					let t = (e + r) / 2, a = (n + c) / 2;
+					o = i.dropPoint.worldX - t, s = i.dropPoint.worldY - a;
+				}
+			}
+			let c = [];
+			for (let e of a) {
+				let r = JSON.parse(JSON.stringify(e));
+				r.id = S();
+				let i = n(m(r), o, s, t(w, r));
+				c.push(h(r, i));
+			}
+			return c;
+		},
+		snapshotSelection: (e) => ({ items: e.map((e) => f.current.find((t) => t.id === e)).filter((e) => !!e) })
+	};
+	return v && (D.getChildren = (e) => e === null ? f.current.filter((e) => g(e.id) === null).map((e) => e.id) : v(e) ?? []), D;
+}
+//#endregion
+export { f as arrayAdapter };
+
+//# sourceMappingURL=arrayAdapter.js.map

package/dist/core/adapters/arrayAdapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrayAdapter.js","names":["defaultFromPose","obj","pose","monotonicPasteCounter","defaultNextId","c","arrayAdapter","config","d","RECT_POSE_DESCRIPTOR","getSelection","selectionRef","takenBy","out","o","ref","toPose","b","regionBoundsOf","poseDescriptorForNode","regionTakes","region","mode","silhouette","poseOutline","adapter","id","items","fromPose","setItems","index","rectRegion","rect","polygonRegion","polygon","ops","createDefault","src","clip","dx","offset","dy","ctx","minX","minY","maxX","maxY","n","cx","cy","cloned","nextId","translated","translatePoseViaDescriptor","ids","getChildren","parentId","getParent"],"sources":["../../../src/core/adapters/arrayAdapter.ts"],"sourcesContent":["import type { MutableRefObject } from 'react';\nimport type {\n  AreaSelectAdapter,\n  InsertAdapter,\n  LassoHitMode,\n  LassoSelectAdapter,\n  MoveAdapter,\n  ResizeAdapter,\n} from './types';\nimport type { Op } from '../ops/types';\nimport { applyOpsTo } from '../applyOps';\nimport type { Bounds } from '../viewport/fitViewToBounds';\nimport type { ClipboardSnapshot } from './types';\nimport {\n  poseDescriptorForNode,\n  translatePoseViaDescriptor,\n  RECT_POSE_DESCRIPTOR,\n  type PoseDescriptor,\n} from 'core/geometry/poseDescriptor';\nimport type { Path } from '@weasel-js/geom';\nimport {\n  polygonRegion,\n  poseOutline,\n  rectRegion,\n  regionBoundsOf,\n  regionTakes,\n  type SelectRegion,\n} from 'core/geometry/regionHit';\n\n/** Configuration for `arrayAdapter`. */\nexport interface ArrayAdapterConfig<TNode extends { id: string }, TPose> {\n  /** Live ref to the current array. */\n  ref: MutableRefObject<TNode[]>;\n  /** Functional setter (typically the second value from `useState`). */\n  setItems: (updater: (items: TNode[]) => TNode[]) => void;\n  /** Project an object to its pose. Required. */\n  toPose: (obj: TNode) => TPose;\n  /** Merge a new pose back into an object. Default: shallow spread. */\n  fromPose?: (obj: TNode, pose: TPose) => TNode;\n  /** Optional parent lookup. Default returns `null`. */\n  getParent?: (id: string) => string | null;\n  /** Optional reparent mutator. Default is a noop. */\n  setParent?: (id: string, parentId: string | null) => void;\n  /** Optional children lookup for a node id. The adapter answers the root\n   *  itself, from `ref` and `getParent` in array order, so this is never\n   *  called with `null`. Default omits the method entirely. */\n  getChildren?: (id: string) => string[] | undefined;\n\n  /** Live ref to the current selection. Default: empty array. */\n  selectionRef?: MutableRefObject<string[]>;\n  /** Selection setter. Default: noop. */\n  setSelection?: (ids: string[]) => void;\n\n  /** Factory for `commitInsert` — invoked at the end of an insert drag.\n   *  Consumers own id generation and any palette/payload fields. Returning\n   *  `null` aborts the insert. When omitted, `commitInsert` returns `null`. */\n  createDefault?: (bounds: Bounds) => TNode | null;\n\n  /** How to read and rewrite item poses. Default `RECT_POSE_DESCRIPTOR`,\n   *  which reads the pose as its own AABB — the canonical axis-aligned rect\n   *  pose. `AUTO_POSE_DESCRIPTOR` lives above `core/` and so cannot be the\n   *  default here; pass it for a scene whose poses may be Paths. */\n  poseDescriptor?: PoseDescriptor<TPose>;\n\n  /** The outline a node draws, for marquee and lasso, in world coordinates.\n   *  Return `null` where the pose says it all. Default: none — a polygon pose\n   *  is its own outline, and anything else is its pose rect, rotated by\n   *  `rotation`. The kit's painters live above `core/`, so a scene whose\n   *  nodes they draw passes `findShapeSilhouette` to be tested as drawn. */\n  silhouette?: (node: TNode, pose: TPose) => Path | null;\n\n  /** Factory for fresh node ids in `commitPaste`. Default: `crypto.randomUUID()`\n   *  when available, otherwise a monotonic `paste-<n>` counter. Override\n   *  when consumers want stable id schemes (e.g. `clip-${n++}`). */\n  nextId?: () => string;\n}\n\n/**\n * Combined adapter satisfying every narrow adapter the kit ships. Methods\n * with no default implementation (e.g. `commitInsert` without\n * `createDefault`) return null/[]/noop — sufficient to typecheck against\n * `InsertAdapter`/`AreaSelectAdapter`, and the corresponding gesture hook\n * simply produces no commit.\n */\nexport interface ArrayAdapter<TNode extends { id: string }, TPose>\n  extends MoveAdapter<TNode, TPose>,\n    ResizeAdapter<TNode, TPose>,\n    InsertAdapter<TNode>,\n    AreaSelectAdapter,\n    LassoSelectAdapter {\n  getNodes(): TNode[];\n  removeNode(id: string): void;\n  // ArrayAdapter satisfies the union of all narrow adapters; redeclare the\n  // methods that are optional on AreaSelectAdapter (post-relaxation) but\n  // required on InsertAdapter so TS sees a single non-conflicting signature.\n  getSelection(): string[];\n  setSelection(ids: string[]): void;\n  // Redeclare applyOps with an optional label so it's compatible with both\n  // MoveAdapter (label required) and AreaSelectAdapter (label absent = transient).\n  applyOps?(ops: Op[], label?: string): void;\n}\n\nfunction defaultFromPose<TNode extends { id: string }, TPose>(\n  obj: TNode,\n  pose: TPose,\n): TNode {\n  return { ...obj, ...(pose as object) } as TNode;\n}\n\nlet monotonicPasteCounter = 0;\nfunction defaultNextId(): string {\n  const c = (globalThis as { crypto?: { randomUUID?: () => string } }).crypto;\n  if (c && typeof c.randomUUID === 'function') return c.randomUUID();\n  return `paste-${monotonicPasteCounter++}`;\n}\n\n/**\n * Synthesize a many-faceted adapter from a `useState`-array scene. Always\n * satisfies `MoveAdapter`, `ResizeAdapter`, `InsertAdapter`, and\n * `AreaSelectAdapter` via structural typing. Override individual methods by\n * spreading the result.\n *\n * `applyOps` is intentionally omitted — hooks fall back to the built-in\n * dispatcher (see `dispatchApplyBatch`). Apps with custom history\n * integration supply their own via spread.\n */\nexport function arrayAdapter<TNode extends { id: string }, TPose>(\n  config: ArrayAdapterConfig<TNode, TPose>,\n): ArrayAdapter<TNode, TPose> {\n  const {\n    ref,\n    setItems,\n    toPose,\n    fromPose = defaultFromPose,\n    getParent = () => null,\n    setParent = () => {},\n    getChildren,\n    selectionRef,\n    setSelection = () => {},\n    createDefault,\n    nextId = defaultNextId,\n    silhouette,\n  } = config;\n\n  const d = (config.poseDescriptor ?? RECT_POSE_DESCRIPTOR) as PoseDescriptor<TPose>;\n\n  const getSelection = selectionRef ? () => selectionRef.current : () => [];\n\n  const takenBy = (region: SelectRegion, mode: LassoHitMode): string[] => {\n    const out: string[] = [];\n    for (const o of ref.current) {\n      const pose = toPose(o);\n      const b = regionBoundsOf(o, pose, poseDescriptorForNode(d, o) as PoseDescriptor<unknown>);\n      const outline = (): Path => silhouette?.(o, pose) ?? poseOutline(pose, b);\n      if (regionTakes(region, mode, pose, b, outline)) out.push(o.id);\n    }\n    return out;\n  };\n\n  const adapter: ArrayAdapter<TNode, TPose> = {\n    getNode: (id) => ref.current.find((o) => o.id === id),\n    getNodes: () => ref.current,\n    getPose: (id) => {\n      const obj = ref.current.find((o) => o.id === id);\n      if (!obj) throw new Error(`arrayAdapter.getPose: id \"${id}\" not found`);\n      return toPose(obj);\n    },\n    setPose: (id, pose) => {\n      setItems((items) => items.map((o) => (o.id === id ? fromPose(o, pose) : o)));\n    },\n    getParent,\n    setParent,\n\n    insertNode: (obj, index) => setItems((items) => {\n      if (index === undefined || index < 0 || index >= items.length) return [...items, obj];\n      return [...items.slice(0, index), obj, ...items.slice(index)];\n    }),\n    removeNode: (id) => setItems((items) => items.filter((o) => o.id !== id)),\n\n    getSelection,\n    setSelection,\n\n    hitTestArea: (rect) => takenBy(rectRegion(rect), 'intersect'),\n\n    hitTestLasso: (polygon, mode: LassoHitMode) => {\n      const region = polygonRegion(polygon);\n      return region ? takenBy(region, mode) : [];\n    },\n\n    // Use a method shorthand so `this` is the call-site receiver, not the\n    // adapter we're building here. That way consumers can spread additional\n    // methods on top (e.g. `{ ...arrayAdapter(...), ...selection.adapterMethods }`)\n    // and `applyOps` will dispatch ops against the merged object.\n    applyOps(ops: Op[]) {\n      applyOpsTo(this, ops);\n    },\n\n    commitInsert: createDefault ? (b) => createDefault(b) : () => null,\n    commitPaste: (\n      clip: ClipboardSnapshot,\n      offset: { dx: number; dy: number },\n      ctx?: { dropPoint?: { worldX: number; worldY: number } },\n    ): TNode[] => {\n      const src = clip.items as TNode[];\n      if (src.length === 0) return [];\n\n      // Default translation = `offset`. When `dropPoint` is supplied, center\n      // the cluster's union AABB at the drop point — matches the\n      // `ClipboardDemo` reference wiring.\n      let dx = offset.dx;\n      let dy = offset.dy;\n      if (ctx?.dropPoint) {\n        let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;\n        for (const n of src) {\n          const b = poseDescriptorForNode(d, n).getBounds(toPose(n));\n          if (b.x < minX) minX = b.x;\n          if (b.y < minY) minY = b.y;\n          if (b.x + b.width > maxX) maxX = b.x + b.width;\n          if (b.y + b.height > maxY) maxY = b.y + b.height;\n        }\n        // Defensive: if the descriptor returned nothing usable, fall back to offset.\n        if (Number.isFinite(minX) && Number.isFinite(minY)) {\n          const cx = (minX + maxX) / 2;\n          const cy = (minY + maxY) / 2;\n          dx = ctx.dropPoint.worldX - cx;\n          dy = ctx.dropPoint.worldY - cy;\n        }\n      }\n\n      // Deep-clone via JSON round-trip so the snapshot isn't mutated by\n      // downstream pose edits.\n      const out: TNode[] = [];\n      for (const n of src) {\n        const cloned = JSON.parse(JSON.stringify(n)) as TNode;\n        (cloned as { id: string }).id = nextId();\n        const translated = translatePoseViaDescriptor(\n          toPose(cloned), dx, dy, poseDescriptorForNode(d, cloned),\n        );\n        out.push(fromPose(cloned, translated));\n      }\n      return out;\n    },\n    snapshotSelection: (ids) => ({\n      items: ids\n        .map((id) => ref.current.find((o) => o.id === id))\n        .filter((o): o is TNode => !!o),\n    }),\n  };\n\n  if (getChildren) {\n    (adapter as ArrayAdapter<TNode, TPose> & {\n      getChildren: (parentId: string | null) => string[];\n    }).getChildren = (parentId) => {\n      // Root order is the item array's order, which this adapter owns — asking\n      // the consumer would get a callback written for node ids, and its `[]`\n      // is indistinguishable from \"the root has no children\".\n      if (parentId === null) {\n        return ref.current.filter((o) => getParent(o.id) === null).map((o) => o.id);\n      }\n      return getChildren(parentId) ?? [];\n    };\n  }\n\n  return adapter;\n}\n"],"mappings":"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"}

package/dist/core/adapters/useArrayAdapter.js

@@ -0,0 +1,13 @@
+import { arrayAdapter as e } from "./arrayAdapter.js";
+//#region src/core/adapters/useArrayAdapter.ts
+function t(t) {
+	let { items: n, ...r } = t;
+	return e({
+		ref: { current: n },
+		...r
+	});
+}
+//#endregion
+export { t as useArrayAdapter };
+
+//# sourceMappingURL=useArrayAdapter.js.map

package/dist/core/adapters/useArrayAdapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useArrayAdapter.js","names":["useArrayAdapter","rest","options","arrayAdapter","items"],"sources":["../../../src/core/adapters/useArrayAdapter.ts"],"sourcesContent":["import { arrayAdapter, type ArrayAdapter, type ArrayAdapterConfig } from './arrayAdapter';\n\n/** Options for `useArrayAdapter` — same shape as `ArrayAdapterConfig` minus the\n *  `ref` field, which the hook manages internally from `items`. */\nexport type UseArrayAdapterOptions<TNode extends { id: string }, TPose> =\n  Omit<ArrayAdapterConfig<TNode, TPose>, 'ref' | 'setItems'> & {\n    items: TNode[];\n    setItems: ArrayAdapterConfig<TNode, TPose>['setItems'];\n  };\n\n/** Hook wrapper around `arrayAdapter` over this render's `items`. Eliminates\n *  the `useRef + ref.current = items` boilerplate every flat-list scene needs.\n *  Returns a fresh adapter each render, reading that render's items — so an\n *  adapter a render reads from sees its own items, and the gesture hooks, which\n *  hold the latest committed adapter, see the committed ones. */\nexport function useArrayAdapter<TNode extends { id: string }, TPose>(\n  options: UseArrayAdapterOptions<TNode, TPose>,\n): ArrayAdapter<TNode, TPose> {\n  const { items, ...rest } = options;\n  return arrayAdapter<TNode, TPose>({ ref: { current: items }, ...rest });\n}\n"],"mappings":";;AAeA,SAAgBA,EACd,GAC4B;CAC5B,IAAM,EAAE,UAAO,GAAGC,MAASC;CAC3B,OAAOC,EAA2B;EAAE,KAAK,EAAE,SAASC,EAAM;EAAG,GAAGH;CAAK,CAAC;AACxE"}

package/dist/core/applyOps.js

@@ -0,0 +1,12 @@
+//#region src/core/applyOps.ts
+function e(e, t, n) {
+	for (let n of t) n.apply(e);
+}
+function t(t, n, r) {
+	let i = t;
+	i.applyOps ? i.applyOps(n, r) : e(t, n, r);
+}
+//#endregion
+export { e as applyOpsTo, t as dispatchApplyBatch };
+
+//# sourceMappingURL=applyOps.js.map

package/dist/core/applyOps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"applyOps.js","names":["applyOpsTo","op","ops","adapter","dispatchApplyBatch","a","label"],"sources":["../../src/core/applyOps.ts"],"sourcesContent":["import type { Op } from './ops/types';\n\n/**\n * Default `applyOps` implementation: apply each op in order against\n * `adapter`. Used by hooks when an adapter omits `applyOps`. Apps that\n * need history integration (checkpoint + push entry) supply their own\n * `applyOps` instead.\n *\n * The `_label` parameter mirrors the `applyOps(ops, label)` signature so\n * call-sites can dispatch through `(adapter.applyOps ?? applyOpsTo)` with\n * matching arguments. The default ignores it.\n */\nexport function applyOpsTo<A>(adapter: A, ops: Op[], _label?: string): void {\n  for (const op of ops) op.apply(adapter);\n}\n\n/**\n * Dispatcher: invokes `adapter.applyOps` if present, otherwise falls back\n * to `applyOpsTo`. Convenience for hooks so they don't repeat the\n * `?? applyOpsTo` pattern at every call site.\n */\nexport function dispatchApplyBatch<A>(\n  adapter: A,\n  ops: Op[],\n  label?: string,\n): void {\n  const a = adapter as { applyOps?: (ops: Op[], label?: string) => void };\n  if (a.applyOps) a.applyOps(ops, label);\n  else applyOpsTo(adapter, ops, label);\n}\n"],"mappings":";AAYA,SAAgBA,EAAc,GAAY,GAAW,GAAuB;CAC1E,KAAK,IAAMC,KAAMC,GAAK,EAAG,MAAMC,CAAO;AACxC;AAOA,SAAgBC,EACd,GACA,GACA,GACM;CACN,IAAMC,IAAIF;CACV,AAAIE,EAAE,WAAUA,EAAE,SAASH,GAAKI,CAAK,IAChCN,EAAWG,GAASD,GAAKI,CAAK;AACrC"}

package/dist/core/device/index.js

@@ -0,0 +1,4 @@
+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 };

package/dist/core/device/targets.js

@@ -0,0 +1,17 @@
+//#region src/core/device/targets.ts
+var e = {
+	handle: 8,
+	anchor: 8,
+	rotationDistance: 24
+}, t = e.handle, n = e.anchor, r = e.rotationDistance;
+function i(t = 1) {
+	return {
+		handle: e.handle * t,
+		anchor: e.anchor * t,
+		rotationDistance: e.rotationDistance * t
+	};
+}
+//#endregion
+export { n as ANCHOR_HIT_BASE_PX, t as HANDLE_BASE_PX, r as ROTATION_HANDLE_BASE_PX, i as targetSizesPx };
+
+//# sourceMappingURL=targets.js.map

package/dist/core/device/targets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"targets.js","names":["BASE_PX","HANDLE_BASE_PX","ANCHOR_HIT_BASE_PX","ROTATION_HANDLE_BASE_PX","targetSizesPx","targetScale"],"sources":["../../../src/core/device/targets.ts"],"sourcesContent":["/**\n * Base sizes for grabbable chrome, in CSS pixels at `targetScale = 1`, and the\n * one accessor that resolves them for a live pointer type.\n *\n * Paint and hit-test MUST scale together: chrome you can see but cannot grab\n * is the exact failure `chrome-caps` exists to make impossible, and a literal\n * `8` copied into a fifth file is how that failure gets reintroduced. So every\n * kit-internal use site goes through {@link targetSizesPx} — the selection\n * overlay's handle size, `buildAffordanceAt`'s hit radii, and the slops debug\n * overlay all read the same object. The bare constants below stay exported for\n * consumers, who get the unscaled numbers they always got.\n */\n\nconst BASE_PX = {\n  handle: 8,\n  anchor: 8,\n  rotationDistance: 24,\n} as const;\n\n/** Selection corner-handle visual size and hit radius. */\nexport const HANDLE_BASE_PX = BASE_PX.handle;\n\n/** Path anchor / control-point hit radius. */\nexport const ANCHOR_HIT_BASE_PX = BASE_PX.anchor;\n\n/** Distance from a selection's top edge to the rotation handle's center. */\nexport const ROTATION_HANDLE_BASE_PX = BASE_PX.rotationDistance;\n\n/** Grabbable-chrome sizes resolved for one pointer type, in CSS pixels. */\nexport interface TargetSizesPx {\n  /** Corner-handle visual size and hit radius. */\n  handle: number;\n  /** Anchor / control-point hit radius. */\n  anchor: number;\n  /** Distance from a selection's top edge to the rotation handle's center,\n   *  which is also the rotate band's minimum thickness. */\n  rotationDistance: number;\n}\n\n/**\n * How big is grabbable chrome, in CSS pixels, for this pointer type?\n *\n * `targetScale` comes from the live {@link DeviceProfile} — 1 for a mouse,\n * {@link COARSE_TARGET_SCALE} for touch.\n */\nexport function targetSizesPx(targetScale = 1): TargetSizesPx {\n  return {\n    handle: BASE_PX.handle * targetScale,\n    anchor: BASE_PX.anchor * targetScale,\n    rotationDistance: BASE_PX.rotationDistance * targetScale,\n  };\n}\n"],"mappings":";AAaA,IAAMA,IAAU;CACd,QAAQ;CACR,QAAQ;CACR,kBAAkB;AACpB,GAGaC,IAAiBD,EAAQ,QAGzBE,IAAqBF,EAAQ,QAG7BG,IAA0BH,EAAQ;AAmB/C,SAAgBI,EAAc,IAAc,GAAkB;CAC5D,OAAO;EACL,QAAQJ,EAAQ,SAASK;EACzB,QAAQL,EAAQ,SAASK;EACzB,kBAAkBL,EAAQ,mBAAmBK;CAC/C;AACF"}