@weasel-js/core 1.10.0 → 1.11.0

package/dist/canvas/SceneCanvas/GestureDispatcherMounter.js

@@ -1,126 +0,0 @@
-import { EMPTY_CHROME_STATE as e } from "../../core/selection/chromeState.js";
-import { anchorStateFrom as t, buildAffordanceAt as n, buildClassifyTarget as r, chromeAffordances as i, layerAffordance as a } from "../affordanceAt.js";
-import { pathFromPlane as o } from "../planeClips.js";
-import { useOptionalViewRegistry as s } from "../viewRegistry.js";
-import { traceConversion as c } from "./coordTrace.js";
-import { useCallback as l, useInsertionEffect as ee, useMemo as u, useState as d } from "react";
-import { useLatest as f } from "@weasel-js/react";
-import { createLongPressStore as p } from "@weasel-js/routing";
-import { useActionsRegistry as te, useDepRegistry as m, useDepSource as h, useGestureDispatcher as g } from "@weasel-js/routing/react";
-//#region src/canvas/SceneCanvas/GestureDispatcherMounter.tsx
-function _({ canvasRef: _, canvasApiRef: v, tools: y, contributions: b, enabled: ne, keyboard: x, claimKeys: S, selectionRef: C, boundsOf: w, planeOfNode: T, pickEvery: E, pickBest: D, kindOfNode: O, viewRef: k, dispatcher: A, getIsVisibleForCanvas: j, getRuleCtx: re, targetScale: M, handleHitRadius: N, rotationBadge: P, chromeAffordancesRef: F, onDoubleClick: I, onClick: L, longPress: { duration: R, haptics: z } = {} }) {
-	let B = te(), V = m(), H = s(), U = u(() => {
-		let e = /* @__PURE__ */ new Map();
-		for (let [t, n] of Object.entries(y.registry)) e.set(t, n);
-		for (let t of b) e.set(t.id, t);
-		for (let t of y.ambient) e.set(t.id, t);
-		return e;
-	}, [
-		y.registry,
-		y.ambient,
-		b
-	]), W = f(E), G = f(D), K = f(O), q = f(V), J = f(T), Y = u(() => t(() => q.current, (e, t) => o(t, J.current?.(e) ?? null)), [q, J]), X = u(() => i({
-		...M === void 0 ? {} : { targetScale: M },
-		...N === void 0 ? {} : { handleHitRadius: N },
-		rotationBadge: P,
-		getAnchorState: Y
-	}), [
-		M,
-		N,
-		P,
-		Y
-	]);
-	ee(() => {
-		F && (F.current = X);
-	});
-	let Z = u(() => {
-		if (C && w && k) return n({
-			getChromeState: () => H?.surface()?.chromeState() ?? e,
-			getView: () => k.current ?? {
-				x: 0,
-				y: 0,
-				scale: {
-					x: 1,
-					y: 1
-				}
-			},
-			affordances: X,
-			...j ? { getIsVisible: () => j() } : {}
-		});
-	}, [
-		C,
-		w,
-		k,
-		X,
-		j,
-		H
-	]), ie = u(() => {
-		if (C && E && k) return r(() => C.current?.current ?? [], (e, t) => {
-			if (G.current) return G.current(e, t);
-			let n = W.current?.(e, t) ?? [];
-			return n.length > 0 ? n[n.length - 1] : null;
-		}, (e) => K.current?.(e));
-	}, [
-		C,
-		E,
-		k,
-		G,
-		W,
-		K
-	]), ae = l((e, t) => {
-		let n = v.current, [r, i] = n ? n.clientToWorld(e, t) : [e, t], a = {
-			x: r,
-			y: i
-		};
-		return c(e, t, n ? _.current : null, k?.current, a), a;
-	}, [
-		_,
-		v,
-		k
-	]), oe = u(() => (e) => {
-		let t = v.current?.hitTestExtras?.(e.x, e.y);
-		return t ? a(t.layerId, t.hit) : Z ? Z(e) : null;
-	}, [Z, v]), se = l(() => {
-		v.current?.requestRedraw?.();
-	}, [v]), ce = l(() => v.current?.paintedCursor, [v]), le = l(() => v.current?.cursorSink, [v]), [Q] = d(p), ue = u(() => ({
-		state: Q,
-		...R === void 0 ? {} : { duration: R },
-		...z === void 0 ? {} : { haptics: z }
-	}), [
-		Q,
-		R,
-		z
-	]), $ = u(() => {
-		if (H) return {
-			targets: () => H.list().map((e) => ({
-				id: e.id,
-				...e.target
-			})),
-			resolver: H.resolver
-		};
-	}, [H]);
-	return g({
-		canvasRef: _,
-		actions: B,
-		entriesById: U,
-		enabled: ne,
-		keyboard: x,
-		claimKeys: S,
-		affordanceAt: oe,
-		classifyTarget: ie,
-		dispatcher: A,
-		clientToWorld: ae,
-		requestRedraw: se,
-		paintedCursor: ce,
-		cursorSink: le,
-		getRuleCtx: re,
-		onClick: L,
-		onDoubleClick: I,
-		longPress: ue,
-		...$ ? { views: $ } : {}
-	}), h("longPress", () => Q), null;
-}
-//#endregion
-export { _ as GestureDispatcherMounter };
-
-//# sourceMappingURL=GestureDispatcherMounter.js.map

