@weasel-js/core 1.7.0 → 1.7.1

package/dist/canvas/sceneSlotWiring.js

@@ -0,0 +1,20 @@
+import { sceneDerivedPathOf as e, withDerivedPaths as t } from "./derivedPath.js";
+import { withColorOverrides as n } from "./colorOverrides.js";
+//#region src/canvas/sceneSlotWiring.ts
+function r(e, t) {
+	let n = (t) => e.overrides.get(t)?.alpha ?? 1;
+	return t ? (e) => t(e) * n(e) : n;
+}
+function i(i, a, o, s) {
+	let c = t(a, i.drawOne, i.toPose), l = e(a, i.toPose);
+	return {
+		...i,
+		drawOne: s ? n(s, c) : c,
+		derivedPathOf: l,
+		alphaFor: r(a, o)
+	};
+}
+//#endregion
+export { r as composeAlphaFor, i as wireSceneSlotToScene };
+
+//# sourceMappingURL=sceneSlotWiring.js.map

package/dist/canvas/sceneSlotWiring.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sceneSlotWiring.js","names":["composeAlphaFor","overrideAlphaFor","scene","id","alphaFor","wireSceneSlotToScene","derived","withDerivedPaths","slot","derivedPathOf","sceneDerivedPathOf","colorOverrides","withColorOverrides"],"sources":["../../src/canvas/sceneSlotWiring.ts"],"sourcesContent":["/**\n * What the scene slot needs from the `Scene` that `<Canvas>` cannot see.\n *\n * `<Canvas>` is scene-agnostic: it walks an adapter. Three things a node is\n * painted with are therefore invisible to it — an ephemeral override's alpha, a\n * derived path, which needs other nodes' poses to resolve, and animated vertex\n * colors, which live in an animator. `<SceneCanvas>` folds them into the slot\n * here; `buildSceneViewCommands` does the same for the headless walk.\n */\nimport type { SceneSlotConfig } from './Canvas';\nimport type { Node, NodeId, Scene } from 'core/scene/types';\nimport { withDerivedPaths, sceneDerivedPathOf } from './derivedPath';\nimport { withColorOverrides } from './colorOverrides';\nimport type { ColorOverrideRegistry } from '../animation/colorRegistry';\n\n/**\n * The alpha a view paints a node at: the view's own `alphaFor` times any\n * ephemeral override alpha.\n *\n * The hit path asks this too — a node painted at alpha 0 is not on screen and\n * must not claim clicks — so it is one function rather than the painter's and\n * picking's separate readings of the same two inputs.\n */\nexport function composeAlphaFor<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  alphaFor?: (id: string) => number,\n): (id: string) => number {\n  const overrideAlphaFor = (id: string) => scene.overrides.get(id as NodeId)?.alpha ?? 1;\n  return alphaFor ? (id: string) => alphaFor(id) * overrideAlphaFor(id) : overrideAlphaFor;\n}\n\nexport function wireSceneSlotToScene<TData, TLayer extends string, TPose>(\n  slot: SceneSlotConfig<Node<TData, TLayer, TPose>, TPose>,\n  scene: Scene<TData, TLayer, TPose>,\n  alphaFor?: (id: string) => number,\n  colorOverrides?: ColorOverrideRegistry,\n): SceneSlotConfig<Node<TData, TLayer, TPose>, TPose> {\n  const derived = withDerivedPaths(scene, slot.drawOne, slot.toPose);\n  const derivedPathOf = sceneDerivedPathOf(scene, slot.toPose);\n  return {\n    ...slot,\n    drawOne: colorOverrides ? withColorOverrides(colorOverrides, derived) : derived,\n    derivedPathOf,\n    alphaFor: composeAlphaFor(scene, alphaFor),\n  };\n}\n"],"mappings":";;;AAuBA,SAAgBA,EACd,GACA,GACwB;CACxB,IAAMC,KAAoB,MAAeC,EAAM,UAAU,IAAIC,CAAY,CAAC,EAAE,SAAS;CACrF,OAAOC,KAAY,MAAeA,EAASD,CAAE,IAAIF,EAAiBE,CAAE,IAAIF;AAC1E;AAEA,SAAgBI,EACd,GACA,GACA,GACA,GACoD;CACpD,IAAMC,IAAUC,EAAiBL,GAAOM,EAAK,SAASA,EAAK,MAAM,GAC3DC,IAAgBC,EAAmBR,GAAOM,EAAK,MAAM;CAC3D,OAAO;EACL,GAAGA;EACH,SAASG,IAAiBC,EAAmBD,GAAgBL,CAAO,IAAIA;EACxE;EACA,UAAUN,EAAgBE,GAAOE,CAAQ;CAC3C;AACF"}

package/dist/canvas/sceneViewRender.js

@@ -0,0 +1,72 @@
+import { viewToMat3 as e } from "../renderer/math/viewToMat3.js";
+import { cullDrawCommands as t } from "../renderer/cullDrawCommands.js";
+import { resolveDerivedPath as n } from "../core/scene/derivedPath.js";
+import { effectivePose as r } from "../core/scene/effectivePose.js";
+import { sceneDepLookup as i, withDerivedPaths as a } from "./derivedPath.js";
+import { paintBoundsFor as o } from "./defaultDrawOne.js";
+import { paintedSceneLayers as s } from "./sceneLayerPaint.js";
+import { paintCanvas as c } from "./canvasRenderer.js";
+import { buildSceneTree as l } from "./buildSceneTree.js";
+import { wrapNodeOutput as u } from "./wrapNodeOutput.js";
+import { paintMissesView as d } from "./paintCull.js";
+import { withColorOverrides as f } from "./colorOverrides.js";
+//#region src/canvas/sceneViewRender.ts
+function p(e, t = {}) {
+	return {
+		getLayers: () => s(e.layers, t).map((e) => ({
+			id: e.id,
+			visible: e.visible,
+			parallax: e.parallax
+		})),
+		getNode: (t) => e.get(t),
+		getChildren: (t) => {
+			if (t === null) return e.roots;
+			let n = e.get(t);
+			return n && n.kind === "container" ? n.children : [];
+		},
+		getPose: (t) => r(e, e.get(t))
+	};
+}
+function m(r, o, s, c, m, h, g, _, v) {
+	let y = a(r, s), b = _ ? f(_, y) : y, x = i(r), S = (e, t, n) => {
+		let i = r.overrides.get(e.id)?.alpha ?? 1;
+		return u(b(e, t, n), t, (m ? m(e.id) : 1) * i);
+	}, C = h !== void 0 && h.closure !== "identity" ? {
+		...p(r, g),
+		composePose: h.compose
+	} : p(r, g), w = v ? {
+		x: 0,
+		y: 0,
+		width: v.width,
+		height: v.height
+	} : void 0, T = w && v?.paintBounds ? d(v.paintBounds, o, w) : void 0, E = l(C, S, o, void 0, ((e) => n(e, x, (e) => r.childrenOf(e))), T), D = w ? t(E, e(o), w) : E;
+	if (c && c.length > 0) for (let e of c) D.push(e);
+	return [{
+		kind: "group",
+		transform: e(o),
+		children: D
+	}];
+}
+function h(e) {
+	let { scene: t, view: n, width: r, height: i, drawOne: a, extraCommands: s, alphaFor: c, layerVisibility: l, layerOrder: u, colorOverrides: d, cull: f } = e;
+	return m(t, n, a, s, c, void 0, {
+		layerVisibility: l,
+		layerOrder: u
+	}, d, f ? {
+		width: r,
+		height: i,
+		paintBounds: e.paintBounds ?? o(a)
+	} : void 0);
+}
+function g(e) {
+	let { canvas: t, view: n, width: r, height: i, dpr: a } = e;
+	c(t, h(e), n, {
+		width: r,
+		height: i,
+		dpr: a
+	});
+}
+//#endregion
+export { m as buildSceneViewCommands, g as renderSceneToCanvas, h as sceneViewFrame };
+
+//# sourceMappingURL=sceneViewRender.js.map

