@weasel-js/core 1.7.0 → 1.7.2

package/dist/canvas/deps/view.js

@@ -0,0 +1,43 @@
+import { useMemo as e } from "react";
+import { useLatest as t } from "@weasel-js/react";
+//#region src/canvas/deps/view.ts
+function n(n, r, i, a, o, s, c) {
+	let l = t({
+		currentViewRef: n,
+		onViewChange: r,
+		recenter: i,
+		hostSize: a,
+		animation: o,
+		decay: s,
+		layerIsPainted: c
+	}), u = !!i, d = !!a, f = !!o, p = !!s, m = !!c;
+	return e(() => ({
+		get: () => l.current.currentViewRef.current,
+		set: (e) => {
+			l.current.animation?.stopIfExternal(), l.current.onViewChange(e);
+		},
+		...u ? { recenter: () => l.current.recenter() } : {},
+		...d ? { hostSize: () => l.current.hostSize() } : {},
+		...f ? {
+			animate: (e, t) => l.current.animation.animate(e, t),
+			stopAnimation: () => l.current.animation.stop(),
+			animationTarget: () => l.current.animation.target()
+		} : {},
+		...p ? {
+			decay: (e) => l.current.decay.start(e),
+			stopDecay: () => l.current.decay.cancel()
+		} : {},
+		...m ? { layerIsPainted: (e) => l.current.layerIsPainted(e) } : {}
+	}), [
+		l,
+		u,
+		d,
+		f,
+		p,
+		m
+	]);
+}
+//#endregion
+export { n as useViewDepSource };
+
+//# sourceMappingURL=view.js.map

package/dist/canvas/deps/view.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"view.js","names":["useViewDepSource","wiring","useLatest","hasRecenter","recenter","hasHostSize","hostSize","hasAnimation","animation","hasDecay","decay","hasLayerIsPainted","layerIsPainted","useMemo","v","to","opts","config","layerId"],"sources":["../../../src/canvas/deps/view.ts"],"sourcesContent":["/**\n * `useViewDepSource` — builds a stable `ViewApi` that reads from\n * `currentViewRef`, writes via `onViewChange`, and (when a camera runner is\n * passed) exposes animation.\n *\n * NOTE: this hook does **not** itself call `useDepSource('view', ...)` because\n * `useStandardActions` already publishes the `view` dep when it is passed in\n * its options bag. Returning the `ViewApi` here lets the registrar hand the\n * same instance to `useStandardActions` (which then registers it) without\n * having to reconstruct it inline.\n *\n * Kept as a per-dep module so the construction logic (closure refresh, ref\n * stability, etc.) has a single home next to the other dep modules.\n */\nimport { useMemo } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type React from 'react';\nimport type { ViewApi } from 'interactions/actions/depSchema';\nimport type { ViewAnimationApi } from 'core/viewport/useViewAnimation';\nimport type { DecayLoopConfig } from 'core/viewport/useDecayLoop';\nimport type { View } from 'core/viewport/view';\n\ninterface Wiring {\n  currentViewRef: React.RefObject<View>;\n  onViewChange: (v: View) => void;\n  recenter?: () => View | void;\n  hostSize?: () => { width: number; height: number } | null;\n  animation?: ViewAnimationApi;\n  decay?: DecayApi;\n  layerIsPainted?: (layerId: string) => boolean;\n}\n\n/** The slice of `useDecayLoop` the view dep republishes. */\nexport interface DecayApi {\n  start(config: DecayLoopConfig): void;\n  cancel(): void;\n}\n\nexport function useViewDepSource(\n  currentViewRef: React.RefObject<View>,\n  onViewChange: (v: View) => void,\n  recenter?: () => View | void,\n  hostSize?: () => { width: number; height: number } | null,\n  animation?: ViewAnimationApi,\n  decay?: DecayApi,\n  layerIsPainted?: (layerId: string) => boolean,\n): ViewApi {\n  // Every method reads through this, so the latest onViewChange / recenter /\n  // runner is captured without the API object itself changing identity.\n  const wiring = useLatest<Wiring>({\n    currentViewRef, onViewChange, recenter, hostSize, animation, decay, layerIsPainted,\n  });\n\n  // An unwired optional member must read falsy — `viewportZoomAction` branches\n  // on `view.recenter`, and a forwarder is truthy — so the identity-stable API\n  // is rebuilt whenever that presence set changes.\n  const hasRecenter = !!recenter;\n  const hasHostSize = !!hostSize;\n  const hasAnimation = !!animation;\n  const hasDecay = !!decay;\n  const hasLayerIsPainted = !!layerIsPainted;\n  return useMemo((): ViewApi => ({\n    get: () => wiring.current.currentViewRef.current,\n    // Not the canvas's only cancel feed (`onViewChange` is), but a `view` dep\n    // wired to something other than a `<SceneCanvas>` has only this one.\n    set: (v: View) => {\n      wiring.current.animation?.stopIfExternal();\n      wiring.current.onViewChange(v);\n    },\n    ...(hasRecenter ? { recenter: () => wiring.current.recenter!() } : {}),\n    ...(hasHostSize ? { hostSize: () => wiring.current.hostSize!() } : {}),\n    ...(hasAnimation\n      ? {\n          animate: (to: View, opts?: Parameters<ViewAnimationApi['animate']>[1]) =>\n            wiring.current.animation!.animate(to, opts),\n          stopAnimation: () => wiring.current.animation!.stop(),\n          animationTarget: () => wiring.current.animation!.target(),\n        }\n      : {}),\n    ...(hasDecay\n      ? {\n          decay: (config: DecayLoopConfig) => wiring.current.decay!.start(config),\n          stopDecay: () => wiring.current.decay!.cancel(),\n        }\n      : {}),\n    ...(hasLayerIsPainted\n      ? { layerIsPainted: (layerId: string) => wiring.current.layerIsPainted!(layerId) }\n      : {}),\n  }), [wiring, hasRecenter, hasHostSize, hasAnimation, hasDecay, hasLayerIsPainted]);\n}\n"],"mappings":";;;AAsCA,SAAgBA,EACd,GACA,GACA,GACA,GACA,GACA,GACA,GACS;CAGT,IAAMC,IAASC,EAAkB;EAC/B;EAAgB;EAAc;EAAU;EAAU;EAAW;EAAO;CACtE,CAAC,GAKKC,IAAc,CAAC,CAACC,GAChBC,IAAc,CAAC,CAACC,GAChBC,IAAe,CAAC,CAACC,GACjBC,IAAW,CAAC,CAACC,GACbC,IAAoB,CAAC,CAACC;CAC5B,OAAOC,SAAwB;EAC7B,WAAWZ,EAAO,QAAQ,eAAe;EAGzC,MAAM,MAAY;GAEhB,AADAA,EAAO,QAAQ,WAAW,eAAe,GACzCA,EAAO,QAAQ,aAAaa,CAAC;EAC/B;EACA,GAAIX,IAAc,EAAE,gBAAgBF,EAAO,QAAQ,SAAU,EAAE,IAAI,CAAC;EACpE,GAAII,IAAc,EAAE,gBAAgBJ,EAAO,QAAQ,SAAU,EAAE,IAAI,CAAC;EACpE,GAAIM,IACA;GACE,UAAU,GAAU,MAClBN,EAAO,QAAQ,UAAW,QAAQc,GAAIC,CAAI;GAC5C,qBAAqBf,EAAO,QAAQ,UAAW,KAAK;GACpD,uBAAuBA,EAAO,QAAQ,UAAW,OAAO;EAC1D,IACA,CAAC;EACL,GAAIQ,IACA;GACE,QAAQ,MAA4BR,EAAO,QAAQ,MAAO,MAAMgB,CAAM;GACtE,iBAAiBhB,EAAO,QAAQ,MAAO,OAAO;EAChD,IACA,CAAC;EACL,GAAIU,IACA,EAAE,iBAAiB,MAAoBV,EAAO,QAAQ,eAAgBiB,CAAO,EAAE,IAC/E,CAAC;CACP,IAAI;EAACjB;EAAQE;EAAaE;EAAaE;EAAcE;EAAUE;CAAiB,CAAC;AACnF"}

package/dist/canvas/derivedPath.js