package/dist/canvas/SceneCanvas/GestureDispatcherMounter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"GestureDispatcherMounter.js","names":["GestureDispatcherMounter","longPressDuration","longPressHaptics","registry","useActionsRegistry","depRegistry","useDepRegistry","viewRegistry","useOptionalViewRegistry","entriesById","useMemo","m","id","tool","tools","entry","contributions","pickEveryRef","useLatest","pickEvery","pickBestRef","pickBest","kindOfNodeRef","kindOfNode","depRegistryRef","planeOfNodeRef","planeOfNode","getAnchorState","anchorStateFrom","pathFromPlane","path","affordances","chromeAffordances","targetScale","handleHitRadius","rotationBadge","chromeAffordancesRef","affordanceAt","selectionRef","boundsOf","viewRef","buildAffordanceAt","EMPTY_CHROME_STATE","getIsVisibleForCanvas","classifyTarget","buildClassifyTarget","wx","wy","ids","clientToWorld","useCallback","api","canvasApiRef","x","y","clientX","clientY","world","traceConversion","canvasRef","affordanceWithLayers","extra","worldPoint","layerAffordance","requestRedraw","paintedCursor","cursorSink","longPressState","useState","createLongPressStore","longPress","views","r","useGestureDispatcher","useDepSource"],"sources":["../../../src/canvas/SceneCanvas/GestureDispatcherMounter.tsx"],"sourcesContent":["import { useLatest } from '@weasel-js/react';\nimport { createLongPressStore, type Dispatcher } from '@weasel-js/routing';\nimport { useActionsRegistry, useDepRegistry, useDepSource, useGestureDispatcher } from '@weasel-js/routing/react';\nimport type { Affordance } from 'affordances/types';\nimport { EMPTY_CHROME_STATE } from 'core/selection/chromeState';\nimport type { View } from 'core/viewport/view';\nimport type { RuleCtx } from 'features/chrome-caps';\nimport type React from 'react';\nimport { useCallback, useInsertionEffect, useMemo, useState } from 'react';\nimport type { Contribution } from '../../tools/overlayBinding';\nimport type { ToolsApi } from '../../tools/overlayBinding';\nimport { anchorStateFrom, buildAffordanceAt, buildClassifyTarget, chromeAffordances, layerAffordance } from '../affordanceAt';\nimport type { CanvasExtensionApi } from '../canvasExtension';\nimport { pathFromPlane } from '../planeClips';\nimport { useOptionalViewRegistry } from '../viewRegistry';\nimport { traceConversion } from './coordTrace';\nimport type { SceneCanvasLongPress } from './props';\n\nexport function GestureDispatcherMounter({\n  canvasRef,\n  canvasApiRef,\n  tools,\n  contributions,\n  enabled,\n  keyboard,\n  claimKeys,\n  selectionRef,\n  boundsOf,\n  planeOfNode,\n  pickEvery,\n  pickBest,\n  kindOfNode,\n  viewRef,\n  dispatcher,\n  getIsVisibleForCanvas,\n  getRuleCtx,\n  targetScale,\n  handleHitRadius,\n  rotationBadge,\n  chromeAffordancesRef,\n  onDoubleClick,\n  onClick,\n  longPress: { duration: longPressDuration, haptics: longPressHaptics } = {},\n}: {\n  canvasRef: React.RefObject<HTMLElement | null>;\n  /** Holds the full `CanvasExtensionApi` so the gesture dispatcher can call\n   *  `requestRedraw()` between pointer events. */\n  canvasApiRef: React.RefObject<CanvasExtensionApi | null>;\n  tools: ToolsApi;\n  /** Always-live entries the canvas installs beside `tools` — the selection's\n   *  `move` / `transform` bindings. Ahead of the tools' ambient entries, so a\n   *  tie at one specificity goes to the kit's. */\n  contributions: readonly Contribution[];\n  enabled: boolean;\n  /** When false, the dispatcher leaves keyboard listeners unattached so\n   *  keyboard-bound actions never fire. Wired to `enableKeybindings`. */\n  keyboard: boolean;\n  /** Take the keyboard on mount. Wired to `claimKeys`. */\n  claimKeys: boolean;\n  selectionRef?: React.RefObject<import('core/selection/useSelection').SelectionApi>;\n  boundsOf?: (id: string) => import('core/viewport/fitViewToBounds').Bounds | null;\n  /** The parallax plane a node is drawn through, under the surface's camera —\n   *  so path anchors are hit where the plane draws them. */\n  planeOfNode?: (id: string) => import('core/viewport/parallax').PlaneMap | null;\n  pickEvery?: (worldX: number, worldY: number) => string[];\n  /** Single topmost hit (collapses parent/child via `pickTopMostHit`), used to\n   *  classify the body under the pointer. Must match the select tool's own\n   *  resolution so a child node isn't misclassified by its parent's selection.\n   *  Falls back to `pickEvery`'s last id when absent. */\n  pickBest?: (worldX: number, worldY: number) => string | null;\n  /** Resolves a hit node id to its routing-trait kind, so the body\n   *  classification carries `kind` alongside `bodyTarget` and the\n   *  `kind:<k>` / `kind:<k>:selected` target forms can match. Absent when\n   *  the consumer opted out of routing (`routing={[]}`). */\n  kindOfNode?: (id: string) => string | undefined;\n  viewRef?: React.RefObject<View>;\n  /** Pre-created dispatcher to pump events into. When omitted,\n   *  `useGestureDispatcher` creates one internally (legacy path). */\n  dispatcher?: Dispatcher;\n  /** Chrome-caps visibility resolver factory. Threaded into\n   *  `buildAffordanceAt` so the hit-test pipeline gates corner / rotate /\n   *  anchor affordances on the same chrome ids the renderer uses. */\n  getIsVisibleForCanvas?: () => (id: string) => boolean;\n  /** Live RuleCtx factory. Threaded into `useGestureDispatcher` so the\n   *  dispatcher's eligibility filter sees the same mode/capabilities/selection\n   *  view of the world that chrome-caps does. */\n  getRuleCtx?: () => RuleCtx | undefined;\n  /** `DeviceProfile.targetScale`, so the affordance grab zones resolve to the\n   *  same sizes the chrome paints at. */\n  targetScale?: number;\n  /** Consumer override for the corner-handle grab radius\n   *  (`selectTool.handleHitRadius`). Undefined takes the device-scaled size. */\n  handleHitRadius?: number;\n  /** The rotate badge the selection overlay paints, grabbable where drawn. */\n  rotationBadge?: { distancePx: number; sizePx: number } | null;\n  /** Receives the affordances this mounter hit-tests, for the slops overlay. */\n  chromeAffordancesRef?: React.MutableRefObject<readonly Affordance[]>;\n  /** Fires on every synthesized double click, in world coords. Backs the\n   *  `onDoubleClick` prop — see the option's doc on\n   *  `UseGestureDispatcherOptions` for why it's an observer, not a binding. */\n  onDoubleClick?: (world: { x: number; y: number }) => void;\n  /** Fires after every synthesized click. Backs the `onClick` prop. */\n  onClick?: (world: { x: number; y: number }) => void;\n  /** Backs `<SceneCanvas longPress>`. */\n  longPress?: SceneCanvasLongPress;\n}) {\n  const registry = useActionsRegistry();\n  const depRegistry = useDepRegistry();\n  const viewRegistry = useOptionalViewRegistry();\n  const entriesById = useMemo<ReadonlyMap<string, Contribution>>(() => {\n    const m = new Map<string, Contribution>();\n    for (const [id, tool] of Object.entries(tools.registry)) {\n      m.set(id, tool);\n    }\n    for (const entry of contributions) m.set(entry.id, entry);\n    // Ambient entries too — their bindings assemble at ambient scope, and the\n    // dispatcher resolves them through this same map.\n    for (const entry of tools.ambient) m.set(entry.id, entry);\n    return m;\n  }, [tools.registry, tools.ambient, contributions]);\n\n\n  // Stable refs for the optional thunk inputs so the thunks themselves are\n  // stable function identities across renders (no need to pass them as deps).\n  const pickEveryRef = useLatest(pickEvery);\n  const pickBestRef = useLatest(pickBest);\n  const kindOfNodeRef = useLatest(kindOfNode);\n\n  // `getAnchorState` thunk for `buildAffordanceAt` — reads the live\n  // `editAnchors` dep from the registry at call time.\n  const depRegistryRef = useLatest(depRegistry);\n  const planeOfNodeRef = useLatest(planeOfNode);\n  const getAnchorState = useMemo(() => anchorStateFrom(\n    () => depRegistryRef.current,\n    (id, path) => pathFromPlane(path, planeOfNodeRef.current?.(id) ?? null),\n  ), [depRegistryRef, planeOfNodeRef]);\n\n  // Build the `affordanceAt` thunk. Takes world coords and delegates to\n  // `buildAffordanceAt` for handle hit-testing.\n  const affordances = useMemo(() => chromeAffordances({\n    ...(targetScale !== undefined ? { targetScale } : {}),\n    ...(handleHitRadius !== undefined ? { handleHitRadius } : {}),\n    rotationBadge,\n    getAnchorState,\n  }), [targetScale, handleHitRadius, rotationBadge, getAnchorState]);\n  useInsertionEffect(() => {\n    if (chromeAffordancesRef) chromeAffordancesRef.current = affordances;\n  });\n  const affordanceAt = useMemo(() => {\n    if (!selectionRef || !boundsOf || !viewRef) return undefined;\n    return buildAffordanceAt({\n      // The canvas's own view chrome, built once by its helpers — not a\n      // second construction here that has to agree with the painted one.\n      getChromeState: () => viewRegistry?.surface()?.chromeState() ?? EMPTY_CHROME_STATE,\n      // Radii are declared in screen pixels and converted against this view.\n      getView: () => viewRef.current ?? { x: 0, y: 0, scale: { x: 1, y: 1 } },\n      affordances,\n      // Chrome-caps resolver: keep the affordance hit-test in sync with what\n      // the renderer is actually painting. Without this, a click on a (no\n      // longer visible) resize handle position still classifies as a resize\n      // handle — e.g. an anchor drag in path-edit mode resizes the path's\n      // bounding box instead of moving the anchor.\n      ...(getIsVisibleForCanvas ? { getIsVisible: () => getIsVisibleForCanvas() } : {}),\n    });\n  }, [selectionRef, boundsOf, viewRef, affordances, getIsVisibleForCanvas, viewRegistry]);\n\n  // Build the `classifyTarget` thunk. Takes world coords and delegates to\n  // `buildClassifyTarget`.\n  const classifyTarget = useMemo(() => {\n    if (!selectionRef || !pickEvery || !viewRef) return undefined;\n    return buildClassifyTarget(\n      () => selectionRef.current?.current ?? [],\n      // Use the select tool's own topmost-hit resolution (`pickTopMostHit`,\n      // which collapses parent/child) so a child body is classified by ITS\n      // OWN selection — not its parent's.\n      (wx: number, wy: number) => {\n        if (pickBestRef.current) return pickBestRef.current(wx, wy);\n        const ids = pickEveryRef.current?.(wx, wy) ?? [];\n        return ids.length > 0 ? ids[ids.length - 1] : null;\n      },\n      // Node kind comes from the routing trait — the same classifier that\n      // names `Hit.kind` — so `target: 'kind:text'` on a binding speaks the\n      // vocabulary the consumer already declared in `routing`, rather than a\n      // second one invented for bindings. `routing={[]}` opts out and leaves\n      // every `kind:` target unmatchable.\n      (id: string) => kindOfNodeRef.current?.(id),\n    );\n  }, [selectionRef, pickEvery, viewRef, pickBestRef, pickEveryRef, kindOfNodeRef]);\n\n  // Through the handle, so a `clientToWorld` override on the canvas applies.\n  const clientToWorld = useCallback((clientX: number, clientY: number): { x: number; y: number } => {\n    const api = canvasApiRef.current;\n    const [x, y] = api ? api.clientToWorld(clientX, clientY) : [clientX, clientY];\n    const world = { x, y };\n    traceConversion(clientX, clientY, api ? canvasRef.current : null, viewRef?.current, world);\n    return world;\n  }, [canvasRef, canvasApiRef, viewRef]);\n\n  const affordanceWithLayers = useMemo(() => {\n    // Note this is NOT gated on `affordanceAt` being built: registered layers\n    // produce affordances of their own, and a consumer with no selection\n    // chrome (a canvas that is nothing but a HUD, say) still needs those.\n    return (worldPoint: { x: number; y: number }) => {\n      // Registered layers first: they draw on top of the kit's own chrome, so\n      // they get first refusal on the point. A hit becomes an `AffordanceHit`\n      // whose kind names the layer, carrying whatever the layer's hit-test\n      // resolved — which is how `@weasel-js/hud` routes a press on one of its\n      // widgets to its own action instead of the active tool.\n      const extra = canvasApiRef.current?.hitTestExtras?.(worldPoint.x, worldPoint.y);\n      if (extra) return layerAffordance(extra.layerId, extra.hit);\n      return affordanceAt ? affordanceAt(worldPoint) : null;\n    };\n  }, [affordanceAt, canvasApiRef]);\n\n  // Stable callback that asks the canvas to redraw. Reads via ref so the\n  // identity stays stable while the underlying API binds after mount.\n  const requestRedraw = useCallback(() => {\n    canvasApiRef.current?.requestRedraw?.();\n  }, [canvasApiRef]);\n\n  // The painted tier's channel, read live for the same reason — the handle it\n  // lives on binds after mount.\n  const paintedCursor = useCallback(() => canvasApiRef.current?.paintedCursor, [canvasApiRef]);\n  const cursorSink = useCallback(() => canvasApiRef.current?.cursorSink, [canvasApiRef]);\n\n  // The pending long-press, published as the `longPress` dep for feedback.\n  const [longPressState] = useState(createLongPressStore);\n  const longPress = useMemo(() => ({\n    state: longPressState,\n    ...(longPressDuration !== undefined ? { duration: longPressDuration } : {}),\n    ...(longPressHaptics !== undefined ? { haptics: longPressHaptics } : {}),\n  }), [longPressState, longPressDuration, longPressHaptics]);\n\n  // Input routing to registered views. Rebuilt per event from the registry, so\n  // a view that mounts or moves mid-session is routable on the next event; with\n  // nothing registered every point resolves to the canvas, as before.\n  const views = useMemo(() => {\n    if (!viewRegistry) return undefined;\n    return {\n      targets: () => viewRegistry.list().map((r) => ({ id: r.id, ...r.target })),\n      resolver: viewRegistry.resolver,\n    };\n  }, [viewRegistry]);\n\n  // Hover cursors live in `useGestureDispatcher`'s hover-cursor pump:\n  // affordance hits carry `AffordanceHit.cursor` (set by `buildAffordanceAt`),\n  // and everything else is predicted via `Dispatcher.resolveOnly` +\n  // `Action.cursor`. Nothing SceneCanvas-specific remains here.\n  useGestureDispatcher({\n    canvasRef,\n    actions: registry!,\n    entriesById,\n    enabled,\n    keyboard,\n    claimKeys,\n    affordanceAt: affordanceWithLayers,\n    classifyTarget,\n    dispatcher,\n    clientToWorld,\n    requestRedraw,\n    paintedCursor,\n    cursorSink,\n    getRuleCtx,\n    onClick,\n    onDoubleClick,\n    longPress,\n    ...(views ? { views } : {}),\n  });\n  useDepSource('longPress', () => longPressState);\n  return null;\n}\n"],"mappings":"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"}