package/dist/canvas/sceneViewRender.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sceneViewRender.js","names":["sceneAsHierarchy","paintedSceneLayers","scene","layers","l","id","parentId","node","effectivePose","buildSceneViewCommands","derivedOnly","withDerivedPaths","drawOne","derived","colorOverrides","withColorOverrides","depLookup","sceneDepLookup","wrappedDrawOne","overrideAlpha","wrapNodeOutput","pose","v","alphaFor","hierarchy","poseComposition","cullRect","cull","culled","paintMissesView","view","tree","buildSceneTree","resolveDerivedPath","children","cullDrawCommands","viewToMat3","extraCommands","cmd","sceneViewFrame","args","paintBoundsFor","renderSceneToCanvas","canvas"],"sources":["../../src/canvas/sceneViewRender.ts"],"sourcesContent":["/**\n * `renderSceneToCanvas` — substrate for detached, read-only scene views\n * (`<SceneViewCanvas>` / `<MinimapCanvas>`). Given a `<canvas>`, a `Scene`,\n * a `View`, and a per-node `drawOne`, render one frame.\n *\n * The full `<SceneCanvas>` render pipeline does much more than this (slots, layer\n * ordering, debug sinks, tool overlays). The helper deliberately re-implements\n * the small subset needed for a non-interactive scene view rather than\n * refactoring `<SceneCanvas>` to share code — the spec calls for that\n * dedupe as a follow-up.\n *\n * Note: this duplicates `<SceneCanvas>`'s GL setup + view-wrap pattern in\n * miniature. When `<SceneCanvas>` is eventually migrated onto this helper,\n * the duplication collapses; until then, keep the two render paths\n * in sync by hand where it matters (DPR handling, viewToMat3 wrap).\n */\n\nimport type { WeaselRenderer } from '../renderer/WeaselRenderer';\nimport { cachedCanvasRenderer, paintCanvas } from './canvasRenderer';\nimport type { PoseComposition } from 'features/groups/composePose';\nimport { viewToMat3 } from '../renderer/math/viewToMat3';\nimport type { DrawCommand } from '../renderer/DrawCommand';\nimport type { View } from '../core/viewport/view';\nimport type { Node, NodeId, Scene } from '../core/scene/types';\nimport { wrapNodeOutput } from './wrapNodeOutput';\nimport { buildSceneTree, type HierarchicalAdapter } from './buildSceneTree';\nimport { effectivePose } from 'core/scene/effectivePose';\nimport { withDerivedPaths, resolveDerivedPath, sceneDepLookup } from './derivedPath';\nimport { withColorOverrides } from './colorOverrides';\nimport type { ColorOverrideRegistry } from '../animation/colorRegistry';\nimport type { SceneViewDrawOne } from './NodeShape';\nimport { paintedSceneLayers } from './sceneLayerPaint';\nimport { cullDrawCommands } from '../renderer/cullDrawCommands';\nimport { paintMissesView, type PaintBoundsFn } from './paintCull';\nimport { paintBoundsFor } from './defaultDrawOne';\n\nexport type { SceneViewDrawOne } from './NodeShape';\n\n/**\n * Which scene layers a detached view paints, on top of each layer's own\n * `visible` flag. Keyed the way `<SceneCanvas>` keys its scene layers —\n * `scene:<layerId>` — so the map a main canvas takes serves its minimap too.\n */\nexport interface SceneViewLayers {\n  /** `false` hides that layer in this view. It cannot show one the scene hides. */\n  layerVisibility?: Record<string, boolean>;\n  /** Paint order, bottom first. A listed order is the whole list: a scene\n   *  layer left out of it is not painted. */\n  layerOrder?: readonly string[];\n}\n\n/** The view size `buildSceneViewCommands` culls to, and how it bounds a\n *  node's paint before painting it. */\nexport interface SceneViewCull<TData, TLayer extends string, TPose> {\n  width: number;\n  height: number;\n  paintBounds?: PaintBoundsFn<Node<TData, TLayer, TPose>, TPose>;\n}\n\n/** What to draw into an existing canvas: the scene, the view, and the same\n *  painting hooks `<SceneCanvas>` takes. */\nexport interface RenderSceneToCanvasArgs<TData, TLayer extends string, TPose> {\n  /** The DOM canvas to paint into. The helper owns its WebGL2 context: the\n   *  first call on a given canvas creates a renderer and stashes it; subsequent\n   *  calls reuse the same renderer (and resize the drawing buffer on dim\n   *  changes). `releaseCanvasRenderer(canvas)` frees it. */\n  canvas: HTMLCanvasElement;\n  /** Scene to walk. `scene.renderOrder()` provides the per-node order. */\n  scene: Scene<TData, TLayer, TPose>;\n  /** Camera view applied to scene + extras (both ride the same world→screen\n   *  transform; extras living in screen space should be supplied via a\n   *  separately-prepared `extraCommands` group or rendered outside this\n   *  helper). */\n  view: View;\n  /** CSS-pixel size. The drawing buffer is set to `width × dpr` and\n   *  `height × dpr`; CSS size to `width` / `height`. */\n  width: number;\n  height: number;\n  /** Per-node draw callback. */\n  drawOne: SceneViewDrawOne<TData, TLayer, TPose>;\n  /** Optional commands appended after the scene-node output. Used for the\n   *  minimap's visible-window indicator. Wrapped in the same view transform\n   *  as scene commands. */\n  extraCommands?: DrawCommand[];\n  /** Optional per-id alpha multiplier, mirroring `<SceneCanvas>`'s scene-slot\n   *  `alphaFor`. Pass the same function the main canvas uses to keep a\n   *  scoping-dim treatment consistent across both. Defaults to `() => 1`. */\n  alphaFor?: (id: string) => number;\n  /** Per-view layer visibility. See {@link SceneViewLayers}. */\n  layerVisibility?: SceneViewLayers['layerVisibility'];\n  /** Per-view layer order. See {@link SceneViewLayers}. */\n  layerOrder?: SceneViewLayers['layerOrder'];\n  /** Animated vertex colors to paint, typically an animator's\n   *  `colorOverrides` — see `NodePaintCtx.vertexColors`. */\n  colorOverrides?: ColorOverrideRegistry;\n  /** Skip what cannot reach the `width × height` view: nodes `paintBounds`\n   *  places outside it are not painted, and scene commands that cannot reach\n   *  it are dropped before the renderer — the scene slot's `cull`. Off by\n   *  default. `extraCommands` are never culled. */\n  cull?: boolean;\n  /** Where `drawOne`'s output for a node can reach, as on the scene slot.\n   *  Defaults to `defaultPaintBounds` when `drawOne` is `defaultDrawOne`. */\n  paintBounds?: PaintBoundsFn<Node<TData, TLayer, TPose>, TPose>;\n  /** Optional device-pixel ratio. Defaults to `window.devicePixelRatio || 1`\n   *  when available, otherwise 1. Tests typically pin this to 1 or 2. */\n  dpr?: number;\n}\n\n/** Test seam: the renderer `renderSceneToCanvas` created for a canvas. Not\n *  re-exported from the barrel. */\nexport function __getCachedRendererForTest(\n  canvas: HTMLCanvasElement,\n): WeaselRenderer | undefined {\n  return cachedCanvasRenderer(canvas);\n}\n\n/**\n * Present a `Scene` as the reading surface `buildSceneTree` walks. Built\n * inline rather than via `sceneToAdapter` so this module stays free of React\n * — `renderSceneToPixels` runs headless.\n */\nfunction sceneAsHierarchy<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  layers: SceneViewLayers = {},\n): HierarchicalAdapter<Node<TData, TLayer, TPose>, TPose> {\n  return {\n    getLayers: () =>\n      paintedSceneLayers(scene.layers, layers)\n        .map((l) => ({ id: l.id, visible: l.visible, parallax: l.parallax })),\n    getNode: (id) => scene.get(id as NodeId),\n    getChildren: (parentId) => {\n      if (parentId === null) return scene.roots as readonly string[];\n      const node = scene.get(parentId as NodeId);\n      return node && node.kind === 'container' ? (node.children as readonly string[]) : [];\n    },\n    getPose: (id) => effectivePose(scene, scene.get(id as NodeId)!),\n  } as HierarchicalAdapter<Node<TData, TLayer, TPose>, TPose>;\n}\n\n/**\n * Build the DrawCommand list that `renderSceneToCanvas` would dispatch.\n *\n * Pure — no GL, no DOM, no side effects. Walks the scene through\n * `buildSceneTree` — the same walk `<SceneCanvas>`'s `buildSceneLayer` uses —\n * appends any `extraCommands`, and wraps the result in a single\n * `{ kind: 'group', transform: viewToMat3(view) }` so the output is in screen\n * space. Sharing the walk is what keeps hidden layers unpainted and container\n * clips applied here; a hand-rolled `renderOrder()` loop silently dropped both.\n *\n * Each node's commands additionally go through `wrapNodeOutput` — pose\n * rotation, then the `alphaFor` multiplier — exactly as `buildSceneLayer`\n * does, so a `drawOne` shared between the two paints the same thing in both.\n * A `drawOne` that rotates its own output will therefore rotate twice here;\n * emit unrotated geometry and let the pose drive it.\n *\n * Output shape follows `buildSceneTree`: one group per **visible** layer, in\n * scene-layer order (or `layers.layerOrder`), each holding one group per node\n * on that layer.\n *\n * Exported for tests and for callers that want to render into something\n * other than a real `<canvas>` (e.g. an offscreen renderer or a\n * snapshot fixture).\n */\nexport function buildSceneViewCommands<TData, TLayer extends string, TPose>(\n  scene: Scene<TData, TLayer, TPose>,\n  view: View,\n  drawOne: SceneViewDrawOne<TData, TLayer, TPose>,\n  extraCommands?: ReadonlyArray<DrawCommand>,\n  alphaFor?: (id: string) => number,\n  /** How a child's stored pose folds into its parent's frame. Omit for the\n   *  absolute-pose model. */\n  poseComposition?: PoseComposition<TPose>,\n  /** This view's own layer visibility and order. */\n  layers?: SceneViewLayers,\n  /** Animated vertex colors to paint, typically an animator's `colorOverrides`. */\n  colorOverrides?: ColorOverrideRegistry,\n  /** Cull the scene to this CSS-pixel view size — see\n   *  `RenderSceneToCanvasArgs.cull`. Omit to paint every node. */\n  cull?: SceneViewCull<TData, TLayer, TPose>,\n): DrawCommand[] {\n  // The scene is in scope here, so this is where the override's alpha and the\n  // derived paths are applied on the headless path; `SceneCanvas` does the same\n  // for the live one. `Canvas` itself never sees a scene, so it can't and doesn't.\n  const derivedOnly = withDerivedPaths(scene, drawOne);\n  const derived = colorOverrides ? withColorOverrides(colorOverrides, derivedOnly) : derivedOnly;\n  const depLookup = sceneDepLookup(scene);\n  const wrappedDrawOne = (\n    node: Node<TData, TLayer, TPose>,\n    pose: TPose,\n    v: View,\n  ): DrawCommand[] => {\n    const overrideAlpha = scene.overrides.get(node.id as NodeId)?.alpha ?? 1;\n    return wrapNodeOutput(\n      derived(node, pose, v),\n      pose,\n      (alphaFor ? alphaFor(node.id) : 1) * overrideAlpha,\n    );\n  };\n\n  const composes = poseComposition !== undefined && poseComposition.closure !== 'identity';\n  const hierarchy = composes\n    ? { ...sceneAsHierarchy(scene, layers), composePose: poseComposition!.compose }\n    : sceneAsHierarchy(scene, layers);\n\n  const cullRect = cull ? { x: 0, y: 0, width: cull.width, height: cull.height } : undefined;\n  const culled = cullRect && cull?.paintBounds ? paintMissesView(cull.paintBounds, view, cullRect) : undefined;\n  const tree: DrawCommand[] = buildSceneTree(\n    hierarchy as Parameters<typeof buildSceneTree>[0],\n    wrappedDrawOne as unknown as Parameters<typeof buildSceneTree>[1],\n    view,\n    undefined,\n    ((node: unknown) =>\n      resolveDerivedPath(\n        node as Node<TData, TLayer, TPose>, depLookup, (id) => scene.childrenOf(id),\n      )) as Parameters<typeof buildSceneTree>[4],\n    culled as Parameters<typeof buildSceneTree>[5],\n  );\n  const children = cullRect ? cullDrawCommands(tree, viewToMat3(view), cullRect) : tree;\n  if (extraCommands && extraCommands.length > 0) {\n    for (const cmd of extraCommands) children.push(cmd);\n  }\n  return [{\n    kind: 'group',\n    transform: viewToMat3(view),\n    children,\n  }];\n}\n\n/**\n * The commands `renderSceneToCanvas` paints for one frame — everything in\n * `args` but the canvas. `<SceneViewCanvas>` paints these through its own\n * renderer lease.\n */\nexport function sceneViewFrame<TData, TLayer extends string, TPose>(\n  args: Omit<RenderSceneToCanvasArgs<TData, TLayer, TPose>, 'canvas'>,\n): DrawCommand[] {\n  const {\n    scene, view, width, height, drawOne, extraCommands, alphaFor, layerVisibility, layerOrder,\n    colorOverrides, cull,\n  } = args;\n  return buildSceneViewCommands(\n    scene, view, drawOne, extraCommands, alphaFor, undefined, { layerVisibility, layerOrder }, colorOverrides,\n    cull ? { width, height, paintBounds: args.paintBounds ?? paintBoundsFor(drawOne) } : undefined,\n  );\n}\n\n/**\n * Render one frame of `scene` at `view` into `canvas`. See module docstring\n * for the design context.\n *\n * Paints through `paintCanvas` (`./canvasRenderer`): one renderer per canvas,\n * created on the first call and resized when `width` / `height` / `dpr`\n * change. Where no WebGL2 context is available (jsdom) the call paints\n * nothing. The renderer lives until `releaseCanvasRenderer(canvas)`.\n */\nexport function renderSceneToCanvas<TData, TLayer extends string, TPose>(\n  args: RenderSceneToCanvasArgs<TData, TLayer, TPose>,\n): void {\n  const { canvas, view, width, height, dpr } = args;\n  paintCanvas(canvas, sceneViewFrame(args), view, { width, height, dpr });\n}\n"],"mappings":";;;;;;;;;;;;;AAyHA,SAASA,EACP,GACA,IAA0B,CAAC,GAC6B;CACxD,OAAO;EACL,iBACEC,EAAmBC,EAAM,QAAQC,CAAM,CAAC,CACrC,KAAK,OAAO;GAAE,IAAIC,EAAE;GAAI,SAASA,EAAE;GAAS,UAAUA,EAAE;EAAS,EAAE;EACxE,UAAU,MAAOF,EAAM,IAAIG,CAAY;EACvC,cAAc,MAAa;GACzB,IAAIC,MAAa,MAAM,OAAOJ,EAAM;GACpC,IAAMK,IAAOL,EAAM,IAAII,CAAkB;GACzC,OAAOC,KAAQA,EAAK,SAAS,cAAeA,EAAK,WAAiC,CAAC;EACrF;EACA,UAAU,MAAOC,EAAcN,GAAOA,EAAM,IAAIG,CAAY,CAAE;CAChE;AACF;AA0BA,SAAgBI,EACd,GACA,GACA,GACA,GACA,GAGA,GAEA,GAEA,GAGA,GACe;CAIf,IAAMC,IAAcC,EAAiBT,GAAOU,CAAO,GAC7CC,IAAUC,IAAiBC,EAAmBD,GAAgBJ,CAAW,IAAIA,GAC7EM,IAAYC,EAAef,CAAK,GAChCgB,KACJ,GACA,GACA,MACkB;EAClB,IAAMC,IAAgBjB,EAAM,UAAU,IAAIK,EAAK,EAAY,CAAC,EAAE,SAAS;EACvE,OAAOa,EACLP,EAAQN,GAAMc,GAAMC,CAAC,GACrBD,IACCE,IAAWA,EAAShB,EAAK,EAAE,IAAI,KAAKY,CACvC;CACF,GAGMK,IADWC,MAAoB,KAAA,KAAaA,EAAgB,YAAY,aAE1E;EAAE,GAAGzB,EAAiBE,GAAOC,CAAM;EAAG,aAAasB,EAAiB;CAAQ,IAC5EzB,EAAiBE,GAAOC,CAAM,GAE5BuB,IAAWC,IAAO;EAAE,GAAG;EAAG,GAAG;EAAG,OAAOA,EAAK;EAAO,QAAQA,EAAK;CAAO,IAAI,KAAA,GAC3EC,IAASF,KAAYC,GAAM,cAAcE,EAAgBF,EAAK,aAAaG,GAAMJ,CAAQ,IAAI,KAAA,GAC7FK,IAAsBC,EAC1BR,GACAN,GACAY,GACA,KAAA,KACE,MACAG,EACE1B,GAAoCS,IAAY,MAAOd,EAAM,WAAWG,CAAE,CAC5E,IACFuB,CACF,GACMM,IAAWR,IAAWS,EAAiBJ,GAAMK,EAAWN,CAAI,GAAGJ,CAAQ,IAAIK;CACjF,IAAIM,KAAiBA,EAAc,SAAS,GAC1C,KAAK,IAAMC,KAAOD,GAAe,EAAS,KAAKC,CAAG;CAEpD,OAAO,CAAC;EACN,MAAM;EACN,WAAWF,EAAWN,CAAI;EAC1B;CACF,CAAC;AACH;AAOA,SAAgBS,EACd,GACe;CACf,IAAM,EACJ,UAAO,SAAM,UAAO,WAAQ,YAAS,kBAAe,aAAU,oBAAiB,eAC/E,mBAAgB,YACdC;CACJ,OAAO/B,EACLP,GAAO4B,GAAMlB,GAASyB,GAAed,GAAU,KAAA,GAAW;EAAE;EAAiB;CAAW,GAAGT,GAC3Fa,IAAO;EAAE;EAAO;EAAQ,aAAaa,EAAK,eAAeC,EAAe7B,CAAO;CAAE,IAAI,KAAA,CACvF;AACF;AAWA,SAAgB8B,EACd,GACM;CACN,IAAM,EAAE,WAAQ,SAAM,UAAO,WAAQ,WAAQF;CAC7C,EAAYG,GAAQJ,EAAeC,CAAI,GAAGV,GAAM;EAAE;EAAO;EAAQ;CAAI,CAAC;AACxE"}

package/dist/canvas/slopsDebugLayer.js

@@ -0,0 +1,61 @@
+import { pointRegionScreenQuad as e, transformOf as t } from "../affordances/hitAffordanceRegions.js";
+import { chromeStateFrom as n, isVisibleFrom as r } from "./drawEnvelope.js";
+import { PATH_L as i, PATH_M as a, PATH_Z as o } from "@weasel-js/geom";
+//#region src/canvas/slopsDebugLayer.ts
+var s = "rgba(255, 80, 140, 0.18)", c = "rgba(255, 80, 140, 0.55)";
+function l(l) {
+	return {
+		id: "slops-debug",
+		label: "Slops (debug)",
+		space: "screen",
+		draw: (u, d) => {
+			let f = n(u);
+			if (!f) return [];
+			let p = r(u), m = (e, t) => [(e - d.x) * d.scale.x, (t - d.y) * d.scale.y], h = [];
+			for (let n of l.getAffordances()) if (!p || p(n.id)) for (let r of n.regions(f)) {
+				if (r.shape.kind !== "point") continue;
+				let n = e(r.shape, t(f, r.targetId), d, m);
+				h.push({
+					kind: "path",
+					path: {
+						kind: "polygon",
+						commands: new Uint8Array([
+							a,
+							i,
+							i,
+							i,
+							o
+						]),
+						coords: new Float32Array([
+							n[0].x,
+							n[0].y,
+							n[1].x,
+							n[1].y,
+							n[2].x,
+							n[2].y,
+							n[3].x,
+							n[3].y
+						]),
+						fillRule: "nonzero"
+					},
+					fill: {
+						fill: "solid",
+						color: s
+					},
+					stroke: {
+						paint: {
+							fill: "solid",
+							color: c
+						},
+						width: 1
+					}
+				});
+			}
+			return h;
+		}
+	};
+}
+//#endregion
+export { l as createSlopsDebugLayer };
+
+//# sourceMappingURL=slopsDebugLayer.js.map

package/dist/canvas/slopsDebugLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slopsDebugLayer.js","names":["SLOP_FILL","SLOP_STROKE","createSlopsDebugLayer","chrome","chromeStateFrom","data","isVisible","isVisibleFrom","toScreen","x","view","y","out","a","opts","region","q","pointRegionScreenQuad","transformOf","PATH_M","PATH_L","PATH_Z"],"sources":["../../src/canvas/slopsDebugLayer.ts"],"sourcesContent":["/**\n * Screen-space debug overlay rendering the kit's hit-test \"slops\" — the\n * forgiveness regions around each point affordance (corner resize handles,\n * the rotate badge, anchor / control-handle markers). Off by default; gated\n * by SceneCanvas's `debug.slops` prop.\n *\n * It walks the same affordances the hit-test does, and draws each point\n * region's square from the same frame the hit-test reads, so a halo shows\n * exactly the pixels that grab.\n */\n\nimport type { DrawCommand } from '../renderer';\nimport type { RenderLayer } from 'core/layers/render';\nimport type { Affordance } from 'affordances/types';\nimport { pointRegionScreenQuad, transformOf } from 'affordances/hitAffordanceRegions';\nimport { PATH_L, PATH_M, PATH_Z } from '@weasel-js/geom';\nimport { chromeStateFrom, isVisibleFrom } from './drawEnvelope';\n\nexport interface CreateSlopsDebugLayerOptions {\n  /** The affordances the canvas hit-tests — `chromeAffordances`, the same\n   *  list handed to `buildAffordanceAt`. */\n  getAffordances: () => readonly Affordance[];\n}\n\nconst SLOP_FILL = 'rgba(255, 80, 140, 0.18)';\nconst SLOP_STROKE = 'rgba(255, 80, 140, 0.55)';\n\nexport function createSlopsDebugLayer(\n  opts: CreateSlopsDebugLayerOptions,\n): RenderLayer<unknown> {\n  return {\n    id: 'slops-debug',\n    label: 'Slops (debug)',\n    space: 'screen',\n    draw: (data, view) => {\n      // Selection, bounds and visibility come off the envelope: the halos\n      // have to sit on the chrome the drawing view actually painted.\n      const chrome = chromeStateFrom(data);\n      if (!chrome) return [];\n      const isVisible = isVisibleFrom(data);\n      const toScreen = (x: number, y: number): [number, number] =>\n        [(x - view.x) * view.scale.x, (y - view.y) * view.scale.y];\n      const out: DrawCommand[] = [];\n      for (const a of opts.getAffordances()) {\n        if (isVisible && !isVisible(a.id)) continue;\n        for (const region of a.regions(chrome)) {\n          if (region.shape.kind !== 'point') continue;\n          const q = pointRegionScreenQuad(\n            region.shape, transformOf(chrome, region.targetId), view, toScreen,\n          );\n          out.push({\n            kind: 'path',\n            path: {\n              kind: 'polygon',\n              commands: new Uint8Array([PATH_M, PATH_L, PATH_L, PATH_L, PATH_Z]),\n              coords: new Float32Array([q[0].x, q[0].y, q[1].x, q[1].y, q[2].x, q[2].y, q[3].x, q[3].y]),\n              fillRule: 'nonzero',\n            },\n            fill: { fill: 'solid', color: SLOP_FILL },\n            stroke: { paint: { fill: 'solid', color: SLOP_STROKE }, width: 1 },\n          });\n        }\n      }\n      return out;\n    },\n  };\n}\n"],"mappings":";;;;AAwBA,IAAMA,IAAY,4BACZC,IAAc;AAEpB,SAAgBC,EACd,GACsB;CACtB,OAAO;EACL,IAAI;EACJ,OAAO;EACP,OAAO;EACP,OAAO,GAAM,MAAS;GAGpB,IAAMC,IAASC,EAAgBC,CAAI;GACnC,IAAI,CAACF,GAAQ,OAAO,CAAC;GACrB,IAAMG,IAAYC,EAAcF,CAAI,GAC9BG,KAAY,GAAW,MAC3B,EAAEC,IAAIC,EAAK,KAAKA,EAAK,MAAM,IAAIC,IAAID,EAAK,KAAKA,EAAK,MAAM,CAAC,GACrDE,IAAqB,CAAC;GAC5B,KAAK,IAAMC,KAAKC,EAAK,eAAe,GAClC,IAAI,MAAcR,EAAUO,EAAE,EAAE,GAChC,KAAK,IAAME,KAAUF,EAAE,QAAQV,CAAM,GAAG;IACtC,IAAIY,EAAO,MAAM,SAAS,SAAS;IACnC,IAAMC,IAAIC,EACRF,EAAO,OAAOG,EAAYf,GAAQY,EAAO,QAAQ,GAAGL,GAAMF,CAC5D;IACA,EAAI,KAAK;KACP,MAAM;KACN,MAAM;MACJ,MAAM;MACN,UAAU,IAAI,WAAW;OAACW;OAAQC;OAAQA;OAAQA;OAAQC;MAAM,CAAC;MACjE,QAAQ,IAAI,aAAa;OAACL,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;OAAGA,EAAE,EAAE,CAAC;MAAC,CAAC;MACzF,UAAU;KACZ;KACA,MAAM;MAAE,MAAM;MAAS,OAAOhB;KAAU;KACxC,QAAQ;MAAE,OAAO;OAAE,MAAM;OAAS,OAAOC;MAAY;MAAG,OAAO;KAAE;IACnE,CAAC;GACH;GAEF,OAAOW;EACT;CACF;AACF"}

package/dist/canvas/surfaceContribution.js

@@ -0,0 +1,15 @@
+import { mergeContributions as e } from "@weasel-js/routing";
+//#region src/canvas/surfaceContribution.ts
+function t(...t) {
+	let n = e(...t), r = /* @__PURE__ */ new Map();
+	for (let e of n) for (let t of e.views ?? []) {
+		let n = r.get(t.id);
+		if (n !== void 0) throw Error(`mergeContributions: view "${t.id}" is added by both "${n}" and "${e.id}". View ids are unique per surface; rename one.`);
+		r.set(t.id, e.id);
+	}
+	return n;
+}
+//#endregion
+export { t as mergeContributions };
+
+//# sourceMappingURL=surfaceContribution.js.map

package/dist/canvas/surfaceContribution.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"surfaceContribution.js","names":["mergeContributions","mergeRoutingContributions","mergeContributions$1","bundles","out","mergeContributions","viewOwner","entry","view","owner"],"sources":["../../src/canvas/surfaceContribution.ts"],"sourcesContent":["/**\n * The canvas's unit of extension: a routing `Contribution` plus the roles only\n * a surface can install — views on it, and whatever else needs the mounted\n * canvas.\n */\nimport { mergeContributions as mergeRoutingContributions } from '@weasel-js/routing';\nimport type { DepName, DepSchema } from 'interactions/actions/depSchema';\nimport type { Contribution } from '../tools/overlayBinding';\nimport type { CanvasExtensionApi } from './canvasExtension';\nimport type { CanvasViewProps } from './CanvasView';\nimport type { View } from '../core/viewport/view';\nimport type { KitRequirements } from './kitRequirements';\n\n/** Reads the surface's deps from inside `SurfaceContribution.attach`. */\nexport interface ContributionDepReader {\n  get<K extends DepName>(name: K): DepSchema[K] | undefined;\n}\n\n/** What {@link SurfaceContribution.beforePaint} and `afterPaint` are handed. */\nexport interface ContributionFrameCtx {\n  /** The frame's timestamp, on `performance.now()`'s clock. Both phases of one\n   *  frame see the same value. */\n  readonly time: number;\n  /** The surface camera this frame paints with. */\n  readonly view: View;\n  /** Ask for another frame. A hook animating something calls this every frame\n   *  it still has work for, and stops calling it to let the loop go idle. */\n  requestFrame(): void;\n  /** The surface's deps, as `attach` reads them. */\n  readonly deps: ContributionDepReader;\n}\n\n/**\n * A feature a surface installs in one step. Every role is optional: `bindings`,\n * `actions`, `deps`, `overlay` and `presentation` from `Contribution`, plus\n * the ones below. Installing it installs every role it declares, and removing\n * it removes them.\n */\nexport interface SurfaceContribution extends Contribution {\n  /** Views this entry adds to the surface, as `<SceneCanvas views>` takes. */\n  views?: readonly CanvasViewProps[];\n  /**\n   * Runs once the surface mounts; returns its teardown. For what the roles\n   * above cannot say — a registered (hit-testable) layer, a subscription.\n   *\n   * Keyed by the function's identity, so a contribution built once (in a\n   * `useMemo`, or at module scope) attaches once however often the host\n   * re-renders.\n   */\n  attach?: (api: CanvasExtensionApi, deps: ContributionDepReader) => () => void;\n  /**\n   * Runs on every frame the surface paints, before the paint — for state the\n   * entry's layers read, advanced once per frame. Hooks run in the order the\n   * surface lists its entries (registered tools, then `ambient` in array\n   * order), and one that throws is reported and skipped without stopping the\n   * frame.\n   */\n  beforePaint?: (ctx: ContributionFrameCtx) => void;\n  /** Runs after a frame's pixels have landed, in the same order as\n   *  {@link beforePaint}. A frame that painted nothing runs no `afterPaint`. */\n  afterPaint?: (ctx: ContributionFrameCtx) => void;\n  /**\n   * The kit versions this entry was written against, as semver ranges:\n   * `{ core: '^1.7' }`. A mismatch warns in development, or throws where the\n   * surface is set to `versionCheck=\"strict\"`.\n   */\n  requires?: KitRequirements;\n}\n\n/**\n * Concatenate contribution bundles into one registry, preserving order. Throws\n * on a duplicate entry id, dep name or view id — two features answering for\n * the same name is a bug in whichever was added second.\n */\nexport function mergeContributions<T extends SurfaceContribution>(\n  ...bundles: readonly (readonly T[])[]\n): T[] {\n  const out = mergeRoutingContributions<T>(...bundles);\n  const viewOwner = new Map<string, string>();\n  for (const entry of out) {\n    for (const view of entry.views ?? []) {\n      const owner = viewOwner.get(view.id);\n      if (owner !== undefined) {\n        throw new Error(\n          `mergeContributions: view \"${view.id}\" is added by both \"${owner}\" and \"${entry.id}\". `\n          + `View ids are unique per surface; rename one.`,\n        );\n      }\n      viewOwner.set(view.id, entry.id);\n    }\n  }\n  return out;\n}\n"],"mappings":";;AA0EA,SAAgBA,EACd,GAAGG,GACE;CACL,IAAMC,IAAMH,EAA6B,GAAGE,CAAO,GAC7CG,oBAAY,IAAI,IAAoB;CAC1C,KAAK,IAAMC,KAASH,GAClB,KAAK,IAAMI,KAAQD,EAAM,SAAS,CAAC,GAAG;EACpC,IAAME,IAAQH,EAAU,IAAIE,EAAK,EAAE;EACnC,IAAIC,MAAU,KAAA,GACZ,MAAU,MACR,6BAA6BD,EAAK,GAAG,sBAAsBC,EAAM,SAASF,EAAM,GAAG,gDAErF;EAEF,EAAU,IAAIC,EAAK,IAAID,EAAM,EAAE;CACjC;CAEF,OAAOH;AACT"}

package/dist/canvas/toolPreview.js

@@ -0,0 +1,39 @@
+//#region src/canvas/toolPreview.ts
+function* e(e) {
+	let t = /* @__PURE__ */ new Set(), n = e.hotkeyEngaged ? e.registry[e.hotkeyEngaged] : void 0, r = e.active === null ? void 0 : e.registry[e.active];
+	for (let e of [n, r]) e && !t.has(e) && (t.add(e), yield e);
+	for (let n of Object.values(e.registry)) n && !t.has(n) && (t.add(n), yield n);
+	for (let n of e.ambient) n && !t.has(n) && (t.add(n), yield n);
+}
+function t(t, n) {
+	if (!t) return null;
+	for (let r of e(t)) {
+		let e = r.previewPose?.(n);
+		if (e != null) return e;
+	}
+	return null;
+}
+function n(t, n) {
+	if (!t) return null;
+	for (let r of e(t)) {
+		let e = r.previewBounds?.(n);
+		if (e) return e;
+	}
+	return null;
+}
+function r(t) {
+	let n = /* @__PURE__ */ new Set();
+	if (!t) return n;
+	for (let r of e(t)) {
+		let e = r.previewIds?.();
+		if (e) for (let t of e) n.add(t);
+	}
+	return n;
+}
+function i(t) {
+	return t ? [...e(t)] : [];
+}
+//#endregion
+export { r as aggregatePreviewIds, n as firstPreviewBounds, t as firstPreviewPose, i as toolPreviewSources, e as toolsInPriorityOrder };
+
+//# sourceMappingURL=toolPreview.js.map

package/dist/canvas/toolPreview.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolPreview.js","names":["toolsInPriorityOrder","seen","hotkey","tools","active","t","firstPreviewPose","p","id","firstPreviewBounds","b","aggregatePreviewIds","out","ids","toolPreviewSources"],"sources":["../../src/canvas/toolPreview.ts"],"sourcesContent":["/**\n * Helpers for reading preview pose / bounds / ids from a ToolsApi.\n * Extracted from Canvas.tsx so SceneCanvas can use the same logic when\n * constructing scene-aware layers (selection overlay, etc.) without\n * going through Canvas's internal render closure.\n */\nimport type { ToolsApi } from '../tools/overlayBinding';\nimport type { AnyTool } from '../tools/overlayBinding';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { GesturePreviewSource } from './gestureBounds';\n\n/** Iterate all tools in priority order: hotkey-engaged → active → rest of\n *  registry → ambient. Skips duplicates so each tool is only visited once.\n *  This preserves the \"most-specific tool wins\" contract when multiple\n *  siblings of select each publish their own preview slice. */\nexport function* toolsInPriorityOrder(tools: ToolsApi): IterableIterator<AnyTool> {\n  const seen = new Set<AnyTool>();\n  const hotkey = tools.hotkeyEngaged ? tools.registry[tools.hotkeyEngaged] : undefined;\n  const active = tools.active === null ? undefined : tools.registry[tools.active];\n  for (const t of [hotkey, active]) {\n    if (t && !seen.has(t)) { seen.add(t); yield t; }\n  }\n  for (const t of Object.values(tools.registry)) {\n    if (t && !seen.has(t)) { seen.add(t); yield t; }\n  }\n  for (const t of tools.ambient) {\n    if (t && !seen.has(t)) { seen.add(t); yield t; }\n  }\n}\n\n/** Return the first non-null `previewPose(id)` from any tool in priority\n *  order, or `null` when no tool owns a preview for this id. */\nexport function firstPreviewPose(tools: ToolsApi | undefined, id: string): unknown {\n  if (!tools) return null;\n  for (const t of toolsInPriorityOrder(tools)) {\n    const p = t.previewPose?.(id);\n    if (p != null) return p;\n  }\n  return null;\n}\n\n/** Return the first non-null `previewBounds(id)` from any tool in priority\n *  order, or `null` when no tool owns a bounds preview for this id. */\nexport function firstPreviewBounds(tools: ToolsApi | undefined, id: string): Bounds | null {\n  if (!tools) return null;\n  for (const t of toolsInPriorityOrder(tools)) {\n    const b = t.previewBounds?.(id);\n    if (b) return b as Bounds;\n  }\n  return null;\n}\n\n/** Aggregate all `previewIds()` from every registered tool into a single Set. */\nexport function aggregatePreviewIds(tools: ToolsApi | undefined): Set<string> {\n  const out = new Set<string>();\n  if (!tools) return out;\n  for (const t of toolsInPriorityOrder(tools)) {\n    const ids = t.previewIds?.();\n    if (!ids) continue;\n    for (const id of ids) out.add(id);\n  }\n  return out;\n}\n\n/** Every tool that can publish a preview, in priority order and deduplicated —\n *  the tool half of a view's preview sources. A drag may run through `select`\n *  while the active tool is `clone`, so the active tool alone is the wrong\n *  source. */\nexport function toolPreviewSources(tools: ToolsApi | undefined): GesturePreviewSource[] {\n  if (!tools) return [];\n  return [...toolsInPriorityOrder(tools)];\n}\n"],"mappings":";AAeA,UAAiBA,EAAqB,GAA4C;CAChF,IAAMC,oBAAO,IAAI,IAAa,GACxBC,IAASC,EAAM,gBAAgBA,EAAM,SAASA,EAAM,iBAAiB,KAAA,GACrEC,IAASD,EAAM,WAAW,OAAO,KAAA,IAAYA,EAAM,SAASA,EAAM;CACxE,KAAK,IAAME,KAAK,CAACH,GAAQE,CAAM,GAC7B,AAAIC,KAAK,CAACJ,EAAK,IAAII,CAAC,MAAKJ,EAAK,IAAII,CAAC,GAAG,MAAMA;CAE9C,KAAK,IAAMA,KAAK,OAAO,OAAOF,EAAM,QAAQ,GAC1C,AAAIE,KAAK,CAACJ,EAAK,IAAII,CAAC,MAAKJ,EAAK,IAAII,CAAC,GAAG,MAAMA;CAE9C,KAAK,IAAMA,KAAKF,EAAM,SACpB,AAAIE,KAAK,CAACJ,EAAK,IAAII,CAAC,MAAKJ,EAAK,IAAII,CAAC,GAAG,MAAMA;AAEhD;AAIA,SAAgBC,EAAiB,GAA6B,GAAqB;CACjF,IAAI,CAACH,GAAO,OAAO;CACnB,KAAK,IAAME,KAAKL,EAAqBG,CAAK,GAAG;EAC3C,IAAMI,IAAIF,EAAE,cAAcG,CAAE;EAC5B,IAAID,KAAK,MAAM,OAAOA;CACxB;CACA,OAAO;AACT;AAIA,SAAgBE,EAAmB,GAA6B,GAA2B;CACzF,IAAI,CAACN,GAAO,OAAO;CACnB,KAAK,IAAME,KAAKL,EAAqBG,CAAK,GAAG;EAC3C,IAAMO,IAAIL,EAAE,gBAAgBG,CAAE;EAC9B,IAAIE,GAAG,OAAOA;CAChB;CACA,OAAO;AACT;AAGA,SAAgBC,EAAoB,GAA0C;CAC5E,IAAMC,oBAAM,IAAI,IAAY;CAC5B,IAAI,CAACT,GAAO,OAAOS;CACnB,KAAK,IAAMP,KAAKL,EAAqBG,CAAK,GAAG;EAC3C,IAAMU,IAAMR,EAAE,aAAa;EAC3B,IAAKQ,GACL,KAAK,IAAML,KAAMK,GAAK,EAAI,IAAIL,CAAE;CAClC;CACA,OAAOI;AACT;AAMA,SAAgBE,EAAmB,GAAqD;CAEtF,OADKX,IACE,CAAC,GAAGH,EAAqBG,CAAK,CAAC,IADnB,CAAC;AAEtB"}

package/dist/canvas/useCanvasRenderer.js

@@ -0,0 +1,11 @@
+import { leaseCanvasRenderer as e } from "./canvasRenderer.js";
+import { useEffect as t, useState as n } from "react";
+//#region src/canvas/useCanvasRenderer.ts
+function r() {
+	let [r] = n(e);
+	return t(() => () => r.release(), [r]), r;
+}
+//#endregion
+export { r as useCanvasRenderer };
+
+//# sourceMappingURL=useCanvasRenderer.js.map

package/dist/canvas/useCanvasRenderer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCanvasRenderer.js","names":["useCanvasRenderer","lease","useState","leaseCanvasRenderer","useEffect"],"sources":["../../src/canvas/useCanvasRenderer.ts"],"sourcesContent":["import { useEffect, useState } from 'react';\nimport { leaseCanvasRenderer, type CanvasRendererLease } from './canvasRenderer';\n\n/**\n * The React lifetime of `leaseCanvasRenderer`: a stable lease for the\n * component's canvas, whose renderer and GL objects are freed on unmount.\n * Every canvas surface in core paints through this, so none can skip the\n * teardown.\n */\nexport function useCanvasRenderer(): CanvasRendererLease {\n  const [lease] = useState(leaseCanvasRenderer);\n  useEffect(() => () => lease.release(), [lease]);\n  return lease;\n}\n"],"mappings":";;;AASA,SAAgBA,IAAyC;CACvD,IAAM,CAACC,KAASC,EAASC,CAAmB;CAE5C,OADAC,cAAsBH,EAAM,QAAQ,GAAG,CAACA,CAAK,CAAC,GACvCA;AACT"}

package/dist/canvas/useFrameLoop.js

@@ -0,0 +1,60 @@
+import { useVisibleRaf as e } from "../scheduling/useVisibleRaf.js";
+import { useCallback as t, useInsertionEffect as n, useLayoutEffect as r, useRef as i } from "react";
+import { useLatest as a } from "@weasel-js/react";
+//#region src/canvas/useFrameLoop.ts
+function o(o, s = {}) {
+	let c = i(!0), l = i(!0), u = i(!1), d = a(o), f = a(s.syncPaint ?? !1), p = i(/* @__PURE__ */ new Set()), m = i(/* @__PURE__ */ new Set()), h = i(!1), g = i(null), _ = t((e) => {
+		c.current = !1, u.current = !0;
+		let t = !1;
+		try {
+			for (let t of m.current) t(e);
+			if (t = d.current(), !t) {
+				c.current = !0;
+				return;
+			}
+			h.current = !1;
+			for (let t of p.current) t(e);
+		} catch (e) {
+			throw c.current = !0, h.current || (h.current = !0, g.current?.()), e;
+		} finally {
+			u.current = !1;
+		}
+	}, [d]), v = e(t((e) => {
+		l.current && c.current && _(e);
+	}, [_]), { target: s.target });
+	n(() => {
+		g.current = () => {
+			v.request();
+		};
+	});
+	let y = t(() => {
+		if (c.current = !0, f.current && l.current && !u.current && v.isVisible()) {
+			_(performance.now());
+			return;
+		}
+		v.request();
+	}, [
+		v,
+		_,
+		f
+	]), b = t((e) => (p.current.add(e), () => {
+		p.current.delete(e);
+	}), []), x = t((e) => (m.current.add(e), () => {
+		m.current.delete(e);
+	}), []);
+	return r(() => {
+		l.current = !0;
+		let e = p.current, t = m.current;
+		return () => {
+			l.current = !1, e.clear(), t.clear();
+		};
+	}, []), {
+		requestRedraw: y,
+		subscribeFrame: b,
+		subscribeBeforePaint: x
+	};
+}
+//#endregion
+export { o as useFrameLoop };
+
+//# sourceMappingURL=useFrameLoop.js.map

package/dist/canvas/useFrameLoop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFrameLoop.js","names":["useFrameLoop","dirtyRef","useRef","aliveRef","paintingRef","paintRef","useLatest","paint","syncRef","options","subsRef","beforeRef","retriedRef","rearmRef","runPaint","useCallback","landed","fn","time","err","frame","useVisibleRaf","requestRedraw","subscribeFrame","subscribeBeforePaint","useLayoutEffect","subs","before"],"sources":["../../src/canvas/useFrameLoop.ts"],"sourcesContent":["/**\n * The frame loop behind `<Canvas>`: a dirty flag, one frame in flight at a\n * time, and a subscriber set notified after a paint lands. When frames may run\n * at all is `useVisibleRaf`'s question, not this hook's — a redraw requested\n * while nothing can see the surface is held there and re-armed on resume.\n *\n * @internal Not consumer surface. Canvas exposes `requestRedraw` and\n *   `subscribeFrame` on its ref handle; this is how they are implemented.\n */\n\nimport { useCallback, useInsertionEffect, useLayoutEffect, useRef } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { useVisibleRaf, type VisibleRafTarget } from '../scheduling/useVisibleRaf';\n\nexport interface FrameLoop {\n  /** Mark the surface dirty and schedule a frame. Identity is stable for the\n   *  lifetime of the component — consumers capture it. */\n  requestRedraw(): void;\n  /** Run `fn` after every landed paint, with the frame's time. Returns an\n   *  unsubscribe. */\n  subscribeFrame(fn: (time: number) => void): () => void;\n  /** Run `fn` on every frame just before its paint, with the frame's time.\n   *  Returns an unsubscribe. */\n  subscribeBeforePaint(fn: (time: number) => void): () => void;\n}\n\nexport interface FrameLoopOptions {\n  /** Paint in the caller's own stack — the commit or event that asked for the\n   *  redraw — instead of on the next animation frame. Read live, so toggling\n   *  it takes effect from the next `requestRedraw` on. */\n  syncPaint?: boolean;\n  /** The surface being painted. Given one, the loop also stops while that\n   *  element sits outside the viewport, not only while the tab is hidden. */\n  target?: VisibleRafTarget;\n}\n\n/**\n * @param paint Runs on the frame; returns whether pixels landed. A `false`\n *   leaves the surface dirty and notifies nobody, so the next request retries.\n */\nexport function useFrameLoop(paint: () => boolean, options: FrameLoopOptions = {}): FrameLoop {\n  const dirtyRef = useRef(true);\n  const aliveRef = useRef(true);\n  const paintingRef = useRef(false);\n  const paintRef = useLatest(paint);\n  const syncRef = useLatest(options.syncPaint ?? false);\n  const subsRef = useRef<Set<(time: number) => void>>(new Set());\n  const beforeRef = useRef<Set<(time: number) => void>>(new Set());\n\n  /** Set while recovering from a paint that threw, so one bad frame is retried\n   *  and a permanently throwing one still doesn't spin at frame rate. */\n  const retriedRef = useRef(false);\n  /** `frame.request`, which doesn't exist until after `runPaint` is built. */\n  const rearmRef = useRef<(() => void) | null>(null);\n\n  const runPaint = useCallback((time: number) => {\n    dirtyRef.current = false;\n    paintingRef.current = true;\n    let landed = false;\n    try {\n      for (const fn of beforeRef.current) fn(time);\n      landed = paintRef.current();\n      if (!landed) {\n        dirtyRef.current = true;\n        return;\n      }\n      retriedRef.current = false;\n      // Notified inside the guard: a subscriber calling `requestRedraw` under\n      // `syncPaint` would otherwise re-enter this synchronously, without bound.\n      for (const fn of subsRef.current) fn(time);\n    } catch (err) {\n      // A throw skips the `!landed` branch above, so without this the surface\n      // is left clean but unpainted — the pixels on screen are whatever the\n      // last landed frame left, and nothing repaints until something\n      // unrelated happens to request a redraw. That is how a single\n      // malformed node blanked a whole document until the pointer moved.\n      dirtyRef.current = true;\n      if (!retriedRef.current) {\n        retriedRef.current = true;\n        rearmRef.current?.();\n      }\n      throw err;\n    } finally {\n      paintingRef.current = false;\n    }\n  }, [paintRef]);\n\n  const frame = useVisibleRaf(\n    useCallback((time: number) => {\n      if (!aliveRef.current || !dirtyRef.current) return;\n      runPaint(time);\n    }, [runPaint]),\n    { target: options.target },\n  );\n  useInsertionEffect(() => {\n    rearmRef.current = () => { frame.request(); };\n  });\n\n  const requestRedraw = useCallback(() => {\n    dirtyRef.current = true;\n    // The gate suppresses the sync path too: a background tab still commits\n    // React updates, and that is the one paint browser throttling does not stop.\n    // A request made from inside a draw or a frame subscriber would recurse\n    // forever if it painted here, so re-entrant ones fall through to a frame.\n    if (syncRef.current && aliveRef.current && !paintingRef.current && frame.isVisible()) {\n      runPaint(performance.now());\n      return;\n    }\n    frame.request();\n  }, [frame, runPaint, syncRef]);\n\n  const subscribeFrame = useCallback((fn: (time: number) => void) => {\n    subsRef.current.add(fn);\n    return () => { subsRef.current.delete(fn); };\n  }, []);\n  const subscribeBeforePaint = useCallback((fn: (time: number) => void) => {\n    beforeRef.current.add(fn);\n    return () => { beforeRef.current.delete(fn); };\n  }, []);\n\n  // `requestRedraw` outlives the component: `@weasel-js/hud` calls it from a\n  // `.then()`, and `viewRegistry.attachSurface` hands it to the consumer.\n  // Re-armed in setup because refs survive StrictMode's simulated remount, and\n  // a layout effect so the arming precedes Canvas's own layout effects — the\n  // sync-paint path runs in one of those.\n  useLayoutEffect(() => {\n    aliveRef.current = true;\n    const subs = subsRef.current;\n    const before = beforeRef.current;\n    return () => {\n      aliveRef.current = false;\n      subs.clear();\n      before.clear();\n    };\n  }, []);\n\n  return { requestRedraw, subscribeFrame, subscribeBeforePaint };\n}\n"],"mappings":";;;;AAwCA,SAAgBA,EAAa,GAAsB,IAA4B,CAAC,GAAc;CAC5F,IAAMC,IAAWC,EAAO,EAAI,GACtBC,IAAWD,EAAO,EAAI,GACtBE,IAAcF,EAAO,EAAK,GAC1BG,IAAWC,EAAUC,CAAK,GAC1BC,IAAUF,EAAUG,EAAQ,aAAa,EAAK,GAC9CC,IAAUR,kBAAoC,IAAI,IAAI,CAAC,GACvDS,IAAYT,kBAAoC,IAAI,IAAI,CAAC,GAIzDU,IAAaV,EAAO,EAAK,GAEzBW,IAAWX,EAA4B,IAAI,GAE3CY,IAAWC,GAAa,MAAiB;EAE7C,AADA,EAAS,UAAU,IACnB,EAAY,UAAU;EACtB,IAAIC,IAAS;EACb,IAAI;GACF,KAAK,IAAMC,KAAMN,EAAU,SAAS,EAAGO,CAAI;GAE3C,IADA,IAASb,EAAS,QAAQ,GACtB,CAACW,GAAQ;IACX,EAAS,UAAU;IACnB;GACF;GACA,EAAW,UAAU;GAGrB,KAAK,IAAMC,KAAMP,EAAQ,SAAS,EAAGQ,CAAI;EAC3C,SAASC,GAAK;GAWZ,MALA,EAAS,UAAU,IACdP,EAAW,YACd,EAAW,UAAU,IACrBC,EAAS,UAAU,IAEfM;EACR,UAAU;GACR,EAAY,UAAU;EACxB;CACF,GAAG,CAACd,CAAQ,CAAC,GAEPe,IAAQC,EACZN,GAAa,MAAiB;EAC5B,AAAKZ,EAAS,WAAYF,EAAS,WACnCa,EAASI,CAAI;CACf,GAAG,CAACJ,CAAQ,CAAC,GACb,EAAE,QAAQL,EAAQ,OAAO,CAC3B;CACA,QAAyB;EACvB,EAAS,gBAAgB;GAAE,EAAM,QAAQ;EAAG;CAC9C,CAAC;CAED,IAAMa,IAAgBP,QAAkB;EAMtC,IALA,EAAS,UAAU,IAKfP,EAAQ,WAAWL,EAAS,WAAW,CAACC,EAAY,WAAWgB,EAAM,UAAU,GAAG;GACpF,EAAS,YAAY,IAAI,CAAC;GAC1B;EACF;EACA,EAAM,QAAQ;CAChB,GAAG;EAACA;EAAON;EAAUN;CAAO,CAAC,GAEvBe,IAAiBR,GAAa,OAClCL,EAAQ,QAAQ,IAAIO,CAAE,SACT;EAAE,EAAQ,QAAQ,OAAOA,CAAE;CAAG,IAC1C,CAAC,CAAC,GACCO,IAAuBT,GAAa,OACxCJ,EAAU,QAAQ,IAAIM,CAAE,SACX;EAAE,EAAU,QAAQ,OAAOA,CAAE;CAAG,IAC5C,CAAC,CAAC;CAkBL,OAXAQ,QAAsB;EACpB,EAAS,UAAU;EACnB,IAAMC,IAAOhB,EAAQ,SACfiB,IAAShB,EAAU;EACzB,aAAa;GAGX,AAFA,EAAS,UAAU,IACnBe,EAAK,MAAM,GACXC,EAAO,MAAM;EACf;CACF,GAAG,CAAC,CAAC,GAEE;EAAE;EAAe;EAAgB;CAAqB;AAC/D"}

package/dist/canvas/useHostAnchor.js

@@ -0,0 +1,71 @@
+import { useVisibleRaf as e } from "../scheduling/useVisibleRaf.js";
+import { hostAnchorCss as t, hostAnchorRect as n } from "./hostAnchor.js";
+import { useCallback as r, useEffect as i, useState as a } from "react";
+import { useLatest as o } from "@weasel-js/react";
+//#region src/canvas/useHostAnchor.ts
+function s(s, c) {
+	let [l, u] = a(null), [d, f] = a(null), p = r((e) => u(e), []), m = o(s), { align: h, offset: g, padding: _ = 0 } = c, { x: v, y } = h, { x: b, y: x } = g, S = r(() => {
+		let e = m.current();
+		if (!e) {
+			f(null);
+			return;
+		}
+		let r = e.getBoundingClientRect(), i = l?.getBoundingClientRect(), a = {
+			width: window.innerWidth,
+			height: window.innerHeight
+		}, o = {
+			x: v,
+			y
+		}, s = n({
+			host: {
+				x: r.left,
+				y: r.top,
+				width: r.width,
+				height: r.height
+			},
+			panel: {
+				width: i?.width ?? 0,
+				height: i?.height ?? 0
+			},
+			viewport: a,
+			align: o,
+			offset: {
+				x: b,
+				y: x
+			},
+			padding: _
+		});
+		f(t(s, o, a));
+	}, [
+		m,
+		l,
+		v,
+		y,
+		b,
+		x,
+		_
+	]), C = e(S);
+	return i(() => {
+		S();
+		let e = () => C.request();
+		window.addEventListener("scroll", e, !0), window.addEventListener("resize", e);
+		let t = typeof ResizeObserver < "u" ? new ResizeObserver(e) : null;
+		l && t?.observe(l);
+		let n = m.current();
+		return n && t?.observe(n), () => {
+			window.removeEventListener("scroll", e, !0), window.removeEventListener("resize", e), C.cancel(), t?.disconnect();
+		};
+	}, [
+		S,
+		C,
+		l,
+		m
+	]), {
+		ref: p,
+		style: d
+	};
+}
+//#endregion
+export { s as useHostAnchor };
+
+//# sourceMappingURL=useHostAnchor.js.map

package/dist/canvas/useHostAnchor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useHostAnchor.js","names":["useHostAnchor","panel","setPanel","useState","style","setStyle","ref","useCallback","el","resolve","useLatest","resolveHost","options","alignX","alignY","align","offsetX","offsetY","offset","recompute","hostEl","h","p","viewport","rect","hostAnchorRect","hostAnchorCss","padding","raf","useVisibleRaf","useEffect","schedule","observer"],"sources":["../../src/canvas/useHostAnchor.ts"],"sourcesContent":["import { useCallback, useEffect, useState } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { useVisibleRaf } from '../scheduling/useVisibleRaf';\nimport {\n  hostAnchorCss, hostAnchorRect,\n  type HostAnchorAlign, type HostAnchorOffset,\n} from './hostAnchor';\n\n/** Options for {@link useHostAnchor}. */\nexport interface UseHostAnchorOptions {\n  align: HostAnchorAlign;\n  offset: HostAnchorOffset;\n  /** Minimum gap kept between the panel and the viewport edge. Default 0. */\n  padding?: number;\n}\n\n/** CSS the caller spreads onto the panel; which edges appear follows `align`. */\nexport type HostAnchorStyle = { top?: number; right?: number; bottom?: number; left?: number };\n\n/**\n * Hold a fixed-position panel against a host element's corner, kept inside the\n * viewport, following it through scrolls, resizes and reflows.\n *\n * `resolveHost` runs on every recompute, so a host that mounts late or is found\n * by selector works the same as one held in a ref. Put the returned `ref` on the\n * panel: until it is measured the panel counts as zero-sized, which resolves to\n * the bare corner, so the first paint lands where an unclamped anchor would and\n * measurement only ever pulls it back on screen.\n */\nexport function useHostAnchor(\n  resolveHost: () => Element | null,\n  options: UseHostAnchorOptions,\n): { ref: (el: HTMLElement | null) => void; style: HostAnchorStyle | null } {\n  const [panel, setPanel] = useState<HTMLElement | null>(null);\n  const [style, setStyle] = useState<HostAnchorStyle | null>(null);\n  const ref = useCallback((el: HTMLElement | null) => setPanel(el), []);\n\n  // Held in a ref so a caller passing an inline arrow doesn't re-subscribe\n  // every render.\n  const resolve = useLatest(resolveHost);\n\n  const { align, offset, padding = 0 } = options;\n  const { x: alignX, y: alignY } = align;\n  const { x: offsetX, y: offsetY } = offset;\n\n  const recompute = useCallback(() => {\n    const hostEl = resolve.current();\n    if (!hostEl) {\n      setStyle(null);\n      return;\n    }\n    const h = hostEl.getBoundingClientRect();\n    const p = panel?.getBoundingClientRect();\n    const viewport = { width: window.innerWidth, height: window.innerHeight };\n    const align = { x: alignX, y: alignY };\n    const rect = hostAnchorRect({\n      host: { x: h.left, y: h.top, width: h.width, height: h.height },\n      panel: { width: p?.width ?? 0, height: p?.height ?? 0 },\n      viewport,\n      align,\n      offset: { x: offsetX, y: offsetY },\n      padding,\n    });\n    setStyle(hostAnchorCss(rect, align, viewport));\n  }, [resolve, panel, alignX, alignY, offsetX, offsetY, padding]);\n\n  // Coalesces bursts of scroll/resize into one frame, and holds the work while\n  // the tab is hidden rather than dropping it.\n  const raf = useVisibleRaf(recompute);\n\n  useEffect(() => {\n    recompute();\n    const schedule = () => raf.request();\n    window.addEventListener('scroll', schedule, true);\n    window.addEventListener('resize', schedule);\n    const observer =\n      typeof ResizeObserver !== 'undefined' ? new ResizeObserver(schedule) : null;\n    if (panel) observer?.observe(panel);\n    const hostEl = resolve.current();\n    if (hostEl) observer?.observe(hostEl);\n\n    return () => {\n      window.removeEventListener('scroll', schedule, true);\n      window.removeEventListener('resize', schedule);\n      raf.cancel();\n      observer?.disconnect();\n    };\n  }, [recompute, raf, panel, resolve]);\n\n  return { ref, style };\n}\n"],"mappings":";;;;;AA6BA,SAAgBA,EACd,GACA,GAC0E;CAC1E,IAAM,CAACC,GAAOC,KAAYC,EAA6B,IAAI,GACrD,CAACC,GAAOC,KAAYF,EAAiC,IAAI,GACzDG,IAAMC,GAAa,MAA2BL,EAASM,CAAE,GAAG,CAAC,CAAC,GAI9DC,IAAUC,EAAUC,CAAW,GAE/B,EAAE,UAAO,WAAQ,aAAU,MAAMC,GACjC,EAAE,GAAGC,GAAWC,MAAWC,GAC3B,EAAE,GAAGC,GAAS,GAAGC,MAAYC,GAE7BC,IAAYZ,QAAkB;EAClC,IAAMa,IAASX,EAAQ,QAAQ;EAC/B,IAAI,CAACW,GAAQ;GACX,EAAS,IAAI;GACb;EACF;EACA,IAAMC,IAAID,EAAO,sBAAsB,GACjCE,IAAIrB,GAAO,sBAAsB,GACjCsB,IAAW;GAAE,OAAO,OAAO;GAAY,QAAQ,OAAO;EAAY,GAClER,IAAQ;GAAE,GAAGF;GAAWC;EAAO,GAC/BU,IAAOC,EAAe;GAC1B,MAAM;IAAE,GAAGJ,EAAE;IAAM,GAAGA,EAAE;IAAK,OAAOA,EAAE;IAAO,QAAQA,EAAE;GAAO;GAC9D,OAAO;IAAE,OAAOC,GAAG,SAAS;IAAG,QAAQA,GAAG,UAAU;GAAE;GACtD;GACA;GACA,QAAQ;IAAE,GAAGN;IAAS,GAAGC;GAAQ;GACjC;EACF,CAAC;EACD,EAASS,EAAcF,GAAMT,GAAOQ,CAAQ,CAAC;CAC/C,GAAG;EAACd;EAASR;EAAOY;EAAQC;EAAQE;EAASC;EAASU;CAAO,CAAC,GAIxDC,IAAMC,EAAcV,CAAS;CAqBnC,OAnBAW,QAAgB;EACd,EAAU;EACV,IAAMC,UAAiBH,EAAI,QAAQ;EAEnC,AADA,OAAO,iBAAiB,UAAUG,GAAU,EAAI,GAChD,OAAO,iBAAiB,UAAUA,CAAQ;EAC1C,IAAMC,IACJ,OAAO,iBAAmB,MAAc,IAAI,eAAeD,CAAQ,IAAI;EACzE,AAAI9B,KAAO+B,GAAU,QAAQ/B,CAAK;EAClC,IAAMmB,IAASX,EAAQ,QAAQ;EAG/B,OAFIW,KAAQY,GAAU,QAAQZ,CAAM,SAEvB;GAIX,AAHA,OAAO,oBAAoB,UAAUW,GAAU,EAAI,GACnD,OAAO,oBAAoB,UAAUA,CAAQ,GAC7CH,EAAI,OAAO,GACXI,GAAU,WAAW;EACvB;CACF,GAAG;EAACb;EAAWS;EAAK3B;EAAOQ;CAAO,CAAC,GAE5B;EAAE;EAAK;CAAM;AACtB"}

package/dist/canvas/useLateContentRedraw.js

@@ -0,0 +1,21 @@
+import { paintKindRegistry as e } from "../core/paintKinds.js";
+import { subscribeImageReady as t } from "../features/images/imageCache.js";
+import { subscribeGlyphReady as n } from "@weasel-js/font";
+import { useEffect as r } from "react";
+//#region src/canvas/useLateContentRedraw.ts
+function i(i) {
+	r(() => {
+		let r = [
+			t(i),
+			n(i),
+			e.subscribe(i)
+		];
+		return () => {
+			for (let e of r) e();
+		};
+	}, [i]);
+}
+//#endregion
+export { i as useLateContentRedraw };
+
+//# sourceMappingURL=useLateContentRedraw.js.map

package/dist/canvas/useLateContentRedraw.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLateContentRedraw.js","names":["useLateContentRedraw","offs","subscribeImageReady","requestRedraw","subscribeGlyphReady","paintKindRegistry","off"],"sources":["../../src/canvas/useLateContentRedraw.ts"],"sourcesContent":["import { useEffect } from 'react';\nimport { subscribeGlyphReady } from '@weasel-js/font';\nimport { subscribeImageReady } from 'features/images/imageCache';\nimport { paintKindRegistry } from 'core/paintKinds';\n\n/**\n * Repaint whenever something a frame could not draw becomes drawable: an image\n * finishes decoding, a deferred glyph bake or font load lands, or a paint kind\n * registers late. Each of these drew nothing (or a placeholder) on the frame\n * that asked for it and says nothing further unless a surface is listening.\n */\nexport function useLateContentRedraw(requestRedraw: () => void): void {\n  useEffect(() => {\n    const offs = [\n      subscribeImageReady(requestRedraw),\n      subscribeGlyphReady(requestRedraw),\n      paintKindRegistry.subscribe(requestRedraw),\n    ];\n    return () => { for (const off of offs) off(); };\n  }, [requestRedraw]);\n}\n"],"mappings":";;;;;AAWA,SAAgBA,EAAqB,GAAiC;CACpE,QAAgB;EACd,IAAMC,IAAO;GACXC,EAAoBC,CAAa;GACjCC,EAAoBD,CAAa;GACjCE,EAAkB,UAAUF,CAAa;EAC3C;EACA,aAAa;GAAE,KAAK,IAAMG,KAAOL,GAAM,EAAI;EAAG;CAChD,GAAG,CAACE,CAAa,CAAC;AACpB"}

package/dist/canvas/useRedrawOn.js

@@ -0,0 +1,21 @@
+import { useEffect as e, useState as t } from "react";
+//#region src/canvas/useRedrawOn.ts
+function n(t, n) {
+	let i = r(t);
+	e(() => {
+		let e = () => {
+			n();
+		}, t = (i ?? []).map((t) => t.subscribe(e));
+		return () => {
+			for (let e of t) e();
+		};
+	}, [i, n]);
+}
+function r(e) {
+	let [n, r] = t(e);
+	return n !== e && !(n && e && n.length === e.length && n.every((t, n) => t === e[n])) ? (r(e), e) : n;
+}
+//#endregion
+export { n as useRedrawOn };
+
+//# sourceMappingURL=useRedrawOn.js.map

package/dist/canvas/useRedrawOn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRedrawOn.js","names":["useRedrawOn","kept","useSameElements","sources","redraw","offs","src","off","requestRedraw","setKept","useState","list","x","i"],"sources":["../../src/canvas/useRedrawOn.ts"],"sourcesContent":["import { useEffect, useState } from 'react';\nimport type { RedrawSource } from '../core/layers/render';\n\n/** Subscribe `requestRedraw` to each source while mounted. An inline array\n *  holding the same sources does not resubscribe. */\nexport function useRedrawOn(sources: readonly RedrawSource[] | undefined, requestRedraw: () => void): void {\n  const kept = useSameElements(sources);\n  useEffect(() => {\n    const redraw = (): void => { requestRedraw(); };\n    const offs = (kept ?? []).map((src) => src.subscribe(redraw));\n    return () => { for (const off of offs) off(); };\n  }, [kept, requestRedraw]);\n}\n\n/** `list` as last passed, kept by identity while it holds the same elements —\n *  so an inline array prop does not read as a change every render. */\nfunction useSameElements<T>(list: readonly T[] | undefined): readonly T[] | undefined {\n  // Derived state rather than a ref, so a render React throws away can't\n  // leave its list behind as the one the next render compares against.\n  const [kept, setKept] = useState(list);\n  if (kept !== list && !(kept && list && kept.length === list.length && kept.every((x, i) => x === list[i]))) {\n    setKept(list);\n    return list;\n  }\n  return kept;\n}\n"],"mappings":";;AAKA,SAAgBA,EAAY,GAA8C,GAAiC;CACzG,IAAMC,IAAOC,EAAgBC,CAAO;CACpC,QAAgB;EACd,IAAMC,UAAqB;GAAE,EAAc;EAAG,GACxCC,KAAQJ,KAAQ,CAAC,EAAA,CAAG,KAAK,MAAQK,EAAI,UAAUF,CAAM,CAAC;EAC5D,aAAa;GAAE,KAAK,IAAMG,KAAOF,GAAM,EAAI;EAAG;CAChD,GAAG,CAACJ,GAAMO,CAAa,CAAC;AAC1B;AAIA,SAASN,EAAmB,GAA0D;CAGpF,IAAM,CAACD,GAAMQ,KAAWC,EAASC,CAAI;CAKrC,OAJIV,MAASU,KAAQ,EAAEV,KAAQU,KAAQV,EAAK,WAAWU,EAAK,UAAUV,EAAK,OAAO,GAAG,MAAMW,MAAMD,EAAKE,EAAE,MACtGJ,EAAQE,CAAI,GACLA,KAEFV;AACT"}