@@ -0,0 +1,47 @@
+import { resolveDerivedPath as e } from "../core/scene/derivedPath.js";
+import { derivedDepOf as t } from "../core/scene/effectivePose.js";
+//#region src/canvas/derivedPath.ts
+function n(e, n) {
+	if (n === void 0) return (n) => t(e, n);
+	let i = {
+		at: n,
+		slot: s(n),
+		childrenOf: (t) => e.childrenOf(t),
+		lookup: (t) => {
+			let n = e.get(t);
+			return n === void 0 ? void 0 : new r(n, i);
+		}
+	};
+	return i.lookup;
+}
+var r = class {
+	ctx;
+	node;
+	pose;
+	constructor(e, t) {
+		this.ctx = t, this.node = e, this.pose = t.at(e);
+	}
+	get path() {
+		return e(this.node, this.ctx.lookup, this.ctx.childrenOf, this.ctx.slot);
+	}
+};
+function i(t, r) {
+	let i = n(t, r), a = r === void 0 ? void 0 : s(r), o = (e) => t.childrenOf(e);
+	return (t) => e(t, i, o, a);
+}
+var a = /* @__PURE__ */ new WeakMap(), o = 0;
+function s(e) {
+	let t = a.get(e);
+	return t === void 0 && (t = `kit:derivedPath:toPose:${o++}`, a.set(e, t)), t;
+}
+function c(e, t, n) {
+	let r = i(e, n);
+	return (e, n, i, a) => e.dependsOn === void 0 ? t(e, n, i, a) : t(e, n, i, {
+		...a,
+		derivedPath: r(e)
+	});
+}
+//#endregion
+export { e as resolveDerivedPath, n as sceneDepLookup, i as sceneDerivedPathOf, c as withDerivedPaths };
+
+//# sourceMappingURL=derivedPath.js.map

package/dist/canvas/derivedPath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"derivedPath.js","names":["sceneDepLookup","toPose","derivedDepOf","scene","id","ctx","memoSlotFor","node","SlotDep","posed","resolveDerivedPath","sceneDerivedPathOf","depOf","slot","childrenOf","toPoseSlots","nextToPoseSlot","withDerivedPaths","derivedPathOf","drawOne","pose","view"],"sources":["../../src/canvas/derivedPath.ts"],"sourcesContent":["/**\n * The render walk's half of derived paths: resolving one against a scene, and\n * handing it to the painter.\n *\n * The resolver itself lives in `core/scene/derivedPath.ts`, beside\n * `derivedPose` — a *pose* can derive from a dependency's path, so\n * `effectivePose` has to be able to reach it.\n */\nimport type { DerivedDep, Node, NodeId, Scene } from 'core/scene/types';\nimport type { Path } from '@weasel-js/geom';\nimport { derivedDepOf } from 'core/scene/effectivePose';\nimport { resolveDerivedPath } from 'core/scene/derivedPath';\nimport type { SceneViewDrawOne } from './NodeShape';\n\nexport { resolveDerivedPath } from 'core/scene/derivedPath';\n\n/**\n * `(id) => that node, the pose it is painted at, and the path it derives` —\n * resolved against the scene, so a dependency that is itself derived resolves\n * before it is read.\n *\n * `Scene` stores absolute poses and the render walks hand `getPose` straight to\n * `drawOne`, composing nothing, so this has to read exactly what the render\n * adapters read: a derived edge is drawn from these coordinates and must meet\n * the nodes it connects. A slot's `toPose` replaces that read, so `toPose`\n * replaces it here too.\n */\nexport function sceneDepLookup<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  toPose?: (node: Node<TData, TLayer, TPose>) => TPose,\n): (id: NodeId) => DerivedDep<TPose> | undefined {\n  if (toPose === undefined) return (id) => derivedDepOf(scene, id);\n  const ctx: SlotLookup<TPose> = {\n    at: toPose as (node: unknown) => TPose,\n    slot: memoSlotFor(toPose),\n    childrenOf: (id: NodeId) => scene.childrenOf(id),\n    lookup: (id: NodeId) => {\n      const node = scene.get(id);\n      return node === undefined ? undefined : new SlotDep(node, ctx);\n    },\n  };\n  return ctx.lookup;\n}\n\ninterface SlotLookup<TPose> {\n  at: (node: unknown) => TPose;\n  slot: string;\n  childrenOf: (id: NodeId) => readonly NodeId[];\n  lookup: (id: NodeId) => DerivedDep<TPose> | undefined;\n}\n\n/** A class, not an object literal with a `get path()` — see `SceneDep` in\n *  `core/scene/effectivePose.ts` for why. */\nclass SlotDep<TPose> implements DerivedDep<TPose> {\n  readonly node: Node<unknown, string, TPose>;\n  readonly pose: TPose;\n\n  constructor(posed: unknown, private readonly ctx: SlotLookup<TPose>) {\n    this.node = posed as Node<unknown, string, TPose>;\n    this.pose = ctx.at(posed);\n  }\n\n  get path(): Path | null {\n    return resolveDerivedPath(\n      this.node as never, this.ctx.lookup, this.ctx.childrenOf, this.ctx.slot,\n    );\n  }\n}\n\n/** `(node) => the path it derives`, read through {@link sceneDepLookup}. */\nexport function sceneDerivedPathOf<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  toPose?: (node: Node<TData, TLayer, TPose>) => TPose,\n): (node: Node<TData, TLayer, TPose>) => Path | null {\n  const depOf = sceneDepLookup(scene, toPose);\n  const slot = toPose === undefined ? undefined : memoSlotFor(toPose);\n  const childrenOf = (id: NodeId): readonly NodeId[] => scene.childrenOf(id);\n  return (node) => resolveDerivedPath(node, depOf, childrenOf, slot);\n}\n\nconst toPoseSlots = new WeakMap<object, string>();\nlet nextToPoseSlot = 0;\n\n/** One memo slot per `toPose`: two slots painting one scene at different\n *  poses must not serve each other's paths. */\nfunction memoSlotFor(toPose: object): string {\n  let slot = toPoseSlots.get(toPose);\n  if (slot === undefined) {\n    slot = `kit:derivedPath:toPose:${nextToPoseSlot++}`;\n    toPoseSlots.set(toPose, slot);\n  }\n  return slot;\n}\n\n/**\n * Wrap a `drawOne` so a node that derives its geometry arrives at the painter\n * with the resolved path. The painter has no scene handle and so cannot read\n * the dependencies' poses itself; both scene walks wrap here instead.\n *\n * A node that derives nothing passes the caller's `ctx` through untouched —\n * this runs per node per frame, and an added `{ derivedPath: null }` would be\n * an allocation per node for a field no painter reads.\n */\nexport function withDerivedPaths<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  drawOne: SceneViewDrawOne<TData, TLayer, TPose>,\n  toPose?: (node: Node<TData, TLayer, TPose>) => TPose,\n): SceneViewDrawOne<TData, TLayer, TPose> {\n  const derivedPathOf = sceneDerivedPathOf(scene, toPose);\n  return (node, pose, view, ctx) => {\n    if (node.dependsOn === undefined) return drawOne(node, pose, view, ctx);\n    return drawOne(node, pose, view, { ...ctx, derivedPath: derivedPathOf(node) });\n  };\n}\n"],"mappings":";;;AA2BA,SAAgBA,EACd,GACA,GAC+C;CAC/C,IAAIC,MAAW,KAAA,GAAW,QAAQ,MAAOC,EAAaC,GAAOC,CAAE;CAC/D,IAAMC,IAAyB;EAC7B,IAAIJ;EACJ,MAAMK,EAAYL,CAAM;EACxB,aAAa,MAAeE,EAAM,WAAWC,CAAE;EAC/C,SAAS,MAAe;GACtB,IAAMG,IAAOJ,EAAM,IAAIC,CAAE;GACzB,OAAOG,MAAS,KAAA,IAAY,KAAA,IAAY,IAAIC,EAAQD,GAAMF,CAAG;EAC/D;CACF;CACA,OAAOA,EAAI;AACb;AAWA,IAAMG,IAAN,MAAkD;CAIH;CAH7C;CACA;CAEA,YAAY,GAAgB,GAAyC;EAEnE,AAF2C,KAAA,MAAAH,GAC3C,KAAK,OAAOI,GACZ,KAAK,OAAOJ,EAAI,GAAGI,CAAK;CAC1B;CAEA,IAAI,OAAoB;EACtB,OAAOC,EACL,KAAK,MAAe,KAAK,IAAI,QAAQ,KAAK,IAAI,YAAY,KAAK,IAAI,IACrE;CACF;AACF;AAGA,SAAgBC,EACd,GACA,GACmD;CACnD,IAAMC,IAAQZ,EAAeG,GAAOF,CAAM,GACpCY,IAAOZ,MAAW,KAAA,IAAY,KAAA,IAAYK,EAAYL,CAAM,GAC5Da,KAAc,MAAkCX,EAAM,WAAWC,CAAE;CACzE,QAAQ,MAASM,EAAmBH,GAAMK,GAAOE,GAAYD,CAAI;AACnE;AAEA,IAAME,oBAAc,IAAI,QAAwB,GAC5CC,IAAiB;AAIrB,SAASV,EAAY,GAAwB;CAC3C,IAAIO,IAAOE,EAAY,IAAId,CAAM;CAKjC,OAJIY,MAAS,KAAA,MACX,IAAO,0BAA0B,OACjCE,EAAY,IAAId,GAAQY,CAAI,IAEvBA;AACT;AAWA,SAAgBI,EACd,GACA,GACA,GACwC;CACxC,IAAMC,IAAgBP,EAAmBR,GAAOF,CAAM;CACtD,QAAQ,GAAM,GAAM,GAAM,MACpBM,EAAK,cAAc,KAAA,IAAkBY,EAAQZ,GAAMa,GAAMC,GAAMhB,CAAG,IAC/Dc,EAAQZ,GAAMa,GAAMC,GAAM;EAAE,GAAGhB;EAAK,aAAaa,EAAcX,CAAI;CAAE,CAAC;AAEjF"}