package/dist/canvas/SceneCanvas/StandardActionsRegistrar.js

@@ -1,64 +0,0 @@
-import { useDecayLoop as e } from "../../core/viewport/useDecayLoop.js";
-import { useStandardActions as t } from "../../interactions/actions/useStandardActions.js";
-import { usePoseDescriptorDepSource as n } from "../deps/poseDescriptor.js";
-import { useSliceDepSource as r } from "../deps/slice.js";
-import { useLayoutArrivals as i } from "../../layout/arrivals.js";
-import { useViewDepSource as a } from "../deps/view.js";
-import { useAreaSelectDepSource as o } from "../deps/areaSelect.js";
-import { useNodeAtPointDepSource as s } from "../deps/nodeAtPoint.js";
-import { useLassoSelectDepSource as c } from "../deps/lassoSelect.js";
-import { useTextEditDepSource as l } from "../deps/textEdit.js";
-import { useEditAnchorsDepSource as u } from "../deps/editAnchors.js";
-import { useInsertDepSource as d } from "../deps/insert.js";
-import { useSnapDepSource as f } from "../deps/snap.js";
-import { useDebugDepSource as p } from "../deps/debug.js";
-import { useDepChangeNotices as m } from "../deps/changes.js";
-import { useDispatcherDepSource as h } from "../deps/dispatcher.js";
-import { useLayoutDepSource as g } from "../deps/layout.js";
-import { useIngestionDepSource as ee } from "../deps/ingestion.js";
-import { GeometryProjectionRegistrar as te, ResizePolicyRegistrar as ne } from "./poseRegistrars.js";
-import { useActionsPropResolver as re } from "./useActionsPropResolver.js";
-import { useViewportActions as ie } from "./useViewportActions.js";
-import { useEffect as _ } from "react";
-import { useActionsRegistry as v, useDepSource as y, usePointerContext as b } from "@weasel-js/routing/react";
-import { Fragment as x, jsx as S, jsxs as C } from "react/jsx-runtime";
-//#region src/canvas/SceneCanvas/StandardActionsRegistrar.tsx
-function w({ selection: w, scene: T, adapter: E, actions: D, excludeActions: O, currentViewRef: k, onViewChange: A, resizeOptions: j, poseDescriptor: M, geometryProjection: N, dispatcher: P, getActionRef: F, pickEvery: I, layerIsPainted: ae, alphaOf: L, viewportPanEnabled: R, viewportZoom: z, viewportPinchZoom: B, viewportRecenter: V, viewAnimation: H, editAnchorsExternalState: U, layouts: W, layoutDropTarget: G, reflowTransition: K, insertNodeFactories: q, insertPaint: J, snapPoint: oe, canvasRef: Y, canvasApiRef: se, ingestionResolveSrc: ce, ingestionSvg: le, ingestionClipboard: ue, actionsRegistryRef: X }) {
-	let Z = v();
-	_(() => (X.current = Z, () => {
-		X.current = null;
-	}), [Z, X]), _(() => {
-		if (Z) return Z.setDispatcher(P);
-	}, [Z, P]), _(() => {
-		if (Z) return F.current = (e) => Z.list().find((t) => t.id === e), () => {
-			F.current = null;
-		};
-	}, [Z, F]);
-	let Q = e(), $ = a(k, A, V, () => {
-		let e = Y.current;
-		return e ? {
-			width: e.clientWidth,
-			height: e.clientHeight
-		} : null;
-	}, H, Q, ae);
-	t({
-		selection: w,
-		scene: T,
-		view: $,
-		history: T.history,
-		exclude: O
-	}), y("rootView", () => $);
-	let de = b();
-	return y("pointer", () => de ?? void 0), ie({
-		pan: R,
-		zoom: z,
-		pinchZoom: B
-	}), o(T, w, M, L), s(I), g(T, W, G, K), i(T, {
-		layouts: W,
-		poseDescriptor: M
-	}), d(T, E, q, J), r(T, w, E, M), f(oe), p(se), m(T, w.current), ee(Y, () => k.current, ce, le, ue), c(T, w, M, L), l(T), u(T, w, E, U), h(P), n(M), re(D, O.join("|")), /* @__PURE__ */ C(x, { children: [j ? /* @__PURE__ */ S(ne, { options: j }) : null, N ? /* @__PURE__ */ S(te, { projection: N }) : null] });
-}
-//#endregion
-export { w as StandardActionsRegistrar };
-
-//# sourceMappingURL=StandardActionsRegistrar.js.map

