@weasel-js/core 1.10.1 → 1.11.1

package/package.json

@@ -1,7 +1,10 @@
 {
   "name": "@weasel-js/core",
-  "version": "1.10.1",
+  "version": "1.11.1",
   "description": "A 2D scene-graph engine for React, rendered on WebGL2: the scene tree, viewport math, pointer and keyboard input, layered rendering, and op-based undo.",
+  "weasel": {
+    "needs": ["webgl2"]
+  },
   "license": "MIT",
   "author": "orochi235",
   "homepage": "https://orochi235.github.io/weasel/",
@@ -17,6 +20,8 @@
   "sideEffects": [
     "*.css",
     "./src/import-shims/mesh.ts",
+    "./src/import-shims/devtools.ts",
+    "./dist/devtools.js",
     "./src/core/paint/registerMesh.ts",
     "./dist/mesh.js",
     "./dist/core/paint/registerMesh.js"
@@ -30,6 +35,9 @@
     "LICENSE",
     "CHANGELOG.md"
   ],
+  "weaselIcons": {
+    "table": "./dist/icons.table.json"
+  },
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -39,6 +47,10 @@
       "types": "./dist/index.d.ts"
     },
     "./style.css": "./dist/style.css",
+    "./icons": {
+      "import": "./dist/icons.js",
+      "types": "./dist/icons.d.ts"
+    },
     "./math": {
       "import": "./dist/math.js",
       "types": "./dist/math.d.ts"
@@ -63,6 +75,14 @@
       "import": "./dist/clone.js",
       "types": "./dist/clone.d.ts"
     },
+    "./devtools": {
+      "import": "./dist/devtools.js",
+      "types": "./dist/devtools.d.ts"
+    },
+    "./devtools-protocol": {
+      "import": "./dist/devtools-protocol.js",
+      "types": "./dist/devtools-protocol.d.ts"
+    },
     "./patterns-builtin": {
       "import": "./dist/patterns-builtin.js",
       "types": "./dist/patterns-builtin.d.ts"
@@ -82,33 +102,34 @@
     "./package.json": "./package.json"
   },
   "scripts": {
-    "build": "vite build && tsup && node ../labkit/scripts/build-css.mjs --if-built",
+    "build": "vite build && tsup && cp src/icons.table.json dist/ && node ../labkit/scripts/build-css.mjs --if-built",
     "typecheck": "tsc --noEmit -p tsconfig.json"
   },
   "peerDependencies": {
-    "@weasel-js/font": "1.10.1",
+    "@weasel-js/font": "1.11.1",
     "react": ">=18"
   },
   "dependencies": {
-    "@msb235/blits": "0.10.0",
-    "@weasel-js/animator": "1.10.1",
-    "@weasel-js/cursor": "1.10.1",
-    "@weasel-js/geom": "1.10.1",
-    "@weasel-js/gestures": "1.10.1",
-    "@weasel-js/history": "1.10.1",
-    "@weasel-js/modes": "1.10.1",
-    "@weasel-js/paint": "1.10.1",
-    "@weasel-js/prefs": "1.10.1",
-    "@weasel-js/quantity": "1.10.1",
-    "@weasel-js/react": "1.10.1",
-    "@weasel-js/registry": "1.10.1",
-    "@weasel-js/renderer": "1.10.1",
-    "@weasel-js/routing": "1.10.1",
-    "@weasel-js/select": "1.10.1",
-    "@weasel-js/simulation": "1.10.1",
-    "@weasel-js/stroke": "1.10.1",
-    "@weasel-js/text": "1.10.1",
-    "@weasel-js/text-dom": "1.10.1",
+    "@msb235/blits": "0.11.0",
+    "@weasel-js/animator": "1.11.1",
+    "@weasel-js/cursor": "1.11.1",
+    "@weasel-js/geom": "1.11.1",
+    "@weasel-js/gestures": "1.11.1",
+    "@weasel-js/history": "1.11.1",
+    "@weasel-js/icons": "1.11.1",
+    "@weasel-js/modes": "1.11.1",
+    "@weasel-js/paint": "1.11.1",
+    "@weasel-js/prefs": "1.11.1",
+    "@weasel-js/quantity": "1.11.1",
+    "@weasel-js/react": "1.11.1",
+    "@weasel-js/registry": "1.11.1",
+    "@weasel-js/renderer": "1.11.1",
+    "@weasel-js/routing": "1.11.1",
+    "@weasel-js/select": "1.11.1",
+    "@weasel-js/simulation": "1.11.1",
+    "@weasel-js/stroke": "1.11.1",
+    "@weasel-js/text": "1.11.1",
+    "@weasel-js/text-dom": "1.11.1",
     "earcut": "3.2.3",
     "polygon-clipping": "^0.15.7"
   },