package/dist/canvas/drawEnvelope.js

@@ -0,0 +1,22 @@
+//#region src/canvas/drawEnvelope.ts
+function e(e, t) {
+	let n = e;
+	return typeof n?.[t] == "function" ? n[t] : void 0;
+}
+function t(t) {
+	return e(t, "getChromeState")?.() ?? null;
+}
+function n(t) {
+	return e(t, "getIsVisible")?.() ?? null;
+}
+function r(t) {
+	return e(t, "getPreviewSources")?.() ?? a;
+}
+function i(t) {
+	return e(t, "getGestureOverlays")?.() ?? o;
+}
+var a = [], o = [];
+//#endregion
+export { t as chromeStateFrom, i as gestureOverlaysFrom, n as isVisibleFrom, r as previewSourcesFrom };
+
+//# sourceMappingURL=drawEnvelope.js.map

package/dist/canvas/drawEnvelope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"drawEnvelope.js","names":["thunk","maybe","data","key","chromeStateFrom","isVisibleFrom","previewSourcesFrom","EMPTY_SOURCES","gestureOverlaysFrom","EMPTY_OVERLAYS"],"sources":["../../src/canvas/drawEnvelope.ts"],"sourcesContent":["/**\n * Reading a layer's draw envelope.\n *\n * Every `RenderLayer.draw` receives the drawing view's {@link CanvasHelpers} as\n * its `data` argument, and `<CanvasView>` overlays its own half before handing\n * the stack to a second camera. A layer that answers from a construction\n * closure instead therefore answers for view zero in every view — so these\n * lookups exist to make the envelope the easy source.\n *\n * A layer drawn by a bare consumer may get plain data instead, which is why\n * each reader has an \"unwired\" answer rather than throwing.\n */\nimport type { ChromeState } from 'core/selection/chromeState';\nimport type { OngoingOverlay } from '@weasel-js/routing';\nimport type { GesturePreviewSource } from './gestureBounds';\nimport type { CanvasViewHelpers } from './useViewHelpers';\n\ntype PartialEnvelope = Partial<CanvasViewHelpers<unknown>>;\n\nfunction thunk<K extends keyof CanvasViewHelpers<unknown>>(\n  data: unknown,\n  key: K,\n): CanvasViewHelpers<unknown>[K] | undefined {\n  const maybe = data as PartialEnvelope | null | undefined;\n  return typeof maybe?.[key] === 'function' ? maybe[key] : undefined;\n}\n\n/** This view's chrome state, or `null` when the caller passed plain data. */\nexport function chromeStateFrom(data: unknown): ChromeState | null {\n  return thunk(data, 'getChromeState')?.() ?? null;\n}\n\n/** This view's chrome-caps predicate, or `null` when the caller passed plain\n *  data — the layer then paints unconditionally. */\nexport function isVisibleFrom(data: unknown): ((id: string) => boolean) | null {\n  return thunk(data, 'getIsVisible')?.() ?? null;\n}\n\n/** This view's in-flight preview surfaces, in resolution order. Empty when\n *  nothing is in flight and when the caller passed plain data. */\nexport function previewSourcesFrom(data: unknown): readonly GesturePreviewSource[] {\n  return thunk(data, 'getPreviewSources')?.() ?? EMPTY_SOURCES;\n}\n\n/** The overlay shapes this view's in-flight handles publish. */\nexport function gestureOverlaysFrom(data: unknown): readonly OngoingOverlay[] {\n  return thunk(data, 'getGestureOverlays')?.() ?? EMPTY_OVERLAYS;\n}\n\n/** First non-null `previewPose(id)` across `sources`, or `null`. */\nexport function previewPoseIn(\n  sources: readonly GesturePreviewSource[],\n  id: string,\n): unknown {\n  for (const s of sources) {\n    const p = s.previewPose?.(id);\n    if (p != null) return p;\n  }\n  return null;\n}\n\n/** First non-null `previewData(id)` across `sources`, or `null`. */\nexport function previewDataIn(\n  sources: readonly GesturePreviewSource[],\n  id: string,\n): unknown {\n  for (const s of sources) {\n    const d = s.previewData?.(id);\n    if (d != null) return d;\n  }\n  return null;\n}\n\nconst EMPTY_SOURCES: readonly GesturePreviewSource[] = [];\nconst EMPTY_OVERLAYS: readonly OngoingOverlay[] = [];\n"],"mappings":";AAmBA,SAASA,EACP,GACA,GAC2C;CAC3C,IAAMC,IAAQC;CACd,OAAO,OAAOD,IAAQE,MAAS,aAAaF,EAAME,KAAO,KAAA;AAC3D;AAGA,SAAgBC,EAAgB,GAAmC;CACjE,OAAOJ,EAAME,GAAM,gBAAgB,CAAC,GAAG,KAAK;AAC9C;AAIA,SAAgBG,EAAc,GAAiD;CAC7E,OAAOL,EAAME,GAAM,cAAc,CAAC,GAAG,KAAK;AAC5C;AAIA,SAAgBI,EAAmB,GAAgD;CACjF,OAAON,EAAME,GAAM,mBAAmB,CAAC,GAAG,KAAKK;AACjD;AAGA,SAAgBC,EAAoB,GAA0C;CAC5E,OAAOR,EAAME,GAAM,oBAAoB,CAAC,GAAG,KAAKO;AAClD;AA0BA,IAAMF,IAAiD,CAAC,GAClDE,IAA4C,CAAC"}

package/dist/canvas/getNodeAtPoint.js

@@ -0,0 +1,18 @@
+//#region src/canvas/getNodeAtPoint.ts
+function e(e, t) {
+	return (n, r, i) => {
+		let a = e(n, r, i), o = Array.isArray(a) ? a[0] ?? null : a;
+		if (o == null) return null;
+		let s = t?.(o) ?? null;
+		return {
+			id: o,
+			kind: s?.kind ?? "unknown",
+			pose: s?.pose,
+			data: s?.data ?? { id: o }
+		};
+	};
+}
+//#endregion
+export { e as makeGetNodeAtPoint };
+
+//# sourceMappingURL=getNodeAtPoint.js.map