package/dist/canvas/SceneCanvas/StandardActionsRegistrar.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"StandardActionsRegistrar.js","names":["_Fragment","StandardActionsRegistrar","registry","useActionsRegistry","useEffect","actionsRegistryRef","dispatcher","a","id","getActionRef","decayLoop","useDecayLoop","view","useViewDepSource","currentViewRef","onViewChange","viewportRecenter","el","canvasRef","viewAnimation","layerIsPainted","useStandardActions","scene","excludeActions","useDepSource","pointer","usePointerContext","useViewportActions","viewportPanEnabled","viewportZoom","viewportPinchZoom","useAreaSelectDepSource","selection","poseDescriptor","alphaOf","useNodeAtPointDepSource","pickEvery","useLayoutDepSource","layouts","layoutDropTarget","reflowTransition","useLayoutArrivals","useInsertDepSource","adapter","insertNodeFactories","insertPaint","useSliceDepSource","useSnapDepSource","snapPoint","useDebugDepSource","canvasApiRef","useDepChangeNotices","useIngestionDepSource","ingestionResolveSrc","ingestionSvg","ingestionClipboard","useLassoSelectDepSource","useTextEditDepSource","useEditAnchorsDepSource","editAnchorsExternalState","useDispatcherDepSource","usePoseDescriptorDepSource","useActionsPropResolver","actions","Fragment","resizeOptions","ResizePolicyRegistrar","geometryProjection","GeometryProjectionRegistrar"],"sources":["../../../src/canvas/SceneCanvas/StandardActionsRegistrar.tsx"],"sourcesContent":["import type { Action, ActionsProp, ActionsRegistry } from '@weasel-js/routing';\nimport type { Dispatcher } from '@weasel-js/routing';\nimport { useActionsRegistry, useDepSource, usePointerContext } from '@weasel-js/routing/react';\nimport type { Scene } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport { useDecayLoop } from 'core/viewport/useDecayLoop';\nimport type { ViewAnimationApi } from 'core/viewport/useViewAnimation';\nimport type { View } from 'core/viewport/view';\nimport type { PinchZoomOptions } from 'interactions/actions/defaults/pinchZoom';\nimport type { WheelPanOptions } from 'interactions/actions/defaults/viewportWheelPan';\nimport type { ViewportZoomOptions } from 'interactions/actions/defaults/viewportZoom';\nimport type { ClipboardIngestCtx, SvgIngestOptions } from 'interactions/actions/depSchema';\nimport type { GeometryProjection } from 'interactions/actions/geometryProjection';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport type { UseResizeOptions } from 'interactions/actions/resize/options';\nimport { useStandardActions } from 'interactions/actions/useStandardActions';\nimport type React from 'react';\nimport { useEffect } from 'react';\nimport { useLayoutArrivals } from '../../layout/arrivals';\nimport type { LayoutDropTargetMode, ReflowTransition } from '../../layout/types';\nimport type { CanvasExtensionApi } from '../canvasExtension';\nimport {\n  useAreaSelectDepSource,\n  useDebugDepSource,\n  useDepChangeNotices,\n  useDispatcherDepSource,\n  useEditAnchorsDepSource,\n  useIngestionDepSource,\n  useInsertDepSource,\n  useLassoSelectDepSource,\n  useLayoutDepSource,\n  useNodeAtPointDepSource,\n  usePoseDescriptorDepSource,\n  useSliceDepSource,\n  useSnapDepSource,\n  useTextEditDepSource,\n  useViewDepSource,\n  type InsertNodeFactory,\n  type InsertPaint\n} from '../deps';\nimport { GeometryProjectionRegistrar, ResizePolicyRegistrar } from './poseRegistrars';\nimport type { BridgeAdapter, SceneCanvasProps } from './props';\nimport { useActionsPropResolver } from './useActionsPropResolver';\nimport { useViewportActions } from './useViewportActions';\n\n/**\n * Registers the kit's default action set into this canvas's input scope.\n *\n * For `delete`, `duplicate`, `group`, and `ungroup` the descriptor's\n * invoker is a stub (those deps aren't in `DepSchema` yet — Phase 4 T8\n * TODO). This component registers legacy bridge overrides for them so the\n * consumer-facing `run` path is functional. The overrides land after the\n * descriptor registrations (last-writer-wins) and use the same id, so the\n * dispatcher and keybinding system see a real `run` body.\n */\nexport function StandardActionsRegistrar({\n  selection,\n  scene,\n  adapter,\n  actions,\n  excludeActions,\n  currentViewRef,\n  onViewChange,\n  resizeOptions,\n  poseDescriptor,\n  geometryProjection,\n  dispatcher,\n  getActionRef,\n  pickEvery,\n  layerIsPainted,\n  alphaOf,\n  viewportPanEnabled,\n  viewportZoom,\n  viewportPinchZoom,\n  viewportRecenter,\n  viewAnimation,\n  editAnchorsExternalState,\n  layouts,\n  layoutDropTarget,\n  reflowTransition,\n  insertNodeFactories,\n  insertPaint,\n  snapPoint,\n  canvasRef,\n  canvasApiRef,\n  ingestionResolveSrc,\n  ingestionSvg,\n  ingestionClipboard,\n  actionsRegistryRef,\n}: {\n  selection: SelectionApi;\n  scene: Scene<unknown, string, unknown>;\n  adapter: BridgeAdapter;\n  actions?: ActionsProp;\n  /** Kit-standard action ids this canvas's presets and tools leave out. */\n  excludeActions: readonly string[];\n  currentViewRef: React.RefObject<View>;\n  onViewChange: (v: View) => void;\n  /** Forwarded from `selectTool.resize` — wires the `resizePolicy` dep\n   *  consumed by the dispatcher-path `resizeAction`. The legacy\n   *  `useResizeTool` consumes the same options separately (both paths run\n   *  in parallel during the dispatcher migration). */\n  resizeOptions?: UseResizeOptions<unknown>;\n  /** Forwarded from `SceneCanvasProps.poseDescriptor` — wires the\n   *  `poseDescriptor` dep every built-in pose-touching action reads. */\n  poseDescriptor: PoseDescriptor<unknown>;\n  /** Forwarded from `SceneCanvasProps.geometryProjection` — wires the\n   *  `geometryProjection` dep consumed by pose-transform actions (move,\n   *  resize, nudge, flip). Conditionally mounted so absent → dep undefined. */\n  geometryProjection?: GeometryProjection;\n  /** Forwarded so `cancelGestureAction` and other actions that need to\n   *  abort in-flight handles can read the dispatcher's control surface. */\n  dispatcher: Dispatcher;\n  /** Ref populated with a live action-lookup function so the dispatcher's\n   *  `getAction` closure can resolve action ids after the registry is\n   *  mounted. Set on first render; cleared on unmount. */\n  getActionRef: React.MutableRefObject<((id: string) => Action | undefined) | null>;\n  /** World-space picker forwarded so the `nodeAtPoint` dep source can\n   *  reuse the same hit-test plumbing the tool dispatcher uses. */\n  pickEvery: (worldX: number, worldY: number) => string[];\n  /** This canvas's own view gate for scene layers, published on the `view`\n   *  dep and read by the selecting actions. Absent when it hides nothing. */\n  layerIsPainted?: (layerId: string) => boolean;\n  /** The composed paint alpha, when the consumer fades anything, so a region\n   *  select passes over what is painted at zero. */\n  alphaOf?: (id: string) => number;\n  /** Resolved `viewport.pan` flag — default true, false to disable. */\n  viewportPanEnabled: boolean | WheelPanOptions;\n  /** Resolved `viewport.zoom` setting — `true` (default Cmd+wheel zoom),\n   *  `false` (disabled), or a {@link ViewportZoomOptions} config. */\n  viewportZoom: boolean | ViewportZoomOptions;\n  /** Resolved `viewport.pinchZoom` setting — `true` (default two-finger pinch),\n   *  `false` (disabled), or a {@link PinchZoomOptions} scale clamp. */\n  viewportPinchZoom: boolean | PinchZoomOptions;\n  /** Optional recenter callback. When supplied, wires through to the\n   *  `view` dep so `viewport.zoom` reset (Cmd-0) calls it instead of\n   *  snapping to identity. A returned `View` is a target the kit may\n   *  animate to; `void` means the callback dispatched it itself. */\n  viewportRecenter?: () => View | void;\n  /** The canvas's camera runner, published on the `view` dep so\n   *  `viewport.zoom`'s discrete branches can animate. */\n  viewAnimation: ViewAnimationApi;\n  /** Lifted edit-mode state so the `pathEditingOverlay` chrome (rendered\n   *  outside this subtree) can read the same `editingId` the dep does. */\n  editAnchorsExternalState: import('../deps/editAnchors').EditAnchorsStateRef;\n  /** Forwarded from `SceneCanvasProps` so the `layout` dep source can wire\n   *  the per-container layout strategy lookup consumed by `moveAction`. */\n  layouts?: SceneCanvasProps<unknown, string, unknown>['layouts'];\n  layoutDropTarget?: LayoutDropTargetMode;\n  reflowTransition?: ReflowTransition<unknown> | null;\n  /** Forwarded from `SceneCanvasProps` so `useInsertDepSource` can wire the\n   *  consumer's per-kind node factories into the `insert` dep. */\n  insertNodeFactories?: Record<string, InsertNodeFactory>;\n  insertPaint?: InsertPaint;\n  /** Forwarded from `SceneCanvasProps.toolOptions.snapPoint` so the `snap`\n   *  dep source can expose grid snapping to `insertAction`. */\n  snapPoint?: (p: { x: number; y: number }) => { x: number; y: number };\n  /** The canvas element ref, so `useIngestionDepSource` can compute the\n   *  visible world rect from the client rect + current view. */\n  canvasRef: React.RefObject<HTMLElement | null>;\n  /** The canvas handle, whose debug sink backs the `debug` dep. */\n  canvasApiRef: React.RefObject<CanvasExtensionApi | null>;\n  /** Forwarded from `SceneCanvasProps.ingestion.resolveSrc` — consumer\n   *  file→src override for the kit image handler. */\n  ingestionResolveSrc?: (file: File) => Promise<string>;\n  /** Forwarded from `SceneCanvasProps.ingestion.svg` — kit SVG-handler\n   *  options (`unpack`). */\n  ingestionSvg?: SvgIngestOptions;\n  /** Clipboard-paste ctx (this canvas's adapter + the consumer's reviver)\n   *  for the kit weasel-JSON handler, from `useCanvasIngestion`; absent\n   *  when disabled. */\n  ingestionClipboard?: ClipboardIngestCtx;\n  /** Populated with the live registry so `CanvasExtensionApi.ingest`\n   *  (assembled in SceneCanvasInner, OUTSIDE the actions provider) can call\n   *  `registry.trigger('ingest', …)`. Cleared on unmount. */\n  actionsRegistryRef: React.MutableRefObject<ActionsRegistry | null>;\n}) {\n  const registry = useActionsRegistry();\n\n  // Stash the registry for SceneCanvasInner's imperative `ingest` handle.\n  useEffect(() => {\n    actionsRegistryRef.current = registry;\n    return () => { actionsRegistryRef.current = null; };\n  }, [registry, actionsRegistryRef]);\n\n  // Wire the dispatcher into the registry so registry.begin() can delegate\n  // to dispatcher.beginUiOngoing() for UI-driven ongoing actions (color,\n  // opacity).\n  useEffect(() => {\n    if (!registry) return;\n    return registry.setDispatcher(dispatcher);\n  }, [registry, dispatcher]);\n\n  // Populate the action-lookup ref so the dispatcher's getAction closure\n  // can resolve action ids once the registry is in scope.\n  useEffect(() => {\n    if (!registry) return;\n    getActionRef.current = (id: string) => registry.list().find((a) => a.id === id);\n    return () => { getActionRef.current = null; };\n  }, [registry, getActionRef]);\n\n  // Momentum for `viewport.dragPan`. The loop must be a hook (it owns a\n  // `useVisibleRaf`), so it is built here and republished on the view dep.\n  const decayLoop = useDecayLoop();\n\n  // Build the ViewApi (stable identity, refreshed closures) and hand it to\n  // useStandardActions (which publishes the `view` dep along with selection,\n  // scene, history, pointer, activeTool). `hostSize` reads the live canvas\n  // element so keyboard zoom (Cmd+=/-) can anchor at the visible center.\n  const view = useViewDepSource(\n    currentViewRef,\n    onViewChange,\n    viewportRecenter,\n    () => {\n      const el = canvasRef.current;\n      return el ? { width: el.clientWidth, height: el.clientHeight } : null;\n    },\n    viewAnimation,\n    decayLoop,\n    layerIsPainted,\n  );\n  useStandardActions({ selection, scene, view, history: scene.history, exclude: excludeActions });\n  // A view overlays `view` with its own camera; this name it leaves alone.\n  useDepSource('rootView', () => view);\n  const pointer = usePointerContext();\n  useDepSource('pointer', () => pointer ?? undefined);\n\n  // viewport.pan / viewport.zoom are SceneCanvas-coupled (need the `view` dep\n  // published just above), so they're registered here rather than in\n  // KIT_STANDARD_DESCRIPTORS. Both default ON; consumer opts out via\n  // `viewport={{ pan: false }}` / `viewport={{ zoom: false }}`.\n  useViewportActions({ pan: viewportPanEnabled, zoom: viewportZoom, pinchZoom: viewportPinchZoom });\n\n  // Per-dep wiring modules under `src/canvas/deps/`. See each file for the\n  // dep's contract and trade-offs.\n  useAreaSelectDepSource(scene, selection, poseDescriptor, alphaOf);\n  useNodeAtPointDepSource(pickEvery);\n  useLayoutDepSource(scene, layouts, layoutDropTarget, reflowTransition);\n  useLayoutArrivals(scene, { layouts, poseDescriptor });\n  useInsertDepSource(scene, adapter, insertNodeFactories, insertPaint);\n  useSliceDepSource(scene, selection, adapter, poseDescriptor);\n  useSnapDepSource(snapPoint);\n  useDebugDepSource(canvasApiRef);\n  useDepChangeNotices(scene, selection.current);\n  useIngestionDepSource(canvasRef, () => currentViewRef.current, ingestionResolveSrc, ingestionSvg, ingestionClipboard);\n  useLassoSelectDepSource(scene, selection, poseDescriptor, alphaOf);\n  useTextEditDepSource(scene);\n  useEditAnchorsDepSource(scene, selection, adapter, editAnchorsExternalState);\n  useDispatcherDepSource(dispatcher);\n  usePoseDescriptorDepSource(poseDescriptor);\n\n  // Keyed on the exclusion too: a re-registration of the standard set would\n  // otherwise land over the overrides applied on top of it.\n  useActionsPropResolver(actions, excludeActions.join('|'));\n\n  // Gate the `resizePolicy` dep registration on the consumer having\n  // passed `selectTool.resize`. When absent, consumers wire it via a child\n  // component (see PointSnapDemo / GroupsDemo). Registering empty defaults\n  // here would race with child-component registrations — React runs child\n  // effects before parent effects, so the parent's empty default would\n  // overwrite the child's real value. The conditional mount avoids that.\n  //\n  // Same pattern for `geometryProjection`: only mount when the consumer\n  // passed the prop so absent → dep undefined → actions stay pose-only.\n  return (\n    <>\n      {resizeOptions ? <ResizePolicyRegistrar options={resizeOptions} /> : null}\n      {geometryProjection ? <GeometryProjectionRegistrar projection={geometryProjection} /> : null}\n    </>\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAuDA,SAAgBC,EAAyB,EACvC,cACA,UACA,YACA,YACA,mBACA,mBACA,iBACA,kBACA,mBACA,uBACA,eACA,iBACA,cACA,oBACA,YACA,uBACA,iBACA,sBACA,qBACA,kBACA,6BACA,YACA,qBACA,qBACA,wBACA,gBACA,eACA,cACA,kBACA,yBACA,kBACA,wBACA,yBAwFC;CACD,IAAMC,IAAWC,EAAmB;CAkBpC,AAfAC,SACE,EAAmB,UAAUF,SAChB;EAAE,EAAmB,UAAU;CAAM,IACjD,CAACA,GAAUG,CAAkB,CAAC,GAKjCD,QAAgB;EACd,IAAKF,GACL,OAAOA,EAAS,cAAcI,CAAU;CAC1C,GAAG,CAACJ,GAAUI,CAAU,CAAC,GAIzBF,QAAgB;EACd,IAAKF,GAEL,OADA,EAAa,WAAW,MAAeA,EAAS,KAAK,CAAC,CAAC,MAAM,MAAMK,EAAE,OAAOC,CAAE,SACjE;GAAE,EAAa,UAAU;EAAM;CAC9C,GAAG,CAACN,GAAUO,CAAY,CAAC;CAI3B,IAAMC,IAAYC,EAAa,GAMzBC,IAAOC,EACXC,GACAC,GACAC,SACM;EACJ,IAAMC,IAAKC,EAAU;EACrB,OAAOD,IAAK;GAAE,OAAOA,EAAG;GAAa,QAAQA,EAAG;EAAa,IAAI;CACnE,GACAE,GACAT,GACAU,EACF;CAGA,AAFAC,EAAmB;EAAE;EAAW;EAAO;EAAM,SAASC,EAAM;EAAS,SAASC;CAAe,CAAC,GAE9FC,EAAa,kBAAkBZ,CAAI;CACnC,IAAMa,KAAUC,EAAkB;CAwClC,OAvCAF,EAAa,iBAAiBC,MAAW,KAAA,CAAS,GAMlDE,GAAmB;EAAE,KAAKC;EAAoB,MAAMC;EAAc,WAAWC;CAAkB,CAAC,GAIhGC,EAAuBT,GAAOU,GAAWC,GAAgBC,CAAO,GAChEC,EAAwBC,CAAS,GACjCC,EAAmBf,GAAOgB,GAASC,GAAkBC,CAAgB,GACrEC,EAAkBnB,GAAO;EAAE;EAAS;CAAe,CAAC,GACpDoB,EAAmBpB,GAAOqB,GAASC,GAAqBC,CAAW,GACnEC,EAAkBxB,GAAOU,GAAWW,GAASV,CAAc,GAC3Dc,EAAiBC,EAAS,GAC1BC,EAAkBC,EAAY,GAC9BC,EAAoB7B,GAAOU,EAAU,OAAO,GAC5CoB,GAAsBlC,SAAiBJ,EAAe,SAASuC,IAAqBC,IAAcC,EAAkB,GACpHC,EAAwBlC,GAAOU,GAAWC,GAAgBC,CAAO,GACjEuB,EAAqBnC,CAAK,GAC1BoC,EAAwBpC,GAAOU,GAAWW,GAASgB,CAAwB,GAC3EC,EAAuBtD,CAAU,GACjCuD,EAA2B5B,CAAc,GAIzC6B,GAAuBC,GAASxC,EAAe,KAAK,GAAG,CAAC,GAYtD,kBAAAvB,GAAA,EAAA,UAAA,CACGiE,IAAgB,kBAACC,IAAD,EAAuB,SAASD,EAAgB,CAAA,IAAI,MACpEE,IAAqB,kBAACC,IAAD,EAA6B,YAAYD,EAAqB,CAAA,IAAI,IACxF,EAAA,CAAA;AAEN"}