@@ -126,7 +147,8 @@
     "2d"
   ],
   "devDependencies": {
-    "@weasel-js/modes": "1.10.1",
-    "@weasel-js/theme": "1.10.1"
+    "@weasel-js/icons-plugin": "1.11.1",
+    "@weasel-js/modes": "1.11.1",
+    "@weasel-js/theme": "1.11.1"
   }
 }

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,55 +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 { useViewDepSource as i } from "../deps/view.js";
-import { useAreaSelectDepSource as a } from "../deps/areaSelect.js";
-import { useNodeAtPointDepSource as o } from "../deps/nodeAtPoint.js";
-import { useLassoSelectDepSource as s } from "../deps/lassoSelect.js";
-import { useTextEditDepSource as c } from "../deps/textEdit.js";
-import { useEditAnchorsDepSource as l } from "../deps/editAnchors.js";
-import { useInsertDepSource as ee } from "../deps/insert.js";
-import { useSnapDepSource as u } from "../deps/snap.js";
-import { useDebugDepSource as d } from "../deps/debug.js";
-import { useDepChangeNotices as f } from "../deps/changes.js";
-import { useDispatcherDepSource as p } from "../deps/dispatcher.js";
-import { useLayoutDepSource as te } from "../deps/layout.js";
-import { useIngestionDepSource as ne } from "../deps/ingestion.js";
-import { GeometryProjectionRegistrar as re, ResizePolicyRegistrar as m } from "./poseRegistrars.js";
-import { useActionsPropResolver as h } from "./useActionsPropResolver.js";
-import { useActionTunings as g } from "./useActionTunings.js";
-import { useViewportActions as _ } from "./useViewportActions.js";
-import { useEffect as v } from "react";
-import { useActionsRegistry as y, useDepSource as b, usePointerContext as x } from "@weasel-js/routing/react";
-import { Fragment as S, jsx as C, jsxs as w } from "react/jsx-runtime";
-//#region src/canvas/SceneCanvas/StandardActionsRegistrar.tsx
-function T({ selection: T, scene: E, adapter: D, actions: O, tune: k, excludeActions: A, currentViewRef: j, onViewChange: M, resizeOptions: N, poseDescriptor: P, geometryProjection: F, dispatcher: I, pickEvery: L, layerIsPainted: R, alphaOf: z, viewportPanEnabled: B, viewportZoom: V, viewportPinchZoom: H, viewportRecenter: U, viewAnimation: W, editAnchorsExternalState: G, layoutDropTarget: K, reflowTransition: q, insertNodeFactories: J, insertPaint: Y, snapPoint: X, canvasRef: Z, canvasApiRef: ie, ingestionResolveSrc: ae, ingestionSvg: oe, ingestionClipboard: se }) {
-	let Q = y();
-	v(() => {
-		if (Q) return Q.setDispatcher(I);
-	}, [Q, I]);
-	let ce = e(), $ = i(j, M, U, () => {
-		let e = Z.current;
-		return e ? {
-			width: e.clientWidth,
-			height: e.clientHeight
-		} : null;
-	}, W, ce, R);
-	t({
-		selection: T,
-		scene: E,
-		view: $,
-		history: E.history,
-		exclude: A
-	}), b("rootView", () => $);
-	let le = x();
-	return b("pointer", () => le ?? void 0), _({
-		pan: B,
-		zoom: V,
-		pinchZoom: H
-	}), a(E, T, P, z), o(L), te(E, K, q), ee(E, D, J, Y), r(E, T, D, P), u(X), d(ie), f(E, T.current), ne(Z, () => j.current, ae, oe, se), s(E, T, P, z), c(E), l(E, T, D, G), p(I), n(P), h(O, A.join("|")), g(k), /* @__PURE__ */ w(S, { children: [N ? /* @__PURE__ */ C(m, { options: N }) : null, F ? /* @__PURE__ */ C(re, { projection: F }) : null] });
-}
-//#endregion
-export { T 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","dispatcher","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","layoutDropTarget","reflowTransition","useInsertDepSource","adapter","insertNodeFactories","insertPaint","useSliceDepSource","useSnapDepSource","snapPoint","useDebugDepSource","canvasApiRef","useDepChangeNotices","useIngestionDepSource","ingestionResolveSrc","ingestionSvg","ingestionClipboard","useLassoSelectDepSource","useTextEditDepSource","useEditAnchorsDepSource","editAnchorsExternalState","useDispatcherDepSource","usePoseDescriptorDepSource","useActionsPropResolver","actions","useActionTunings","tune","Fragment","resizeOptions","ResizePolicyRegistrar","geometryProjection","GeometryProjectionRegistrar"],"sources":["../../../src/canvas/SceneCanvas/StandardActionsRegistrar.tsx"],"sourcesContent":["import type { ActionsProp, ActionTunings } 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 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 } from './props';\nimport { useActionsPropResolver } from './useActionsPropResolver';\nimport { useActionTunings } from './useActionTunings';\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, tune,\n  excludeActions,\n  currentViewRef,\n  onViewChange,\n  resizeOptions,\n  poseDescriptor,\n  geometryProjection,\n  dispatcher,\n  pickEvery,\n  layerIsPainted,\n  alphaOf,\n  viewportPanEnabled,\n  viewportZoom,\n  viewportPinchZoom,\n  viewportRecenter,\n  viewAnimation,\n  editAnchorsExternalState,\n  layoutDropTarget,\n  reflowTransition,\n  insertNodeFactories,\n  insertPaint,\n  snapPoint,\n  canvasRef,\n  canvasApiRef,\n  ingestionResolveSrc,\n  ingestionSvg,\n  ingestionClipboard,\n}: {\n  selection: SelectionApi;\n  scene: Scene<unknown, string, unknown>;\n  adapter: BridgeAdapter;\n  actions?: ActionsProp;\n  tune?: ActionTunings;\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  /** 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  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}) {\n  const registry = useActionsRegistry();\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  // 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, layoutDropTarget, reflowTransition);\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  useActionTunings(tune);\n\n  // Mounted only when passed: an empty default registered here would land\n  // after, and over, a dep a child component registered (child effects run\n  // first). Absent `geometryProjection` leaves the dep undefined.\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,YAAS,SACT,mBACA,mBACA,iBACA,kBACA,mBACA,uBACA,eACA,cACA,mBACA,YACA,uBACA,iBACA,sBACA,qBACA,kBACA,6BACA,qBACA,qBACA,wBACA,gBACA,cACA,cACA,kBACA,yBACA,kBACA,0BA8EC;CACD,IAAMC,IAAWC,EAAmB;CAKpC,QAAgB;EACd,IAAKD,GACL,OAAOA,EAAS,cAAcE,CAAU;CAC1C,GAAG,CAACF,GAAUE,CAAU,CAAC;CAIzB,IAAMC,KAAYC,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,IACAU,CACF;CAGA,AAFAC,EAAmB;EAAE;EAAW;EAAO;EAAM,SAASC,EAAM;EAAS,SAASC;CAAe,CAAC,GAE9FC,EAAa,kBAAkBZ,CAAI;CACnC,IAAMa,KAAUC,EAAkB;CAkClC,OAjCAF,EAAa,iBAAiBC,MAAW,KAAA,CAAS,GAMlDE,EAAmB;EAAE,KAAKC;EAAoB,MAAMC;EAAc,WAAWC;CAAkB,CAAC,GAIhGC,EAAuBT,GAAOU,GAAWC,GAAgBC,CAAO,GAChEC,EAAwBC,CAAS,GACjCC,GAAmBf,GAAOgB,GAAkBC,CAAgB,GAC5DC,GAAmBlB,GAAOmB,GAASC,GAAqBC,CAAW,GACnEC,EAAkBtB,GAAOU,GAAWS,GAASR,CAAc,GAC3DY,EAAiBC,CAAS,GAC1BC,EAAkBC,EAAY,GAC9BC,EAAoB3B,GAAOU,EAAU,OAAO,GAC5CkB,GAAsBhC,SAAiBJ,EAAe,SAASqC,IAAqBC,IAAcC,EAAkB,GACpHC,EAAwBhC,GAAOU,GAAWC,GAAgBC,CAAO,GACjEqB,EAAqBjC,CAAK,GAC1BkC,EAAwBlC,GAAOU,GAAWS,GAASgB,CAAwB,GAC3EC,EAAuBjD,CAAU,GACjCkD,EAA2B1B,CAAc,GAIzC2B,EAAuBC,GAAStC,EAAe,KAAK,GAAG,CAAC,GACxDuC,EAAiBC,CAAI,GAMnB,kBAAA1D,GAAA,EAAA,UAAA,CACG4D,IAAgB,kBAACC,GAAD,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/cornerHandles-BSKbyuvQ.d.ts

@@ -1,104 +0,0 @@
-import { B as BoundsConstraint, P as PointSnapBehavior } from './clone-C0eADtS0.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"}