package/dist/canvas/getNodeAtPoint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getNodeAtPoint.js","names":["makeGetNodeAtPoint","raw","pickEvery","wx","wy","view","id","resolved","nodeResolver"],"sources":["../../src/canvas/getNodeAtPoint.ts"],"sourcesContent":["/**\n * Stable helper for synthesizing the dispatcher's `getNodeAtPoint` callback\n * from a `pickEvery` function and an optional per-id node resolver.\n *\n * Extracted from `Canvas.tsx`'s inline `__setGetNodeAtPoint` synthesizer so\n * that `SceneCanvas` (and any other scene-aware wrapper) can build the\n * function externally and hand it to `<Canvas>` as a prop. The caller supplies\n * a `nodeResolver` that derives each hit's kind/pose/data (SceneCanvas\n * classifies the node's `data` via its routing registry).\n */\n\nimport type { PickView } from './SceneCanvas/useSceneSelectTool';\n\n/** The hit record returned by a `getNodeAtPoint` function.  Matches the\n *  shape expected by `ToolsDispatcher.__setGetNodeAtPoint`. */\nexport interface NodeAtPointHit {\n  id: string;\n  kind: string;\n  pose: unknown;\n  data: unknown;\n  meta?: Record<string, unknown>;\n}\n\n/**\n * Resolves per-id metadata for a node (kind, pose, data). When absent,\n * kind falls back to `'unknown'` and pose/data fall back to trivial values.\n */\nexport type NodeResolver = (id: string) => { kind: string; pose: unknown; data: unknown } | null;\n\n/**\n * Build a stable `getNodeAtPoint(wx, wy)` function suitable for passing to\n * the tool dispatcher via `Canvas`'s `getNodeAtPoint` prop.\n *\n * Algorithm matches the inline synthesizer in Canvas.tsx exactly:\n * - `pickEvery` returns `string | string[] | null`\n * - When an array, the **first** element is the topmost id (front-to-back order)\n * - `nodeResolver` is called for the topmost id to get kind/pose/data\n * - When `nodeResolver` is absent or returns null, kind defaults to `'unknown'`,\n *   pose to `undefined`, data to `{ id }`\n *\n * @param pickEvery  Raw hit-test function. Same signature as the Canvas prop.\n * @param nodeResolver  Optional per-id resolver. SceneCanvas builds this from its adapter.\n */\nexport function makeGetNodeAtPoint(\n  pickEvery: (wx: number, wy: number, view?: PickView | null) => string | string[] | null,\n  nodeResolver?: NodeResolver,\n): (wx: number, wy: number, view?: PickView | null) => NodeAtPointHit | null {\n  return (wx: number, wy: number, view?: PickView | null): NodeAtPointHit | null => {\n    const raw = pickEvery(wx, wy, view);\n    // Normalize `string | string[] | null` to topmost id (first entry).\n    const id = Array.isArray(raw) ? raw[0] ?? null : raw;\n    if (id == null) return null;\n\n    const resolved = nodeResolver?.(id) ?? null;\n    const kind = resolved?.kind ?? 'unknown';\n    const pose = resolved?.pose;\n    const data = resolved?.data ?? { id };\n\n    return { id, kind, pose, data };\n  };\n}\n"],"mappings":";AA2CA,SAAgBA,EACd,GACA,GAC2E;CAC3E,QAAQ,GAAY,GAAY,MAAkD;EAChF,IAAMC,IAAMC,EAAUC,GAAIC,GAAIC,CAAI,GAE5BC,IAAK,MAAM,QAAQL,CAAG,IAAIA,EAAI,MAAM,OAAOA;EACjD,IAAIK,KAAM,MAAM,OAAO;EAEvB,IAAMC,IAAWC,IAAeF,CAAE,KAAK;EAKvC,OAAO;GAAE;GAAI,MAJAC,GAAU,QAAQ;GAIZ,MAHNA,GAAU;GAGE,MAFZA,GAAU,QAAQ,EAAE,MAAG;EAEN;CAChC;AACF"}

package/dist/canvas/hostAnchor.js

@@ -0,0 +1,29 @@
+import { clampRectWithin as e } from "@weasel-js/geom";
+//#region src/canvas/hostAnchor.ts
+function t(e, t, n, r, i) {
+	return r === "start" ? e + i : r === "end" ? e + t - n - i : e + (t - n) / 2 + i;
+}
+function n(n) {
+	let { host: r, panel: i, viewport: a, align: o, offset: s, padding: c = 0 } = n, l = {
+		x: t(r.x, r.width, i.width, o.x, s.x),
+		y: t(r.y, r.height, i.height, o.y, s.y),
+		width: i.width,
+		height: i.height
+	};
+	return e(l, {
+		x: 0,
+		y: 0,
+		width: a.width,
+		height: a.height
+	}, c);
+}
+function r(e, t, n) {
+	return {
+		...t.y === "end" ? { bottom: n.height - e.y - e.height } : { top: e.y },
+		...t.x === "end" ? { right: n.width - e.x - e.width } : { left: e.x }
+	};
+}
+//#endregion
+export { r as hostAnchorCss, n as hostAnchorRect };
+
+//# sourceMappingURL=hostAnchor.js.map

package/dist/canvas/hostAnchor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hostAnchor.js","names":["insetAlong","align","start","by","extent","size","hostAnchorRect","input","desired","host","panel","offset","clampRectWithin","viewport","padding","hostAnchorCss","rect"],"sources":["../../src/canvas/hostAnchor.ts"],"sourcesContent":["import { clampRectWithin, type PlacementAlign, type Rect } from '@weasel-js/geom';\n\n/** Which of the host's edges the panel is held against, per axis. */\nexport interface HostAnchorAlign {\n  x: PlacementAlign;\n  y: PlacementAlign;\n}\n\n/** Inset from the anchored corner, in CSS pixels, positive going inward. */\nexport interface HostAnchorOffset {\n  x: number;\n  y: number;\n}\n\n/** Everything {@link hostAnchorRect} needs, all in viewport coordinates. */\nexport interface HostAnchorInput {\n  host: Rect;\n  panel: { width: number; height: number };\n  viewport: { width: number; height: number };\n  align: HostAnchorAlign;\n  offset: HostAnchorOffset;\n  /** Minimum gap kept between the panel and the viewport edge. Default 0. */\n  padding?: number;\n}\n\nfunction insetAlong(start: number, extent: number, size: number, align: PlacementAlign, by: number): number {\n  if (align === 'start') return start + by;\n  if (align === 'end') return start + extent - size - by;\n  return start + (extent - size) / 2 + by;\n}\n\n/**\n * Where a fixed-position panel held against a host element's corner lands, once\n * it has been kept inside the viewport. Returns a rect rather than CSS so the\n * caller decides which edges to pin — see {@link hostAnchorCss}.\n */\nexport function hostAnchorRect(input: HostAnchorInput): Rect {\n  const { host, panel, viewport, align, offset, padding = 0 } = input;\n  const desired: Rect = {\n    x: insetAlong(host.x, host.width, panel.width, align.x, offset.x),\n    y: insetAlong(host.y, host.height, panel.height, align.y, offset.y),\n    width: panel.width,\n    height: panel.height,\n  };\n  return clampRectWithin(desired, { x: 0, y: 0, width: viewport.width, height: viewport.height }, padding);\n}\n\n/**\n * CSS for a resolved rect, pinning whichever edges the alignment names.\n *\n * Pinning matters beyond taste: a panel whose width tracks its content holds\n * the anchored edge still and grows away from it. Pin the wrong edge and the\n * anchored corner drifts on every content change, correcting only once a\n * resize observer catches up.\n */\nexport function hostAnchorCss(\n  rect: Rect,\n  align: HostAnchorAlign,\n  viewport: { width: number; height: number },\n): { top?: number; right?: number; bottom?: number; left?: number } {\n  return {\n    ...(align.y === 'end'\n      ? { bottom: viewport.height - rect.y - rect.height }\n      : { top: rect.y }),\n    ...(align.x === 'end'\n      ? { right: viewport.width - rect.x - rect.width }\n      : { left: rect.x }),\n  };\n}\n"],"mappings":";;AAyBA,SAASA,EAAW,GAAe,GAAgB,GAAc,GAAuB,GAAoB;CAG1G,OAFIC,MAAU,UAAgBC,IAAQC,IAClCF,MAAU,QAAcC,IAAQE,IAASC,IAAOF,IAC7CD,KAASE,IAASC,KAAQ,IAAIF;AACvC;AAOA,SAAgBG,EAAe,GAA8B;CAC3D,IAAM,EAAE,SAAM,UAAO,aAAU,UAAO,WAAQ,aAAU,MAAMC,GACxDC,IAAgB;EACpB,GAAGR,EAAWS,EAAK,GAAGA,EAAK,OAAOC,EAAM,OAAOT,EAAM,GAAGU,EAAO,CAAC;EAChE,GAAGX,EAAWS,EAAK,GAAGA,EAAK,QAAQC,EAAM,QAAQT,EAAM,GAAGU,EAAO,CAAC;EAClE,OAAOD,EAAM;EACb,QAAQA,EAAM;CAChB;CACA,OAAOE,EAAgBJ,GAAS;EAAE,GAAG;EAAG,GAAG;EAAG,OAAOK,EAAS;EAAO,QAAQA,EAAS;CAAO,GAAGC,CAAO;AACzG;AAUA,SAAgBC,EACd,GACA,GACA,GACkE;CAClE,OAAO;EACL,GAAId,EAAM,MAAM,QACZ,EAAE,QAAQY,EAAS,SAASG,EAAK,IAAIA,EAAK,OAAO,IACjD,EAAE,KAAKA,EAAK,EAAE;EAClB,GAAIf,EAAM,MAAM,QACZ,EAAE,OAAOY,EAAS,QAAQG,EAAK,IAAIA,EAAK,MAAM,IAC9C,EAAE,MAAMA,EAAK,EAAE;CACrB;AACF"}

package/dist/canvas/hud.module.js

@@ -0,0 +1,18 @@
+//#region src/canvas/hud.module.css
+var e = "_hud_1hv8c_3", t = "_sized_1hv8c_17", n = "_readings_1hv8c_22 _numeric_zns9n_4", r = "_muted_1hv8c_39", i = "_absent_1hv8c_44", a = "_header_1hv8c_49", o = "_list_1hv8c_53", s = "_item_1hv8c_62", c = "_itemBest_1hv8c_68", l = "_row_1hv8c_72", u = "_stack_1hv8c_79", d = {
+	hud: e,
+	sized: t,
+	readings: n,
+	muted: r,
+	absent: i,
+	header: a,
+	list: o,
+	item: s,
+	itemBest: c,
+	row: l,
+	stack: u
+};
+//#endregion
+export { i as absent, d as default, a as header, e as hud, s as item, c as itemBest, o as list, r as muted, n as readings, l as row, t as sized, u as stack };
+
+//# sourceMappingURL=hud.module.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hud.module.js","names":["hud","sized","readings","muted","absent","header","list","item","itemBest","row","stack","hud_module_default"],"sources":["../../src/canvas/hud.module.css"],"sourcesContent":["/* The debug HUDs <Canvas> can draw: CursorCoordsHud, PickHud, ModalityHud. The\n   mono face is for the ids the pick and modality HUDs list; figures take the\n   numeric face, on a child so `.hud`'s own font cannot override it. */\n.hud {\n  position: fixed;\n  z-index: 10000;\n  background: rgba(0, 0, 0, 0.7);\n  color: #e8e8e8;\n  font: 11px ui-monospace, SFMono-Regular, Menlo, monospace;\n  padding: 6px 8px;\n  border-radius: 4px;\n  pointer-events: none;\n  line-height: 1.4;\n  text-align: right;\n}\n\n.sized {\n  min-width: 120px;\n  max-width: 260px;\n}\n\n.readings {\n  composes: numeric from '@weasel-js/theme/numeric.module.css';\n  display: grid;\n  grid-template-columns: auto auto;\n  column-gap: 8px;\n  margin: 0;\n}\n\n.readings dt {\n  text-align: left;\n}\n\n.readings dd {\n  margin: 0;\n  white-space: nowrap;\n}\n\n.muted {\n  color: #888;\n}\n\n/* A value that is not there: an em dash, \"off-canvas\". */\n.absent {\n  color: #888;\n  font-style: italic;\n}\n\n.header {\n  margin-bottom: 2px;\n}\n\n.list {\n  list-style: none;\n  margin: 0;\n  padding: 0;\n  display: flex;\n  flex-direction: column;\n  gap: 1px;\n}\n\n.item {\n  white-space: nowrap;\n  overflow: hidden;\n  text-overflow: ellipsis;\n}\n\n.itemBest {\n  font-weight: 700;\n}\n\n.row {\n  display: flex;\n  gap: 8px;\n  justify-content: flex-end;\n  white-space: nowrap;\n}\n\n.stack {\n  display: flex;\n  flex-direction: column;\n  align-items: flex-end;\n}\n"],"mappings":""}

package/dist/canvas/insertPreviewExtent.js

@@ -0,0 +1,103 @@
+//#region src/canvas/insertPreviewExtent.ts
+function e(e) {
+	let r = e.bounds, i = {
+		x: r.x,
+		y: r.y,
+		width: r.width,
+		height: r.height
+	};
+	switch (e.shape) {
+		case "line": {
+			let t = e.extras, a = t.a ?? {
+				x: r.x,
+				y: r.y
+			}, o = t.b ?? {
+				x: r.x + r.width,
+				y: r.y + r.height
+			};
+			return {
+				shape: e.shape,
+				bounds: n([a, o]) ?? i,
+				geometry: {
+					kind: "line",
+					a,
+					b: o
+				}
+			};
+		}
+		case "polygon": {
+			let n = e.extras, i = n.center ?? {
+				x: r.x + r.width / 2,
+				y: r.y + r.height / 2
+			}, a = n.radius ?? Math.min(r.width, r.height) / 2;
+			return {
+				shape: e.shape,
+				bounds: t(i, a),
+				geometry: {
+					kind: "polygon",
+					center: i,
+					radius: a,
+					sides: Math.max(3, Math.floor(n.sides ?? 6)),
+					rotation: n.rotation ?? 0
+				}
+			};
+		}
+		case "star": {
+			let n = e.extras, i = n.center ?? {
+				x: r.x + r.width / 2,
+				y: r.y + r.height / 2
+			}, a = n.outerRadius ?? Math.min(r.width, r.height) / 2;
+			return {
+				shape: e.shape,
+				bounds: t(i, a),
+				geometry: {
+					kind: "star",
+					center: i,
+					outerRadius: a,
+					innerRadius: a * (n.innerRadiusRatio ?? .5),
+					points: Math.max(3, Math.floor(n.points ?? 5)),
+					rotation: n.rotation ?? 0
+				}
+			};
+		}
+		case "pencil": {
+			let t = e.extras.samples ?? [];
+			return {
+				shape: e.shape,
+				bounds: n(t) ?? i,
+				geometry: {
+					kind: "pencil",
+					samples: t
+				}
+			};
+		}
+		default: return {
+			shape: e.shape,
+			bounds: i,
+			geometry: { kind: "box" }
+		};
+	}
+}
+function t(e, t) {
+	return {
+		x: e.x - t,
+		y: e.y - t,
+		width: t * 2,
+		height: t * 2
+	};
+}
+function n(e) {
+	if (e.length === 0) return null;
+	let t = Infinity, n = Infinity, r = -Infinity, i = -Infinity;
+	for (let a of e) a.x < t && (t = a.x), a.y < n && (n = a.y), a.x > r && (r = a.x), a.y > i && (i = a.y);
+	return {
+		x: t,
+		y: n,
+		width: r - t,
+		height: i - n
+	};
+}
+//#endregion
+export { e as insertPreviewExtent };
+
+//# sourceMappingURL=insertPreviewExtent.js.map

package/dist/canvas/insertPreviewExtent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"insertPreviewExtent.js","names":["insertPreviewExtent","b","ov","box","e","b2","aabbOf","center","radius","radialBox","outerRadius","samples","pts","minX","minY","maxX","maxY","p"],"sources":["../../src/canvas/insertPreviewExtent.ts"],"sourcesContent":["/**\n * The one answer to \"how big is the thing this in-flight insert is making\".\n *\n * A drag-to-insert has no scene node until commit, so three surfaces have to\n * size the nascent shape themselves: `useDispatcherOverlayLayer` (paints the\n * preview), `canvas/deps/insert` (poses the committed node) and\n * `dispatcherGestureBounds` (reports the gesture's world AABB to `<Canvas>`).\n * They all resolve it here.\n *\n * The drag AABB alone is NOT the answer. `insertAction` hands over an\n * `extras` payload that can carry richer geometry than the drag rect —\n * a polygon's center+radius, a pencil's sample trail, a line's endpoints —\n * and where it does, that geometry is the shape. A centered Alt-drag\n * produces a `d`-wide drag rect around a `d√2` circumradius; a pencil that\n * loops back to its start produces a zero-area drag rect around a trail that\n * swept the page.\n */\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { OngoingOverlay } from '@weasel-js/routing';\n\ntype Point = { x: number; y: number };\n\n/** The fields of an `insertPreview` overlay this needs. `canvas/deps/insert`\n *  passes the equivalent from its own `(bounds, extras)` commit arguments. */\nexport interface InsertPreviewLike {\n  shape: string;\n  bounds: { x: number; y: number; width: number; height: number };\n  extras: unknown;\n}\n\n/** Resolved preview geometry, in the terms the path builders take. */\nexport type InsertPreviewGeometry =\n  | { kind: 'box' }\n  | { kind: 'line'; a: Point; b: Point }\n  | { kind: 'polygon'; center: Point; radius: number; sides: number; rotation: number }\n  | {\n      kind: 'star';\n      center: Point;\n      outerRadius: number;\n      innerRadius: number;\n      points: number;\n      rotation: number;\n    }\n  | { kind: 'pencil'; samples: ReadonlyArray<Point> };\n\n/** An in-flight insert's shape, resolved from its drag rect and `extras`. */\nexport interface InsertPreviewExtent {\n  /** The insert kind, verbatim from the caller. */\n  shape: string;\n  /** World-space AABB of `geometry` — the extent. */\n  bounds: Bounds;\n  geometry: InsertPreviewGeometry;\n}\n\n/** The `insertPreview` member of `OngoingOverlay`, which `insertAction` publishes during a drag-to-insert. */\nexport type InsertPreviewOverlay = Extract<OngoingOverlay, { kind: 'insertPreview' }>;\n\n/** Resolve an in-flight insert's geometry and world AABB. Uses the geometry in\n *  `extras` where the shape carries it; an unknown shape falls back to its drag rect. */\nexport function insertPreviewExtent(ov: InsertPreviewLike): InsertPreviewExtent {\n  const b = ov.bounds;\n  const box = { x: b.x, y: b.y, width: b.width, height: b.height };\n\n  switch (ov.shape) {\n    case 'line': {\n      const e = ov.extras as Partial<{ a: Point; b: Point }>;\n      const a = e.a ?? { x: b.x, y: b.y };\n      const b2 = e.b ?? { x: b.x + b.width, y: b.y + b.height };\n      return { shape: ov.shape, bounds: aabbOf([a, b2]) ?? box, geometry: { kind: 'line', a, b: b2 } };\n    }\n    case 'polygon': {\n      const e = ov.extras as Partial<{\n        sides: number; rotation: number; center: Point; radius: number;\n      }>;\n      const center = e.center ?? { x: b.x + b.width / 2, y: b.y + b.height / 2 };\n      const radius = e.radius ?? Math.min(b.width, b.height) / 2;\n      return {\n        shape: ov.shape,\n        bounds: radialBox(center, radius),\n        geometry: {\n          kind: 'polygon',\n          center,\n          radius,\n          sides: Math.max(3, Math.floor(e.sides ?? 6)),\n          rotation: e.rotation ?? 0,\n        },\n      };\n    }\n    case 'star': {\n      const e = ov.extras as Partial<{\n        points: number; innerRadiusRatio: number; rotation: number;\n        center: Point; outerRadius: number;\n      }>;\n      const center = e.center ?? { x: b.x + b.width / 2, y: b.y + b.height / 2 };\n      const outerRadius = e.outerRadius ?? Math.min(b.width, b.height) / 2;\n      return {\n        shape: ov.shape,\n        bounds: radialBox(center, outerRadius),\n        geometry: {\n          kind: 'star',\n          center,\n          outerRadius,\n          innerRadius: outerRadius * (e.innerRadiusRatio ?? 0.5),\n          points: Math.max(3, Math.floor(e.points ?? 5)),\n          rotation: e.rotation ?? 0,\n        },\n      };\n    }\n    case 'pencil': {\n      const e = ov.extras as Partial<{ samples: ReadonlyArray<Point> }>;\n      const samples = e.samples ?? [];\n      return {\n        shape: ov.shape,\n        bounds: aabbOf(samples) ?? box,\n        geometry: { kind: 'pencil', samples },\n      };\n    }\n    default:\n      return { shape: ov.shape, bounds: box, geometry: { kind: 'box' } };\n  }\n}\n\n/** A radial shape's extent is its circumscribed square, not the drag rect. */\nfunction radialBox(center: Point, radius: number): Bounds {\n  return { x: center.x - radius, y: center.y - radius, width: radius * 2, height: radius * 2 };\n}\n\nfunction aabbOf(pts: ReadonlyArray<Point>): Bounds | null {\n  if (pts.length === 0) return null;\n  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;\n  for (const p of pts) {\n    if (p.x < minX) minX = p.x;\n    if (p.y < minY) minY = p.y;\n    if (p.x > maxX) maxX = p.x;\n    if (p.y > maxY) maxY = p.y;\n  }\n  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };\n}\n"],"mappings":";AA2DA,SAAgBA,EAAoB,GAA4C;CAC9E,IAAMC,IAAIC,EAAG,QACPC,IAAM;EAAE,GAAGF,EAAE;EAAG,GAAGA,EAAE;EAAG,OAAOA,EAAE;EAAO,QAAQA,EAAE;CAAO;CAE/D,QAAQC,EAAG,OAAX;EACE,KAAK,QAAQ;GACX,IAAME,IAAIF,EAAG,QACP,IAAIE,EAAE,KAAK;IAAE,GAAGH,EAAE;IAAG,GAAGA,EAAE;GAAE,GAC5BI,IAAKD,EAAE,KAAK;IAAE,GAAGH,EAAE,IAAIA,EAAE;IAAO,GAAGA,EAAE,IAAIA,EAAE;GAAO;GACxD,OAAO;IAAE,OAAOC,EAAG;IAAO,QAAQI,EAAO,CAAC,GAAGD,CAAE,CAAC,KAAKF;IAAK,UAAU;KAAE,MAAM;KAAQ;KAAG,GAAGE;IAAG;GAAE;EACjG;EACA,KAAK,WAAW;GACd,IAAMD,IAAIF,EAAG,QAGPK,IAASH,EAAE,UAAU;IAAE,GAAGH,EAAE,IAAIA,EAAE,QAAQ;IAAG,GAAGA,EAAE,IAAIA,EAAE,SAAS;GAAE,GACnEO,IAASJ,EAAE,UAAU,KAAK,IAAIH,EAAE,OAAOA,EAAE,MAAM,IAAI;GACzD,OAAO;IACL,OAAOC,EAAG;IACV,QAAQO,EAAUF,GAAQC,CAAM;IAChC,UAAU;KACR,MAAM;KACN;KACA;KACA,OAAO,KAAK,IAAI,GAAG,KAAK,MAAMJ,EAAE,SAAS,CAAC,CAAC;KAC3C,UAAUA,EAAE,YAAY;IAC1B;GACF;EACF;EACA,KAAK,QAAQ;GACX,IAAMA,IAAIF,EAAG,QAIPK,IAASH,EAAE,UAAU;IAAE,GAAGH,EAAE,IAAIA,EAAE,QAAQ;IAAG,GAAGA,EAAE,IAAIA,EAAE,SAAS;GAAE,GACnES,IAAcN,EAAE,eAAe,KAAK,IAAIH,EAAE,OAAOA,EAAE,MAAM,IAAI;GACnE,OAAO;IACL,OAAOC,EAAG;IACV,QAAQO,EAAUF,GAAQG,CAAW;IACrC,UAAU;KACR,MAAM;KACN;KACA;KACA,aAAaA,KAAeN,EAAE,oBAAoB;KAClD,QAAQ,KAAK,IAAI,GAAG,KAAK,MAAMA,EAAE,UAAU,CAAC,CAAC;KAC7C,UAAUA,EAAE,YAAY;IAC1B;GACF;EACF;EACA,KAAK,UAAU;GAEb,IAAMO,IADIT,EAAG,OACK,WAAW,CAAC;GAC9B,OAAO;IACL,OAAOA,EAAG;IACV,QAAQI,EAAOK,CAAO,KAAKR;IAC3B,UAAU;KAAE,MAAM;KAAU;IAAQ;GACtC;EACF;EACA,SACE,OAAO;GAAE,OAAOD,EAAG;GAAO,QAAQC;GAAK,UAAU,EAAE,MAAM,MAAM;EAAE;CACrE;AACF;AAGA,SAASM,EAAU,GAAe,GAAwB;CACxD,OAAO;EAAE,GAAGF,EAAO,IAAIC;EAAQ,GAAGD,EAAO,IAAIC;EAAQ,OAAOA,IAAS;EAAG,QAAQA,IAAS;CAAE;AAC7F;AAEA,SAASF,EAAO,GAA0C;CACxD,IAAIM,EAAI,WAAW,GAAG,OAAO;CAC7B,IAAIC,IAAO,UAAUC,IAAO,UAAUC,IAAO,WAAWC,IAAO;CAC/D,KAAK,IAAMC,KAAKL,GAId,AAHIK,EAAE,IAAIJ,MAAM,IAAOI,EAAE,IACrBA,EAAE,IAAIH,MAAM,IAAOG,EAAE,IACrBA,EAAE,IAAIF,MAAM,IAAOE,EAAE,IACrBA,EAAE,IAAID,MAAM,IAAOC,EAAE;CAE3B,OAAO;EAAE,GAAGJ;EAAM,GAAGC;EAAM,OAAOC,IAAOF;EAAM,QAAQG,IAAOF;CAAK;AACrE"}

package/dist/canvas/kitRequirements.js

@@ -0,0 +1,177 @@
+import { VERSION as e } from "../version.js";
+//#region src/canvas/kitRequirements.ts
+var t = { core: e }, n = "-unknown", r = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/, i = /^v?(\d+|[xX*])(?:\.(\d+|[xX*]))?(?:\.(\d+|[xX*]))?(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+function a(e) {
+	return e ? e.split(".").map((e) => /^\d+$/.test(e) ? Number(e) : e) : [];
+}
+function o(e) {
+	let t = r.exec(e.trim());
+	return t ? {
+		triple: [
+			Number(t[1]),
+			Number(t[2]),
+			Number(t[3])
+		],
+		pre: a(t[4])
+	} : null;
+}
+function s(e, t) {
+	for (let n = 0; n < 3; n++) {
+		let r = e.triple[n] - t.triple[n];
+		if (r !== 0) return r;
+	}
+	if (e.pre.length === 0 || t.pre.length === 0) return t.pre.length - e.pre.length;
+	for (let n = 0; n < Math.max(e.pre.length, t.pre.length); n++) {
+		let r = e.pre[n], i = t.pre[n];
+		if (r === void 0) return -1;
+		if (i === void 0) return 1;
+		if (r !== i) return typeof r == "number" && typeof i == "number" ? r - i : typeof r == "number" ? -1 : typeof i == "number" ? 1 : r < i ? -1 : 1;
+	}
+	return 0;
+}
+var c = (e, t, n, r = []) => ({
+	triple: [
+		e,
+		t,
+		n
+	],
+	pre: r
+});
+function l(e) {
+	let t = /^(\^|~|>=|<=|>|<|=)?(.*)$/.exec(e), n = t[1] ?? "", r = i.exec(t[2]);
+	if (!r) return null;
+	let o = [];
+	for (let e of [
+		r[1],
+		r[2],
+		r[3]
+	]) {
+		if (e === void 0 || /^[xX*]$/.test(e)) break;
+		o.push(Number(e));
+	}
+	let s = a(r[4]);
+	if (s.length > 0 && o.length < 3) return null;
+	let [l = 0, u = 0, d = 0] = o, f = c(l, u, d, s), p = o.length === 0 ? null : o.length === 1 ? c(l + 1, 0, 0) : o.length === 2 ? c(l, u + 1, 0) : c(l, u, d + 1);
+	switch (n) {
+		case ">=": return [{
+			op: ">=",
+			v: f
+		}];
+		case "<": return o.length === 0 ? [{
+			op: "<",
+			v: c(0, 0, 0)
+		}] : [{
+			op: "<",
+			v: f
+		}];
+		case ">": return o.length === 3 ? [{
+			op: ">",
+			v: f
+		}] : p ? [{
+			op: ">=",
+			v: p
+		}] : [{
+			op: "<",
+			v: c(0, 0, 0)
+		}];
+		case "<=": return o.length === 3 ? [{
+			op: "<=",
+			v: f
+		}] : p ? [{
+			op: "<",
+			v: p
+		}] : [];
+		case "~": {
+			let e = o.length <= 1 ? c(l + 1, 0, 0) : c(l, u + 1, 0);
+			return [{
+				op: ">=",
+				v: f
+			}, {
+				op: "<",
+				v: e
+			}];
+		}
+		case "^": {
+			let e = l > 0 || o.length === 1 ? c(l + 1, 0, 0) : u > 0 || o.length === 2 ? c(0, u + 1, 0) : c(0, 0, d + 1);
+			return o.length === 0 ? [] : [{
+				op: ">=",
+				v: f
+			}, {
+				op: "<",
+				v: e
+			}];
+		}
+		default: return o.length === 3 ? [{
+			op: ">=",
+			v: f
+		}, {
+			op: "<=",
+			v: f
+		}] : p ? [{
+			op: ">=",
+			v: f
+		}, {
+			op: "<",
+			v: p
+		}] : [];
+	}
+}
+function u(e, t) {
+	let n = s(e, t.v);
+	switch (t.op) {
+		case ">=": return n >= 0;
+		case ">": return n > 0;
+		case "<=": return n <= 0;
+		case "<": return n < 0;
+	}
+}
+function d(e, t) {
+	let n = o(e);
+	if (!n) return null;
+	let r = t.split("||").map((e) => e.trim()), i = !1;
+	for (let e of r) {
+		if (e === "") return null;
+		let t = [];
+		for (let n of e.split(/\s+/)) {
+			let e = l(n);
+			if (!e) return null;
+			t.push(...e);
+		}
+		t.every((e) => u(n, e)) && (i = !0);
+	}
+	return i;
+}
+function f(e, r = t) {
+	let i = [];
+	for (let [t, a] of Object.entries(e)) {
+		if (a === void 0) continue;
+		let e = r[t];
+		if (e === void 0) {
+			i.push({
+				package: t,
+				range: a,
+				running: void 0,
+				reason: "unknown-package"
+			});
+			continue;
+		}
+		if (e.endsWith(n)) continue;
+		let o = d(e, a);
+		o === null ? i.push({
+			package: t,
+			range: a,
+			running: e,
+			reason: "invalid-range"
+		}) : o || i.push({
+			package: t,
+			range: a,
+			running: e,
+			reason: "unsatisfied"
+		});
+	}
+	return i;
+}
+//#endregion
+export { t as KIT_VERSIONS, f as checkRequirements, d as satisfiesRange };
+
+//# sourceMappingURL=kitRequirements.js.map

package/dist/canvas/kitRequirements.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kitRequirements.js","names":["KIT_VERSIONS","VERSION","UNKNOWN_SUFFIX","VERSION_RE","PARTIAL_RE","preOf","s","id","parseVersion","m","compare","i","d","a","b","x","y","v","c","parseComparator","token","op","p","nums","part","pre","M","mi","pa","lower","upper","top","holds","version","satisfiesRange","parsed","alternatives","range","alt","any","set","cs","checkRequirements","out","pkg","requires","have","running","ok"],"sources":["../../src/canvas/kitRequirements.ts"],"sourcesContent":["/**\n * Version negotiation for contributions: a `requires` map of semver ranges,\n * matched against the versions the running kit packages report.\n *\n * The range grammar is npm's everyday subset — `^`, `~`, `>=`, `>`, `<=`, `<`,\n * `=`, bare and partial versions (`1.7`, `1.x`, `*`), space for AND and `||`\n * for OR. Hyphen ranges are not read. A prerelease orders below its release,\n * without npm's rule that a range must opt into prereleases by naming one.\n */\nimport { VERSION } from '../version';\n\n/**\n * The versions a contribution can require, keyed by package without its\n * `@weasel-js/` scope. Only core reports its version today.\n */\nexport interface KitVersions {\n  core: string;\n}\n\n/** A contribution's `requires`: a semver range per package it was written against. */\nexport type KitRequirements = { readonly [K in keyof KitVersions]?: string };\n\n/** The running kit's versions. */\nexport const KIT_VERSIONS: Readonly<KitVersions> = { core: VERSION };\n\n/** One requirement the running kit does not meet. */\nexport interface RequirementMismatch {\n  package: string;\n  range: string;\n  /** The running version, or `undefined` when that package reports none. */\n  running: string | undefined;\n  reason: 'unsatisfied' | 'invalid-range' | 'unknown-package';\n}\n\ntype Triple = readonly [number, number, number];\ninterface Version { triple: Triple; pre: readonly (string | number)[] }\ninterface Comparator { op: '>=' | '<' | '>' | '<='; v: Version }\n\nconst UNKNOWN_SUFFIX = '-unknown';\nconst VERSION_RE = /^v?(\\d+)\\.(\\d+)\\.(\\d+)(?:-([0-9A-Za-z.-]+))?(?:\\+[0-9A-Za-z.-]+)?$/;\nconst PARTIAL_RE = /^v?(\\d+|[xX*])(?:\\.(\\d+|[xX*]))?(?:\\.(\\d+|[xX*]))?(?:-([0-9A-Za-z.-]+))?(?:\\+[0-9A-Za-z.-]+)?$/;\n\nfunction preOf(s: string | undefined): (string | number)[] {\n  return s ? s.split('.').map((id) => (/^\\d+$/.test(id) ? Number(id) : id)) : [];\n}\n\nfunction parseVersion(s: string): Version | null {\n  const m = VERSION_RE.exec(s.trim());\n  return m ? { triple: [Number(m[1]), Number(m[2]), Number(m[3])], pre: preOf(m[4]) } : null;\n}\n\nfunction compare(a: Version, b: Version): number {\n  for (let i = 0; i < 3; i++) {\n    const d = a.triple[i]! - b.triple[i]!;\n    if (d !== 0) return d;\n  }\n  if (a.pre.length === 0 || b.pre.length === 0) return b.pre.length - a.pre.length;\n  for (let i = 0; i < Math.max(a.pre.length, b.pre.length); i++) {\n    const x = a.pre[i];\n    const y = b.pre[i];\n    if (x === undefined) return -1;\n    if (y === undefined) return 1;\n    if (x === y) continue;\n    if (typeof x === 'number' && typeof y === 'number') return x - y;\n    if (typeof x === 'number') return -1;\n    if (typeof y === 'number') return 1;\n    return x < y ? -1 : 1;\n  }\n  return 0;\n}\n\nconst v = (a: number, b: number, c: number, pre: readonly (string | number)[] = []): Version =>\n  ({ triple: [a, b, c], pre });\n\n/** One comparator token as the interval it names. `null` when unreadable. */\nfunction parseComparator(token: string): Comparator[] | null {\n  const m = /^(\\^|~|>=|<=|>|<|=)?(.*)$/.exec(token)!;\n  const op = m[1] ?? '';\n  const p = PARTIAL_RE.exec(m[2]!);\n  if (!p) return null;\n  const nums: number[] = [];\n  for (const part of [p[1], p[2], p[3]]) {\n    if (part === undefined || /^[xX*]$/.test(part)) break;\n    nums.push(Number(part));\n  }\n  const pre = preOf(p[4]);\n  if (pre.length > 0 && nums.length < 3) return null;\n  const [M = 0, mi = 0, pa = 0] = nums;\n  const lower = v(M, mi, pa, pre);\n  // The first version past everything the partial names: `1.7` → `1.8.0`.\n  const upper = nums.length === 0 ? null\n    : nums.length === 1 ? v(M + 1, 0, 0)\n    : nums.length === 2 ? v(M, mi + 1, 0)\n    : v(M, mi, pa + 1);\n\n  switch (op) {\n    case '>=': return [{ op: '>=', v: lower }];\n    case '<': return nums.length === 0 ? [{ op: '<', v: v(0, 0, 0) }] : [{ op: '<', v: lower }];\n    case '>': return nums.length === 3 ? [{ op: '>', v: lower }] : upper ? [{ op: '>=', v: upper }] : [{ op: '<', v: v(0, 0, 0) }];\n    case '<=': return nums.length === 3 ? [{ op: '<=', v: lower }] : upper ? [{ op: '<', v: upper }] : [];\n    case '~': {\n      const top = nums.length <= 1 ? v(M + 1, 0, 0) : v(M, mi + 1, 0);\n      return [{ op: '>=', v: lower }, { op: '<', v: top }];\n    }\n    case '^': {\n      const top = M > 0 || nums.length === 1 ? v(M + 1, 0, 0)\n        : mi > 0 || nums.length === 2 ? v(0, mi + 1, 0)\n        : v(0, 0, pa + 1);\n      return nums.length === 0 ? [] : [{ op: '>=', v: lower }, { op: '<', v: top }];\n    }\n    default:\n      if (nums.length === 3) return [{ op: '>=', v: lower }, { op: '<=', v: lower }];\n      return upper ? [{ op: '>=', v: lower }, { op: '<', v: upper }] : [];\n  }\n}\n\nfunction holds(version: Version, c: Comparator): boolean {\n  const d = compare(version, c.v);\n  switch (c.op) {\n    case '>=': return d >= 0;\n    case '>': return d > 0;\n    case '<=': return d <= 0;\n    case '<': return d < 0;\n  }\n}\n\n/**\n * Whether `version` falls in `range`. `null` when either cannot be read, so a\n * caller can tell a mismatch from a requirement it could not check.\n */\nexport function satisfiesRange(version: string, range: string): boolean | null {\n  const parsed = parseVersion(version);\n  if (!parsed) return null;\n  const alternatives = range.split('||').map((alt) => alt.trim());\n  let any = false;\n  for (const alt of alternatives) {\n    if (alt === '') return null;\n    const set: Comparator[] = [];\n    for (const token of alt.split(/\\s+/)) {\n      const cs = parseComparator(token);\n      if (!cs) return null;\n      set.push(...cs);\n    }\n    if (set.every((c) => holds(parsed, c))) any = true;\n  }\n  return any;\n}\n\n/**\n * Every requirement in `requires` the running kit does not meet. A package\n * whose build does not know its own version (`0.0.0-unknown`, core's source\n * bundled without its define) is skipped: nothing can be said about it.\n */\nexport function checkRequirements(\n  requires: KitRequirements,\n  running: Readonly<Partial<Record<string, string>>> = KIT_VERSIONS,\n): RequirementMismatch[] {\n  const out: RequirementMismatch[] = [];\n  for (const [pkg, range] of Object.entries(requires)) {\n    if (range === undefined) continue;\n    const have = running[pkg];\n    if (have === undefined) {\n      out.push({ package: pkg, range, running: undefined, reason: 'unknown-package' });\n      continue;\n    }\n    if (have.endsWith(UNKNOWN_SUFFIX)) continue;\n    const ok = satisfiesRange(have, range);\n    if (ok === null) out.push({ package: pkg, range, running: have, reason: 'invalid-range' });\n    else if (!ok) out.push({ package: pkg, range, running: have, reason: 'unsatisfied' });\n  }\n  return out;\n}\n"],"mappings":"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"}

package/dist/canvas/layerOrder.js

@@ -0,0 +1,66 @@
+import { STANDARD_SLOTS as e, isCustomEntry as t } from "./layerSlots.js";
+//#region src/canvas/layerOrder.ts
+var n = new Set(e);
+function r(r, i, a, o) {
+	let s = /* @__PURE__ */ new Map(), c = /* @__PURE__ */ new Map(), l = [], u = /* @__PURE__ */ new Set();
+	for (let [e, i] of Object.entries(r)) if (!n.has(e) && t(i)) {
+		if (u.add(e), i.after) {
+			let t = s.get(i.after) ?? [];
+			t.push({
+				key: e,
+				layer: i.layer
+			}), s.set(i.after, t);
+		} else if (i.before) {
+			let t = c.get(i.before) ?? [];
+			t.push({
+				key: e,
+				layer: i.layer
+			}), c.set(i.before, t);
+		} else l.push({
+			key: e,
+			layer: i.layer
+		});
+	}
+	let d = /* @__PURE__ */ new Set(), f = o ? [o] : [];
+	function p(e) {
+		if (d.has(e.key)) {
+			console.warn(`composeOrderedLayers: cycle detected involving custom layer "${e.key}"`);
+			return;
+		}
+		d.add(e.key), h(e.key), f.push(e.layer), m(e.key);
+	}
+	function m(e) {
+		for (let t of s.get(e) ?? []) p(t);
+	}
+	function h(e) {
+		for (let t of c.get(e) ?? []) p(t);
+	}
+	for (let t of e) {
+		if (t === "scene" && a) {
+			h("scene");
+			for (let e of a) h(e.key), f.push(e.layer), m(e.key);
+			m("scene");
+			continue;
+		}
+		h(t);
+		let e = i[t];
+		e && f.push(e), m(t);
+	}
+	for (let e of l) d.has(e.key) || (d.add(e.key), f.push(e.layer));
+	for (let e of u) {
+		if (d.has(e)) continue;
+		let n = r[e];
+		if (!t(n)) continue;
+		let i = n.after ?? n.before;
+		console.warn(`composeOrderedLayers: dangling reference "${i}" from custom layer "${e}" — falling back to tail`), d.add(e), f.push(n.layer);
+	}
+	return f;
+}
+function i(e, t, n) {
+	let r = n("before-selection"), i = n("after-selection"), a = t ? e.indexOf(t) : -1;
+	return a >= 0 ? (e.splice(a + 1, 0, ...i), e.splice(a, 0, ...r)) : e.push(...r, ...i), e.push(...n("top")), e;
+}
+//#endregion
+export { r as composeOrderedLayers, i as placeToolOverlays };
+
+//# sourceMappingURL=layerOrder.js.map