package/dist/canvas/SceneCanvas/ToolKeybindingsMounter.js

@@ -1,16 +0,0 @@
-import { useKeybindings as e } from "../../tools/useKeybindings.js";
-import { useContributionRoles as t } from "./useContributionRoles.js";
-//#region src/canvas/SceneCanvas/ToolKeybindingsMounter.tsx
-function n({ internalTools: n, toolsTakeover: r, enableKeybindings: i, modes: a, canvasApi: o, versionCheck: s }) {
-	return e(n, {
-		disable: !!r || !i,
-		modes: a
-	}), e(r ?? n, {
-		disable: !r || !i,
-		modes: a
-	}), t(r ?? n, o, s), null;
-}
-//#endregion
-export { n as ToolKeybindingsMounter };
-
-//# sourceMappingURL=ToolKeybindingsMounter.js.map

package/dist/canvas/SceneCanvas/ToolKeybindingsMounter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ToolKeybindingsMounter.js","names":["ToolKeybindingsMounter","useKeybindings","internalTools","toolsTakeover","enableKeybindings","useContributionRoles","canvasApi","versionCheck"],"sources":["../../../src/canvas/SceneCanvas/ToolKeybindingsMounter.tsx"],"sourcesContent":["import type { ModeRegistry } from '@weasel-js/modes';\nimport { useKeybindings } from 'tools/useKeybindings';\nimport type { ToolsApi } from '../../tools/overlayBinding';\nimport type { CanvasExtensionApi } from '../canvasExtension';\nimport { useContributionRoles, type VersionCheck } from './useContributionRoles';\n\n/**\n * Mounts `useKeybindings`, whose `tool.activate` / `tool.offhand` /\n * `tool.resetToDefault` registrations land in this canvas's scope.\n *\n * Two calls: the hook snapshots the initial active tool for\n * Escape-returns-to-default, so the internal and consumer-supplied `ToolsApi`\n * each need their own instance and the hook count has to stay stable across\n * the takeover branch.\n */\nexport function ToolKeybindingsMounter({\n  internalTools,\n  toolsTakeover,\n  enableKeybindings,\n  modes,\n  canvasApi,\n  versionCheck,\n}: {\n  internalTools: ToolsApi;\n  toolsTakeover?: ToolsApi;\n  enableKeybindings: boolean;\n  modes?: ModeRegistry;\n  canvasApi: CanvasExtensionApi | null;\n  versionCheck?: VersionCheck;\n}) {\n  useKeybindings(internalTools, {\n    disable: !!toolsTakeover || !enableKeybindings,\n    modes,\n  });\n  useKeybindings(toolsTakeover ?? internalTools, {\n    disable: !toolsTakeover || !enableKeybindings,\n    modes,\n  });\n  // Entry-owned roles live here and not in the tool hooks because the hooks\n  // run above the provider. Not gated on `enableKeybindings` — these back\n  // wheel and pointer bindings too, not just keys.\n  useContributionRoles(toolsTakeover ?? internalTools, canvasApi, versionCheck);\n  return null;\n}\n"],"mappings":";;;AAeA,SAAgBA,EAAuB,EACrC,kBACA,kBACA,sBACA,UACA,cACA,mBAQC;CAaD,OAZAC,EAAeC,GAAe;EAC5B,SAAS,CAAC,CAACC,KAAiB,CAACC;EAC7B;CACF,CAAC,GACDH,EAAeE,KAAiBD,GAAe;EAC7C,SAAS,CAACC,KAAiB,CAACC;EAC5B;CACF,CAAC,GAIDC,EAAqBF,KAAiBD,GAAeI,GAAWC,CAAY,GACrE;AACT"}

package/dist/canvas/SceneCanvas/isDev.js

@@ -1,12 +0,0 @@
-//#region src/canvas/SceneCanvas/isDev.ts
-var e = (() => {
-	try {
-		return !1;
-	} catch {
-		return !1;
-	}
-})();
-//#endregion
-export { e as IS_DEV };
-
-//# sourceMappingURL=isDev.js.map

package/dist/canvas/SceneCanvas/isDev.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"isDev.js","names":["IS_DEV"],"sources":["../../../src/canvas/SceneCanvas/isDev.ts"],"sourcesContent":["\n// Read through a cast: core must compile without a bundler's ambient\n// `ImportMeta` augmentation (`vite/client`).\nexport const IS_DEV: boolean = (() => {\n  try {\n    return Boolean((import.meta as unknown as { env?: { DEV?: boolean } }).env?.DEV);\n  } catch {\n    return false;\n  }\n})();\n"],"mappings":";AAGA,IAAaA,WAAyB;CACpC,IAAI;EACF,OAAO,CAAA;CACT,QAAQ;EACN,OAAO;CACT;AACF,EAAA,CAAG"}

package/dist/canvas/SceneCanvas/useViewLayerGate.js

@@ -1,20 +0,0 @@
-import { createSceneLayerGate as e } from "../sceneLayerPaint.js";
-import { useOptionalViewRegistry as t } from "../viewRegistry.js";
-import { useCallback as n, useState as r } from "react";
-import { useLatest as i } from "@weasel-js/react";
-//#region src/canvas/SceneCanvas/useViewLayerGate.ts
-function a(a, o) {
-	let s = t(), c = i({
-		layerVisibility: a,
-		layerOrder: o
-	}), [l] = r(e), u = n((e) => l(s?.surface()?.layers() ?? [], c.current)(e), [
-		s,
-		l,
-		c
-	]);
-	return a !== void 0 || o !== void 0 ? u : void 0;
-}
-//#endregion
-export { a as useViewLayerGate };
-
-//# sourceMappingURL=useViewLayerGate.js.map

package/dist/canvas/SceneCanvas/useViewLayerGate.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useViewLayerGate.js","names":["useViewLayerGate","surfaceViewRegistry","useOptionalViewRegistry","layerPaintRef","useLatest","sceneLayerGate","useState","createSceneLayerGate","layerIsPainted","useCallback","layerId","layerVisibility","layerOrder"],"sources":["../../../src/canvas/SceneCanvas/useViewLayerGate.ts"],"sourcesContent":["import { useCallback, useState } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { createSceneLayerGate, type ViewLayerPaint } from '../sceneLayerPaint';\nimport { useOptionalViewRegistry } from '../viewRegistry';\n\n/**\n * Whether the surface's own view paints a scene layer, judged against the\n * stack `<Canvas>` composed and read at pick time, so a consumer slot anchored\n * between scene layers is weighed the way paint weighs it. Undefined when the\n * view hides nothing, so a pick walk skips the gate.\n */\nexport function useViewLayerGate(\n  layerVisibility: ViewLayerPaint['layerVisibility'],\n  layerOrder: ViewLayerPaint['layerOrder'],\n): ((layerId: string) => boolean) | undefined {\n  const surfaceViewRegistry = useOptionalViewRegistry();\n  const layerPaintRef = useLatest<ViewLayerPaint>({ layerVisibility, layerOrder });\n  const [sceneLayerGate] = useState(createSceneLayerGate);\n  const layerIsPainted = useCallback((layerId: string): boolean => (\n    sceneLayerGate(surfaceViewRegistry?.surface()?.layers() ?? [], layerPaintRef.current)(layerId)\n  ), [surfaceViewRegistry, sceneLayerGate, layerPaintRef]);\n  return layerVisibility !== undefined || layerOrder !== undefined ? layerIsPainted : undefined;\n}\n"],"mappings":";;;;;AAWA,SAAgBA,EACd,GACA,GAC4C;CAC5C,IAAMC,IAAsBC,EAAwB,GAC9CC,IAAgBC,EAA0B;EAAE;EAAiB;CAAW,CAAC,GACzE,CAACC,KAAkBC,EAASC,CAAoB,GAChDC,IAAiBC,GAAa,MAClCJ,EAAeJ,GAAqB,QAAQ,CAAC,EAAE,OAAO,KAAK,CAAC,GAAGE,EAAc,OAAO,CAAC,CAACO,CAAO,GAC5F;EAACT;EAAqBI;EAAgBF;CAAa,CAAC;CACvD,OAAOQ,MAAoB,KAAA,KAAaC,MAAe,KAAA,IAAYJ,IAAiB,KAAA;AACtF"}

package/dist/canvas/surface.module.js

@@ -1,6 +0,0 @@
-//#region src/canvas/surface.module.css
-var e = "_surface_c2e145", t = { surface: e };
-//#endregion
-export { t as default, e as surface };
-
-//# sourceMappingURL=surface.module.js.map

package/dist/canvas/surface.module.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"surface.module.js","names":["surface","surface_module_default"],"sources":["../../src/canvas/surface.module.css"],"sourcesContent":["/* The CSS size of a canvas the kit renders: its `width` and `height` props.\n   Zero specificity, so a class the consumer passes resizes the element. */\n:where(.surface) {\n  width: var(--wzl-surface-width);\n  height: var(--wzl-surface-height);\n}\n"],"mappings":""}

package/dist/canvas/surfaceBox.js

@@ -1,16 +0,0 @@
-import e from "./surface.module.js";
-//#region src/canvas/surfaceBox.ts
-function t(t, n, r, i) {
-	return {
-		className: r ? `${e.surface} ${r}` : e.surface,
-		style: {
-			...i,
-			"--wzl-surface-width": `${t}px`,
-			"--wzl-surface-height": `${n}px`
-		}
-	};
-}
-//#endregion
-export { t as surfaceBox };
-
-//# sourceMappingURL=surfaceBox.js.map

package/dist/canvas/surfaceBox.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"surfaceBox.js","names":["s","surface_module_default","surfaceBox","className","style","width","height"],"sources":["../../src/canvas/surfaceBox.ts"],"sourcesContent":["/// <reference path=\"../css-modules.d.ts\" />\nimport type { CSSProperties } from 'react';\nimport s from './surface.module.css';\n\n/** The class and style for a `<canvas>` the kit renders at `width` × `height`\n *  CSS pixels. The renderer sizes only the drawing buffer, so without these\n *  the element is as large as its buffer: `dpr` times too big. */\nexport function surfaceBox(\n  width: number,\n  height: number,\n  className?: string,\n  style?: CSSProperties,\n): { className: string; style: CSSProperties } {\n  return {\n    className: className ? `${s.surface} ${className}` : s.surface,\n    style: { ...style, '--wzl-surface-width': `${width}px`, '--wzl-surface-height': `${height}px` } as CSSProperties,\n  };\n}\n"],"mappings":";;AAOA,SAAgBE,EACd,GACA,GACA,GACA,GAC6C;CAC7C,OAAO;EACL,WAAWC,IAAY,GAAGH,EAAE,QAAQ,GAAGG,MAAcH,EAAE;EACvD,OAAO;GAAE,GAAGI;GAAO,uBAAuB,GAAGC,EAAM;GAAK,wBAAwB,GAAGC,EAAO;EAAI;CAChG;AACF"}

package/dist/cornerHandles-BEshc4z3.d.ts

@@ -1,104 +0,0 @@
-import { B as BoundsConstraint, P as PointSnapBehavior } from './clone-2a5hVbBd.js';
-import { Bounds, ResizeAnchor } from '@weasel-js/routing';
-
-/** Option surface for the `resize` action. */
-
-/** Options for the `resize` action: the constraints applied to the dragged
- *  bounding box, how a gesture expands a group into its leaves, and its
- *  history and lifecycle. `<SceneCanvas>` publishes them as the
- *  `resizePolicy` dep (`resizePolicyOptions`). */
-interface UseResizeOptions<TPose> {
-    /** Behaviors are rect-typed: they read/write `{x,y,width,height}`. For a
-     *  non-rect `TPose`, constraints are typed `never`; the pose descriptor
-     *  comes from `<SceneCanvas poseDescriptor>`. */
-    behaviors?: TPose extends Bounds ? BoundsConstraint<TPose>[] : never;
-    /** History label for the committed resize. Default `'Resize'`. */
-    resizeLabel?: string;
-    /** Commit without an undo entry (`scene.untracked`), bypassing the
-     *  consumer `applyOps` hook. Unset, a behavior's `defaultTransient` decides. */
-    transient?: boolean;
-    /** Fired when the resize starts, with the ids it writes. */
-    onGestureStart?: (ids: string[]) => void;
-    /** Fired once per `onGestureStart`: `true` when the resize wrote to the
-     *  document, `false` on cancel, a behavior abort, or no change. */
-    onGestureEnd?: (committed: boolean) => void;
-    /** Expand the incoming id into leaf ids, for resizing a group: the kit
-     *  resizes the union AABB of the leaves' bounds and remaps each leaf into
-     *  the result. Called once at `start()`. Returning `[]` aborts the gesture
-     *  cleanly. */
-    expandIds?: (ids: string[]) => string[];
-    /** Behaviors that operate on world-space anchor points. Fire after
-     *  `behaviors[]`. The first non-null `PointSnapResult` wins, and the pose
-     *  is back-solved so the chosen frame's world point lands on the snap
-     *  target. */
-    pointSnapBehaviors?: TPose extends Bounds ? PointSnapBehavior<TPose>[] : never;
-    /** Per-node resizability predicate. Returns `false` for nodes that should
-     *  never show resize handles (and thus can't start a resize gesture). The
-     *  handles hide whenever any selected node is non-resizable. Default: every
-     *  node resizable. */
-    resizable?: (id: string) => boolean;
-}
-
-/** Corner resize-handle: world-space center plus the anchor that pins the opposite corner during resize. */
-interface CornerHandle {
-    cx: number;
-    cy: number;
-    anchor: ResizeAnchor;
-}
-/** Which AABB edge a corner sits on, per axis. `'min'` = the x/y origin
- *  edge; `'max'` = the origin + extent edge. */
-type CornerEdge = 'min' | 'max';
-/** One entry of the canonical 4-corner resize layout. The single source of
- *  truth for "which corner maps to which anchor / handle-kind". */
-interface CornerAnchor {
-    /** Which x-edge the corner sits on (`'min'` = left, `'max'` = right). */
-    xEdge: CornerEdge;
-    /** Which y-edge the corner sits on (`'min'` = top, `'max'` = bottom). */
-    yEdge: CornerEdge;
-    /** Anchor that pins the diagonally-opposite (fixed) corner. Always the
-     *  axis-wise opposite of `{xEdge, yEdge}`. */
-    anchor: ResizeAnchor;
-    /** Affordance/handle discriminator string for this corner. */
-    kind: string;
-    /** Short positional tag (`'<xEdge>-<yEdge>'`), e.g. `'min-max'`. */
-    tag: string;
-}
-/**
- * The single ordered corner→anchor table. Order is **load-bearing**: every
- * consumer iterates it in this sequence (TL, TR, BL, BR) so positional
- * meaning (the i-th handle / `kind` / `tag`) stays consistent across the
- * resize-handle affordance, the affordance-hit classifier, and
- * `cornerResizeHandles`. Each corner's `anchor` names the diagonally
- * opposite corner, so dragging the corner scales the box from that fixed
- * point.
- */
-declare const CORNER_ANCHORS: readonly CornerAnchor[];
-/** Resolve a corner's world-space position for the given bounds. `xEdge`
- *  `'max'` → `x + width`; `yEdge` `'max'` → `y + height`. */
-declare function cornerPoint(bounds: Bounds, entry: Pick<CornerAnchor, 'xEdge' | 'yEdge'>): {
-    x: number;
-    y: number;
-};
-/** Standard 4-corner resize-handle layout: each corner pins the opposite
- *  corner via an anchor of `{x: 'min'|'max', y: 'min'|'max'}` so dragging it
- *  scales the box from the fixed opposite corner. Decodes {@link CORNER_ANCHORS}
- *  against `bounds`. */
-declare function cornerResizeHandles(bounds: Bounds): CornerHandle[];
-/** Square hit-test for a handle: returns true if `(px, py)` is within
- *  `radius` of the handle center on both axes. */
-declare function hitCornerHandle(handle: CornerHandle, px: number, py: number, radius: number): boolean;
-/** The corner that does NOT move under a resize gesture with the given
- *  anchor. Used by the rotated-resize math to pin a world-space invariant.
- *
- *  Convention: `anchor.x === 'min'` means the min-x (left) edge is the
- *  fixed anchor, so the fixed corner sits at `x = bounds.x` (min-x).
- *  `anchor.x === 'max'` means the max-x (right) edge is fixed, so the
- *  fixed corner sits at `x = bounds.x + bounds.width`. `'free'` on an
- *  axis means that axis doesn't move; the fixed coord is the bounds
- *  origin on that axis. */
-declare function fixedCornerOf(bounds: Bounds, anchor: ResizeAnchor): {
-    x: number;
-    y: number;
-};
-
-export { CORNER_ANCHORS as C, type UseResizeOptions as U, type CornerAnchor as a, type CornerHandle as b, cornerPoint as c, cornerResizeHandles as d, type CornerEdge as e, fixedCornerOf as f, hitCornerHandle as h };

package/dist/icons/ArrowIcon.js

@@ -1,23 +0,0 @@
-import { ICON_SVG_BASE as e } from "./_base.js";
-import { jsx as t, jsxs as n } from "react/jsx-runtime";
-//#region src/icons/ArrowIcon.tsx
-function r({ className: r, size: i = 20 }) {
-	return /* @__PURE__ */ n("svg", {
-		...e,
-		className: r,
-		width: i,
-		height: i,
-		children: [/* @__PURE__ */ t("path", {
-			d: "M3.5 16.5 12.9 7.1",
-			strokeLinecap: "round"
-		}), /* @__PURE__ */ t("path", {
-			d: "M16.5 3.5 11.06 5.98 14.03 8.95Z",
-			fill: "currentColor",
-			strokeLinejoin: "round"
-		})]
-	});
-}
-//#endregion
-export { r as default };
-
-//# sourceMappingURL=ArrowIcon.js.map

package/dist/icons/ArrowIcon.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ArrowIcon.js","names":["ArrowIcon","ICON_SVG_BASE","size"],"sources":["../../src/icons/ArrowIcon.tsx"],"sourcesContent":["import { ICON_SVG_BASE } from './_base';\nimport type { IconProps } from './types';\n\n/** `LineIcon`'s diagonal with a filled head, so the two read as one tool with\n *  and without the marker. Used for the arrow insertion tool.\n *\n *  The head is filled rather than an open V: at 16px an open V's barbs merge\n *  under antialiasing and the notch disappears, leaving a blob. Its base\n *  corners are `tip ∓ 5.6·d ± 2.1·d⊥` — computed, and the shaft stops half a\n *  unit inside the base so its round cap hides under the fill. */\nexport default function ArrowIcon({ className, size = 20 }: IconProps) {\n  return (\n    <svg\n      {...ICON_SVG_BASE}\n      className={className}\n      width={size}\n      height={size}\n    >\n      <path d=\"M3.5 16.5 12.9 7.1\" strokeLinecap=\"round\" />\n      <path d=\"M16.5 3.5 11.06 5.98 14.03 8.95Z\" fill=\"currentColor\" strokeLinejoin=\"round\" />\n    </svg>\n  );\n}\n"],"mappings":";;;AAUA,SAAwBA,EAAU,EAAE,cAAW,UAAO,MAAiB;CACrE,OACE,kBAAC,OAAD;EACE,GAAIC;EACO;EACX,OAAOC;EACP,QAAQA;EAJV,UAAA,CAME,kBAAC,QAAD;GAAM,GAAE;GAAqB,eAAc;EAAS,CAAA,GACpD,kBAAC,QAAD;GAAM,GAAE;GAAmC,MAAK;GAAe,gBAAe;EAAS,CAAA,CACpF;;AAET"}

package/dist/icons/EllipseIcon.js

@@ -1,21 +0,0 @@
-import { ICON_SVG_BASE as e } from "./_base.js";
-import { jsx as t } from "react/jsx-runtime";
-//#region src/icons/EllipseIcon.tsx
-function n({ className: n, size: r = 20 }) {
-	return /* @__PURE__ */ t("svg", {
-		...e,
-		className: n,
-		width: r,
-		height: r,
-		children: /* @__PURE__ */ t("ellipse", {
-			cx: "10",
-			cy: "10",
-			rx: "7",
-			ry: "5"
-		})
-	});
-}
-//#endregion
-export { n as default };
-
-//# sourceMappingURL=EllipseIcon.js.map

package/dist/icons/EllipseIcon.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"EllipseIcon.js","names":["EllipseIcon","ICON_SVG_BASE","size"],"sources":["../../src/icons/EllipseIcon.tsx"],"sourcesContent":["import { ICON_SVG_BASE } from './_base';\nimport type { IconProps } from './types';\n\n/** Outlined ellipse. Used for the ellipse insertion tool. */\nexport default function EllipseIcon({ className, size = 20 }: IconProps) {\n  return (\n    <svg\n      {...ICON_SVG_BASE}\n      className={className}\n      width={size}\n      height={size}\n    >\n      <ellipse cx=\"10\" cy=\"10\" rx=\"7\" ry=\"5\" />\n    </svg>\n  );\n}\n"],"mappings":";;;AAIA,SAAwBA,EAAY,EAAE,cAAW,UAAO,MAAiB;CACvE,OACE,kBAAC,OAAD;EACE,GAAIC;EACO;EACX,OAAOC;EACP,QAAQA;EAER,UAAA,kBAAC,WAAD;GAAS,IAAG;GAAK,IAAG;GAAK,IAAG;GAAI,IAAG;EAAK,CAAA;CACrC,CAAA;AAET"}

package/dist/icons/EyedropperIcon.js

@@ -1,49 +0,0 @@
-import { ICON_SVG_BASE as e } from "./_base.js";
-import { jsx as t, jsxs as n } from "react/jsx-runtime";
-//#region src/icons/EyedropperIcon.tsx
-function r({ className: r, size: i = 20 }) {
-	return /* @__PURE__ */ n("svg", {
-		...e,
-		className: r,
-		width: i,
-		height: i,
-		children: [
-			/* @__PURE__ */ t("line", {
-				x1: "12.5",
-				y1: "3.5",
-				x2: "16.5",
-				y2: "7.5",
-				strokeLinecap: "round"
-			}),
-			/* @__PURE__ */ t("path", {
-				d: "M 11 7 L 13 5 a 2 2 0 0 1 2.8 0 l 1.2 1.2 a 2 2 0 0 1 0 2.8 L 15 11 Z",
-				strokeLinejoin: "round"
-			}),
-			/* @__PURE__ */ t("line", {
-				x1: "13",
-				y1: "9",
-				x2: "5",
-				y2: "17",
-				strokeLinecap: "round"
-			}),
-			/* @__PURE__ */ t("line", {
-				x1: "11",
-				y1: "7",
-				x2: "3",
-				y2: "15",
-				strokeLinecap: "round"
-			}),
-			/* @__PURE__ */ t("line", {
-				x1: "3",
-				y1: "15",
-				x2: "5",
-				y2: "17",
-				strokeLinecap: "round"
-			})
-		]
-	});
-}
-//#endregion
-export { r as default };
-
-//# sourceMappingURL=EyedropperIcon.js.map

package/dist/icons/EyedropperIcon.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"EyedropperIcon.js","names":["EyedropperIcon","ICON_SVG_BASE","size"],"sources":["../../src/icons/EyedropperIcon.tsx"],"sourcesContent":["import { ICON_SVG_BASE } from './_base';\nimport type { IconProps } from './types';\n\n/** Eyedropper — diagonal stem running from upper-right (bulb) to\n *  lower-left (tip), with a small squared bulb cap at the top. Used\n *  for the eyedropper / color-picker tool. */\nexport default function EyedropperIcon({ className, size = 20 }: IconProps) {\n  return (\n    <svg\n      {...ICON_SVG_BASE}\n      className={className}\n      width={size}\n      height={size}\n    >\n      {/* Bulb cap (upper-right) */}\n      <line x1=\"12.5\" y1=\"3.5\" x2=\"16.5\" y2=\"7.5\" strokeLinecap=\"round\" />\n      {/* Bulb body — rounded rectangle along the diagonal */}\n      <path\n        d=\"M 11 7 L 13 5 a 2 2 0 0 1 2.8 0 l 1.2 1.2 a 2 2 0 0 1 0 2.8 L 15 11 Z\"\n        strokeLinejoin=\"round\"\n      />\n      {/* Stem from bulb down to tip */}\n      <line x1=\"13\" y1=\"9\" x2=\"5\" y2=\"17\" strokeLinecap=\"round\" />\n      <line x1=\"11\" y1=\"7\" x2=\"3\" y2=\"15\" strokeLinecap=\"round\" />\n      {/* Tip closure */}\n      <line x1=\"3\" y1=\"15\" x2=\"5\" y2=\"17\" strokeLinecap=\"round\" />\n    </svg>\n  );\n}\n"],"mappings":";;;AAMA,SAAwBA,EAAe,EAAE,cAAW,UAAO,MAAiB;CAC1E,OACE,kBAAC,OAAD;EACE,GAAIC;EACO;EACX,OAAOC;EACP,QAAQA;EAJV,UAAA;GAOE,kBAAC,QAAD;IAAM,IAAG;IAAO,IAAG;IAAM,IAAG;IAAO,IAAG;IAAM,eAAc;GAAS,CAAA;GAEnE,kBAAC,QAAD;IACE,GAAE;IACF,gBAAe;GAChB,CAAA;GAED,kBAAC,QAAD;IAAM,IAAG;IAAK,IAAG;IAAI,IAAG;IAAI,IAAG;IAAK,eAAc;GAAS,CAAA;GAC3D,kBAAC,QAAD;IAAM,IAAG;IAAK,IAAG;IAAI,IAAG;IAAI,IAAG;IAAK,eAAc;GAAS,CAAA;GAE3D,kBAAC,QAAD;IAAM,IAAG;IAAI,IAAG;IAAK,IAAG;IAAI,IAAG;IAAK,eAAc;GAAS,CAAA;EACxD;;AAET"}