@weasel-js/core 1.9.4 → 1.10.1

package/dist/features/patterns/rasterizeTile.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"rasterizeTile.js","names":["rasterizeTile","off","opts","c","oc"],"sources":["../../../src/features/patterns/rasterizeTile.ts"],"sourcesContent":["import type { TilePatternOpts } from '.';\n\n/** Draw one tile and hand back its pixels, or `null` where no\n *  `OffscreenCanvas` 2D context can be had. */\nexport function rasterizeTile(opts: TilePatternOpts): ImageBitmap | null {\n  // Prefer OffscreenCanvas; fall back to <canvas> for environments without it.\n  let off: OffscreenCanvas | HTMLCanvasElement;\n  try {\n    off = new OffscreenCanvas(opts.size, opts.size);\n  } catch {\n    if (typeof document === 'undefined') return null;\n    const c = document.createElement('canvas');\n    c.width = opts.size;\n    c.height = opts.size;\n    off = c;\n  }\n  const oc = off.getContext('2d') as CanvasRenderingContext2D | null;\n  if (!oc) return null;\n  opts.draw(oc, opts.size);\n\n  // Only an OffscreenCanvas can hand over a bitmap synchronously.\n  if (typeof (off as OffscreenCanvas).transferToImageBitmap !== 'function') return null;\n  return (off as OffscreenCanvas).transferToImageBitmap();\n}\n"],"mappings":";AAIA,SAAgBA,EAAc,GAA2C;CAEvE,IAAIC;CACJ,IAAI;EACF,IAAM,IAAI,gBAAgBC,EAAK,MAAMA,EAAK,IAAI;CAChD,QAAQ;EACN,IAAI,OAAO,WAAa,KAAa,OAAO;EAC5C,IAAMC,IAAI,SAAS,cAAc,QAAQ;EAGzC,AAFA,EAAE,QAAQD,EAAK,MACf,EAAE,SAASA,EAAK,MAChB,IAAMC;CACR;CACA,IAAMC,IAAKH,EAAI,WAAW,IAAI;CAM9B,OALI,CAACG,MACLF,EAAK,KAAKE,GAAIF,EAAK,IAAI,GAGnB,OAAQD,EAAwB,yBAA0B,cAAmB,OACzEA,EAAwB,sBAAsB;AACxD"}

package/dist/features/patterns/resolveSpec.js

@@ -1,65 +0,0 @@
-import { ownTextureIds as e, registerTextureAs as t, textureRegistry as n, unregisterTexture as r } from "../../renderer/textures/registerTexture.js";
-import { rasterizeTile as i } from "./rasterizeTile.js";
-import { drawTileShapes as a, tileGeometry as o, tileSize as s } from "./tileGeometry.js";
-//#region src/features/patterns/resolveSpec.ts
-var c = 256, l = "pattern:", u = /* @__PURE__ */ new Map();
-function d(e) {
-	let t = e, n = {};
-	for (let e of Object.keys(t).sort()) n[e] = t[e];
-	return l + JSON.stringify(n);
-}
-function f(e) {
-	let t = d(e), n = u.get(t);
-	return n === void 0 ? m(t, e) : (p(t), n);
-}
-function p(e) {
-	let t = u.get(e);
-	t !== void 0 && (u.delete(e), u.set(e, t));
-}
-function m(e, n) {
-	let r = h.has(n.tile) ? i({
-		size: s(n),
-		draw: (e) => a(e, o(n))
-	}) : null, l = r ? t(e, r) : null;
-	for (u.delete(e), u.set(e, l); u.size > c;) g(u.keys().next().value);
-	return l;
-}
-var h = /* @__PURE__ */ new Set([
-	"hatch",
-	"crosshatch",
-	"dots",
-	"chunks"
-]);
-function g(e) {
-	u.delete(e);
-	let t = n.get(e)?.source;
-	r({ id: e }), t && "close" in t && t.close();
-}
-function _(e) {
-	let t;
-	try {
-		t = JSON.parse(e.slice(8));
-	} catch {
-		return;
-	}
-	typeof t == "object" && t && "tile" in t && m(e, t);
-}
-e(l, {
-	revive: _,
-	touched: p
-});
-function v(e) {
-	return "tile" in e;
-}
-function y(e) {
-	if (e.fill !== "pattern" || !v(e.pattern)) return e;
-	let t = f(e.pattern);
-	return t ? {
-		...e,
-		pattern: t
-	} : null;
-}
-//#endregion
-export { c as PATTERN_TILE_CACHE_LIMIT, v as isPatternSpec, y as resolveFillPattern, f as resolvePatternSpec };
-
-//# sourceMappingURL=resolveSpec.js.map

package/dist/features/patterns/resolveSpec.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolveSpec.js","names":["PATTERN_TILE_CACHE_LIMIT","ID_PREFIX","cache","specId","bag","spec","sorted","k","resolvePatternSpec","id","hit","build","markUsed","bitmap","TILES","rasterizeTile","tileSize","drawTileShapes","oc","tileGeometry","handle","registerTextureAs","evict","source","textureRegistry","unregisterTexture","revive","ownTextureIds","isPatternSpec","payload","resolveFillPattern","fill"],"sources":["../../../src/features/patterns/resolveSpec.ts"],"sourcesContent":["/**\n * `TilePatternSpec` → `TextureHandle`. The bridge between the serializable\n * half of a pattern paint and the GL texture that paints it.\n *\n * Memoized on the spec's field values, so identical specs across nodes share\n * one texture and a re-render never re-rasterizes. The memo keeps the\n * `PATTERN_TILE_CACHE_LIMIT` tiles most recently resolved or drawn and\n * unregisters the rest. A handle outliving its tile still draws: its id is\n * the spec, and the texture registry asks this module to rebuild it.\n */\n\nimport type { CommandFill, FillStyle, PosedFill, TilePatternSpec } from '@weasel-js/paint';\nimport {\n  ownTextureIds, registerTextureAs, textureRegistry, unregisterTexture,\n  type TextureHandle,\n} from '../../renderer/textures/registerTexture';\nimport { rasterizeTile } from './rasterizeTile';\nimport { drawTileShapes, tileGeometry, tileSize } from './tileGeometry';\n\n/** How many built-in tiles stay rasterized at once. A scene drawing more\n *  distinct specs than this in one frame rebuilds the overflow every frame. */\nexport const PATTERN_TILE_CACHE_LIMIT = 256;\n\nconst ID_PREFIX = 'pattern:';\n\n/** Texture id → handle, least recently used first. */\nconst cache = new Map<string, TextureHandle | null>();\n\n/** Stable across key order — specs arriving from JSON have no guaranteed\n *  field order, and two orderings must not rasterize two tiles. */\nfunction specId(spec: TilePatternSpec): string {\n  const bag = spec as unknown as Record<string, unknown>;\n  const sorted: Record<string, unknown> = {};\n  for (const k of Object.keys(bag).sort()) sorted[k] = bag[k];\n  return ID_PREFIX + JSON.stringify(sorted);\n}\n\n/** @internal Test helper — do not call from product code. */\nexport function _resetPatternSpecCacheForTests(): void {\n  cache.clear();\n}\n\n/**\n * Build (or fetch) the texture for a spec. Returns `null` when the tile\n * can't be rasterized — no `OffscreenCanvas`, same as `createTilePattern`.\n */\nexport function resolvePatternSpec(spec: TilePatternSpec): TextureHandle | null {\n  const id = specId(spec);\n  const hit = cache.get(id);\n  if (hit !== undefined) {\n    markUsed(id);\n    return hit;\n  }\n  return build(id, spec);\n}\n\nfunction markUsed(id: string): void {\n  const hit = cache.get(id);\n  if (hit === undefined) return;\n  cache.delete(id);\n  cache.set(id, hit);\n}\n\nfunction build(id: string, spec: TilePatternSpec): TextureHandle | null {\n  const bitmap = TILES.has(spec.tile)\n    ? rasterizeTile({\n      size: tileSize(spec),\n      draw: (oc) => drawTileShapes(oc, tileGeometry(spec)),\n    })\n    : null;\n  const handle = bitmap ? registerTextureAs(id, bitmap) : null;\n  cache.delete(id);\n  cache.set(id, handle);\n  while (cache.size > PATTERN_TILE_CACHE_LIMIT) evict(cache.keys().next().value!);\n  return handle;\n}\n\nconst TILES: ReadonlySet<string> = new Set<TilePatternSpec['tile']>([\n  'hatch', 'crosshatch', 'dots', 'chunks',\n]);\n\nfunction evict(id: string): void {\n  cache.delete(id);\n  const source = textureRegistry.get(id)?.source;\n  unregisterTexture({ id });\n  if (source && 'close' in source) source.close();\n}\n\nfunction revive(id: string): void {\n  let spec: unknown;\n  try {\n    spec = JSON.parse(id.slice(ID_PREFIX.length));\n  } catch {\n    return;\n  }\n  if (typeof spec !== 'object' || spec === null || !('tile' in spec)) return;\n  build(id, spec as TilePatternSpec);\n}\n\nownTextureIds(ID_PREFIX, { revive, touched: markUsed });\n\n/** Whether a pattern payload is a spec rather than an already-built handle. */\nexport function isPatternSpec(\n  payload: TextureHandle | TilePatternSpec,\n): payload is TilePatternSpec {\n  return 'tile' in payload;\n}\n\n/**\n * Swap a pattern paint's spec payload for the texture that paints it,\n * leaving every other fill untouched. The built-in painters run this\n * alongside `fillInPoseFrame`; a consumer emitting its own draw commands\n * runs it at the same place it runs that one.\n *\n * A spec that can't rasterize drops the fill rather than painting garbage.\n */\nexport function resolveFillPattern(fill: PosedFill): CommandFill | null;\nexport function resolveFillPattern(fill: FillStyle): FillStyle | null;\nexport function resolveFillPattern(fill: FillStyle): FillStyle | null {\n  if (fill.fill !== 'pattern') return fill;\n  if (!isPatternSpec(fill.pattern)) return fill;\n  const handle = resolvePatternSpec(fill.pattern);\n  return handle ? { ...fill, pattern: handle } : null;\n}\n"],"mappings":";;;;AAqBA,IAAaA,IAA2B,KAElCC,IAAY,YAGZC,oBAAQ,IAAI,IAAkC;AAIpD,SAASC,EAAO,GAA+B;CAC7C,IAAMC,IAAMC,GACNC,IAAkC,CAAC;CACzC,KAAK,IAAMC,KAAK,OAAO,KAAKH,CAAG,CAAC,CAAC,KAAK,GAAG,EAAOG,KAAKH,EAAIG;CACzD,OAAON,IAAY,KAAK,UAAUK,CAAM;AAC1C;AAWA,SAAgBE,EAAmB,GAA6C;CAC9E,IAAMC,IAAKN,EAAOE,CAAI,GAChBK,IAAMR,EAAM,IAAIO,CAAE;CAKxB,OAJIC,MAAQ,KAAA,IAILC,EAAMF,GAAIJ,CAAI,KAHnBO,EAASH,CAAE,GACJC;AAGX;AAEA,SAASE,EAAS,GAAkB;CAClC,IAAMF,IAAMR,EAAM,IAAIO,CAAE;CACxB,AAAIC,MAAQ,KAAA,MACZR,EAAM,OAAOO,CAAE,GACfP,EAAM,IAAIO,GAAIC,CAAG;AACnB;AAEA,SAASC,EAAM,GAAY,GAA6C;CACtE,IAAME,IAASC,EAAM,IAAIT,EAAK,IAAI,IAC9BU,EAAc;EACd,MAAMC,EAASX,CAAI;EACnB,OAAO,MAAOY,EAAeC,GAAIC,EAAad,CAAI,CAAC;CACrD,CAAC,IACC,MACEe,IAASP,IAASQ,EAAkBZ,GAAII,CAAM,IAAI;CAGxD,KAFAX,EAAM,OAAOO,CAAE,GACfP,EAAM,IAAIO,GAAIW,CAAM,GACblB,EAAM,OAAOF,IAA0B,EAAME,EAAM,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,KAAM;CAC9E,OAAOkB;AACT;AAEA,IAAMN,oBAA6B,IAAI,IAA6B;CAClE;CAAS;CAAc;CAAQ;AACjC,CAAC;AAED,SAASQ,EAAM,GAAkB;CAC/B,EAAM,OAAOb,CAAE;CACf,IAAMc,IAASC,EAAgB,IAAIf,CAAE,CAAC,EAAE;CAExC,AADAgB,EAAkB,EAAE,MAAG,CAAC,GACpBF,KAAU,WAAWA,KAAQA,EAAO,MAAM;AAChD;AAEA,SAASG,EAAO,GAAkB;CAChC,IAAIrB;CACJ,IAAI;EACF,IAAO,KAAK,MAAMI,EAAG,MAAM,CAAgB,CAAC;CAC9C,QAAQ;EACN;CACF;CACA,AAAI,OAAOJ,KAAS,YAAYA,KAAmB,UAAUA,KAC7DM,EAAMF,GAAIJ,CAAuB;AACnC;AAEAsB,EAAc1B,GAAW;CAAE;CAAQ,SAASW;AAAS,CAAC;AAGtD,SAAgBgB,EACd,GAC4B;CAC5B,OAAO,UAAUC;AACnB;AAYA,SAAgBC,EAAmB,GAAmC;CAEpE,IADIC,EAAK,SAAS,aACd,CAACH,EAAcG,EAAK,OAAO,GAAG,OAAOA;CACzC,IAAMX,IAASZ,EAAmBuB,EAAK,OAAO;CAC9C,OAAOX,IAAS;EAAE,GAAGW;EAAM,SAASX;CAAO,IAAI;AACjD"}

package/dist/features/patterns/tileGeometry.js

@@ -1,158 +0,0 @@
-//#region src/features/patterns/tileGeometry.ts
-function e(e) {
-	if (e.size !== void 0) return e.size;
-	switch (e.tile) {
-		case "hatch": return 5;
-		case "crosshatch": return 6;
-		case "dots": return 6;
-		case "chunks": return 48;
-		default: return 8;
-	}
-}
-function t(e) {
-	let t = e | 0;
-	return () => {
-		t = t + 1831565813 | 0;
-		let e = Math.imul(t ^ t >>> 15, 1 | t);
-		return e = e + Math.imul(e ^ e >>> 7, 61 | e) ^ e, ((e ^ e >>> 14) >>> 0) / 4294967296;
-	};
-}
-function n(n) {
-	let a = e(n), { color: o } = n;
-	switch (n.tile) {
-		case "hatch": return {
-			size: a,
-			shapes: r(a, n.lineWidth ?? 1, o)
-		};
-		case "crosshatch": {
-			let e = n.lineWidth ?? .8;
-			return {
-				size: a,
-				shapes: [...r(a, e, o), ...i(a, e, o)]
-			};
-		}
-		case "dots": {
-			let e = n.radius ?? 1;
-			return {
-				size: a,
-				shapes: [{
-					kind: "circle",
-					cx: a / 2,
-					cy: a / 2,
-					r: e,
-					color: o
-				}]
-			};
-		}
-		case "chunks": {
-			let e = n.density ?? .35, r = n.chunkSize ?? 3, i = t(n.seed ?? 42), s = Math.round(a * a * e / (r * r)), c = [];
-			n.bg !== void 0 && c.push({
-				kind: "rect",
-				x: 0,
-				y: 0,
-				width: a,
-				height: a,
-				color: n.bg
-			});
-			for (let e = 0; e < s; e++) {
-				let e = i() * a, t = i() * a, n = r * (.5 + i()), s = r * (.5 + i()), l = i() * Math.PI;
-				c.push({
-					kind: "ellipse",
-					cx: e,
-					cy: t,
-					rx: n / 2,
-					ry: s / 2,
-					rotation: l,
-					color: o
-				});
-			}
-			return {
-				size: a,
-				shapes: c
-			};
-		}
-		default: return {
-			size: a,
-			shapes: []
-		};
-	}
-}
-function r(e, t, n) {
-	return [
-		{
-			kind: "line",
-			x1: -1,
-			y1: e + 1,
-			x2: e + 1,
-			y2: -1,
-			width: t,
-			color: n
-		},
-		{
-			kind: "line",
-			x1: -1,
-			y1: 1,
-			x2: 1,
-			y2: -1,
-			width: t,
-			color: n
-		},
-		{
-			kind: "line",
-			x1: e - 1,
-			y1: e + 1,
-			x2: e + 1,
-			y2: e - 1,
-			width: t,
-			color: n
-		}
-	];
-}
-function i(e, t, n) {
-	return [
-		{
-			kind: "line",
-			x1: -1,
-			y1: -1,
-			x2: e + 1,
-			y2: e + 1,
-			width: t,
-			color: n
-		},
-		{
-			kind: "line",
-			x1: e - 1,
-			y1: -1,
-			x2: e + 1,
-			y2: 1,
-			width: t,
-			color: n
-		},
-		{
-			kind: "line",
-			x1: -1,
-			y1: e - 1,
-			x2: 1,
-			y2: e + 1,
-			width: t,
-			color: n
-		}
-	];
-}
-function a(e, t) {
-	for (let n of t.shapes) {
-		if (n.kind === "line") {
-			e.strokeStyle = n.color, e.lineWidth = n.width, e.beginPath(), e.moveTo(n.x1, n.y1), e.lineTo(n.x2, n.y2), e.stroke();
-			continue;
-		}
-		if (e.fillStyle = n.color, n.kind === "rect") {
-			e.fillRect(n.x, n.y, n.width, n.height);
-			continue;
-		}
-		e.beginPath(), n.kind === "circle" ? e.arc(n.cx, n.cy, n.r, 0, Math.PI * 2) : e.ellipse(n.cx, n.cy, n.rx, n.ry, n.rotation, 0, Math.PI * 2), e.fill();
-	}
-}
-//#endregion
-export { a as drawTileShapes, n as tileGeometry, e as tileSize };
-
-//# sourceMappingURL=tileGeometry.js.map

package/dist/features/patterns/tileGeometry.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tileGeometry.js","names":["tileSize","spec","mulberry32","s","seed","t","tileGeometry","forwardDiagonals","color","width","backwardDiagonals","r","density","chunkSize","rand","count","shapes","i","cx","cy","w","h","rotation","drawTileShapes","shape","geometry","oc"],"sources":["../../../src/features/patterns/tileGeometry.ts"],"sourcesContent":["/**\n * The shapes a built-in tile is made of, as data.\n *\n * One description, two renderers: `patterns-builtin` strokes/fills these to\n * an `OffscreenCanvas` to build the GL texture, and `@weasel-js/svg` maps\n * them to `<pattern>` children. Duplicating the tile drawing in the\n * serializer would let the raster and vector forms drift apart silently.\n */\n\nimport type { TilePatternSpec } from '@weasel-js/paint';\n\n/** One primitive within a pattern tile, in tile-local coordinates. */\nexport type TileShape =\n  | { kind: 'line'; x1: number; y1: number; x2: number; y2: number; width: number; color: string }\n  | { kind: 'circle'; cx: number; cy: number; r: number; color: string }\n  | { kind: 'ellipse'; cx: number; cy: number; rx: number; ry: number; rotation: number; color: string }\n  | { kind: 'rect'; x: number; y: number; width: number; height: number; color: string };\n\n/** A built-in tile's shapes plus the edge length they're drawn within. */\nexport interface TileGeometry {\n  size: number;\n  shapes: TileShape[];\n}\n\n/** Defaults per tile kind, matching each factory's signature. */\nexport function tileSize(spec: TilePatternSpec): number {\n  if (spec.size !== undefined) return spec.size;\n  switch (spec.tile) {\n    case 'hatch': return 5;\n    case 'crosshatch': return 6;\n    case 'dots': return 6;\n    case 'chunks': return 48;\n    default: return 8;\n  }\n}\n\n/** Seeded PRNG (mulberry32) — `chunks` places its scatter with this, so the\n *  same `seed` yields the same tile in both the raster and vector paths. */\nfunction mulberry32(seed: number): () => number {\n  let s = seed | 0;\n  return () => {\n    s = (s + 0x6D2B79F5) | 0;\n    let t = Math.imul(s ^ (s >>> 15), 1 | s);\n    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;\n    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;\n  };\n}\n\n/** Resolve a pattern spec to the shapes that make up one tile. Consumers that\n *  want to draw a pattern swatch themselves — a picker, an SVG export — read\n *  this rather than rasterizing a texture. */\nexport function tileGeometry(spec: TilePatternSpec): TileGeometry {\n  const s = tileSize(spec);\n  const { color } = spec;\n\n  switch (spec.tile) {\n    case 'hatch': {\n      const width = spec.lineWidth ?? 1;\n      return { size: s, shapes: forwardDiagonals(s, width, color) };\n    }\n    case 'crosshatch': {\n      const width = spec.lineWidth ?? 0.8;\n      return {\n        size: s,\n        shapes: [...forwardDiagonals(s, width, color), ...backwardDiagonals(s, width, color)],\n      };\n    }\n    case 'dots': {\n      const r = spec.radius ?? 1;\n      return { size: s, shapes: [{ kind: 'circle', cx: s / 2, cy: s / 2, r, color }] };\n    }\n    case 'chunks': {\n      const density = spec.density ?? 0.35;\n      const chunkSize = spec.chunkSize ?? 3;\n      const rand = mulberry32(spec.seed ?? 42);\n      const count = Math.round((s * s * density) / (chunkSize * chunkSize));\n      const shapes: TileShape[] = [];\n      if (spec.bg !== undefined) {\n        shapes.push({ kind: 'rect', x: 0, y: 0, width: s, height: s, color: spec.bg });\n      }\n      for (let i = 0; i < count; i++) {\n        const cx = rand() * s;\n        const cy = rand() * s;\n        const w = chunkSize * (0.5 + rand());\n        const h = chunkSize * (0.5 + rand());\n        const rotation = rand() * Math.PI;\n        shapes.push({ kind: 'ellipse', cx, cy, rx: w / 2, ry: h / 2, rotation, color });\n      }\n      return { size: s, shapes };\n    }\n    default:\n      return { size: s, shapes: [] };\n  }\n}\n\n/** The forward (`/`) diagonal, plus the two corner stubs that make it tile\n *  seamlessly across the edges. */\nfunction forwardDiagonals(s: number, width: number, color: string): TileShape[] {\n  return [\n    { kind: 'line', x1: -1, y1: s + 1, x2: s + 1, y2: -1, width, color },\n    { kind: 'line', x1: -1, y1: 1, x2: 1, y2: -1, width, color },\n    { kind: 'line', x1: s - 1, y1: s + 1, x2: s + 1, y2: s - 1, width, color },\n  ];\n}\n\n/** The backward (`\\`) diagonal and its two stubs. */\nfunction backwardDiagonals(s: number, width: number, color: string): TileShape[] {\n  return [\n    { kind: 'line', x1: -1, y1: -1, x2: s + 1, y2: s + 1, width, color },\n    { kind: 'line', x1: s - 1, y1: -1, x2: s + 1, y2: 1, width, color },\n    { kind: 'line', x1: -1, y1: s - 1, x2: 1, y2: s + 1, width, color },\n  ];\n}\n\n/** Draw a tile's shapes to a 2D context — the raster half of the pair. */\nexport function drawTileShapes(oc: CanvasRenderingContext2D, geometry: TileGeometry): void {\n  for (const shape of geometry.shapes) {\n    if (shape.kind === 'line') {\n      oc.strokeStyle = shape.color;\n      oc.lineWidth = shape.width;\n      oc.beginPath();\n      oc.moveTo(shape.x1, shape.y1);\n      oc.lineTo(shape.x2, shape.y2);\n      oc.stroke();\n      continue;\n    }\n    oc.fillStyle = shape.color;\n    if (shape.kind === 'rect') {\n      oc.fillRect(shape.x, shape.y, shape.width, shape.height);\n      continue;\n    }\n    oc.beginPath();\n    if (shape.kind === 'circle') {\n      oc.arc(shape.cx, shape.cy, shape.r, 0, Math.PI * 2);\n    } else {\n      oc.ellipse(shape.cx, shape.cy, shape.rx, shape.ry, shape.rotation, 0, Math.PI * 2);\n    }\n    oc.fill();\n  }\n}\n"],"mappings":"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"}

package/dist/features/pointer/PointerContext.js

@@ -1,45 +0,0 @@
-import { createContext as e, useContext as t, useState as n, useSyncExternalStore as r } from "react";
-import { jsx as i } from "react/jsx-runtime";
-//#region src/features/pointer/PointerContext.tsx
-function a(e, t) {
-	return e === null || t === null ? e === t : e.worldX === t.worldX && e.worldY === t.worldY && e.viewId === t.viewId;
-}
-function o() {
-	let e = null, t = 0, n = /* @__PURE__ */ new Set(), r = () => e;
-	return {
-		get: r,
-		set(r) {
-			if (!a(e, r)) {
-				e = r, t++;
-				for (let e of [...n]) e();
-			}
-		},
-		subscribe(e) {
-			return n.add(e), () => {
-				n.delete(e);
-			};
-		},
-		getVersion: () => t,
-		getDropPoint: r
-	};
-}
-var s = e(null);
-function c({ children: e, store: t }) {
-	let [r] = n(o);
-	return /* @__PURE__ */ i(s.Provider, {
-		value: t ?? r,
-		children: e
-	});
-}
-function l() {
-	return t(s);
-}
-var u = () => () => {}, d = () => null;
-function f() {
-	let e = l();
-	return r(e ? e.subscribe : u, e ? e.get : d, e ? e.get : d);
-}
-//#endregion
-export { c as PointerContextProvider, o as createPointerStore, l as usePointerContext, f as usePointerPosition };
-
-//# sourceMappingURL=PointerContext.js.map

package/dist/features/pointer/PointerContext.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"PointerContext.js","names":["samePos","a","b","createPointerStore","current","version","listeners","get","next","fn","PointerContext","createContext","PointerContextProvider","own","useState","store","usePointerContext","useContext","noSubscribe","noPointer","usePointerPosition","useSyncExternalStore"],"sources":["../../../src/features/pointer/PointerContext.tsx"],"sourcesContent":["/**\n * @experimental\n * PointerContext — the world-space position of the canvas pointer, and the\n * view it is over, refreshed on every `pointermove` and cleared on\n * `pointerleave`.\n *\n * It is an external store rather than React state: cursor moves fire dozens of\n * times per second, and a consumer that only reads on demand (paste at the\n * pointer) must not re-render for each one. Readers that do need to follow it\n * — a linked cursor — subscribe, or use `usePointerPosition()`.\n *\n * `<SceneCanvas>` publishes automatically, and defers to a provider already in\n * scope, so several surfaces under one provider share one pointer: a detached\n * minimap and its main canvas each see where the other's pointer is.\n */\nimport {\n  createContext, useContext, useState, useSyncExternalStore, type ReactNode,\n} from 'react';\n\n/** @experimental World-space pointer position and the view it is over — a\n *  view id, or `null` for a surface's own camera. `null` as a whole when the\n *  pointer is over no publishing surface. */\nexport type PointerWorldPos = { worldX: number; worldY: number; viewId: string | null } | null;\n\n/** @experimental */\nexport interface PointerContextValue {\n  /** The latest position. */\n  get(): PointerWorldPos;\n  /** Publish a position. Subscribers hear only a changed value. */\n  set(next: PointerWorldPos): void;\n  /** Called after every change; returns the unsubscribe. */\n  subscribe(fn: () => void): () => void;\n  /** Bumps on every change. */\n  getVersion(): number;\n  /** `get()` as a stable thunk, for hooks taking a drop-point option. */\n  readonly getDropPoint: () => PointerWorldPos;\n}\n\nfunction samePos(a: PointerWorldPos, b: PointerWorldPos): boolean {\n  if (a === null || b === null) return a === b;\n  return a.worldX === b.worldX && a.worldY === b.worldY && a.viewId === b.viewId;\n}\n\n/** @experimental A pointer store with no provider around it. */\nexport function createPointerStore(): PointerContextValue {\n  let current: PointerWorldPos = null;\n  let version = 0;\n  const listeners = new Set<() => void>();\n  const get = (): PointerWorldPos => current;\n  return {\n    get,\n    set(next) {\n      if (samePos(current, next)) return;\n      current = next;\n      version++;\n      for (const fn of [...listeners]) fn();\n    },\n    subscribe(fn) {\n      listeners.add(fn);\n      return () => { listeners.delete(fn); };\n    },\n    getVersion: () => version,\n    getDropPoint: get,\n  };\n}\n\nconst PointerContext = createContext<PointerContextValue | null>(null);\n\n/**\n * @experimental\n * Wrap the part of the React tree that should share one pointer. Usually at\n * the app root, alongside `<ActionsProvider>` and `<SelectionContextProvider>`.\n *\n * Most consumers don't need to mount this directly — `<SceneCanvas>` mounts\n * one when none is in scope. Mount it yourself when two surfaces should share\n * a pointer. Pass `store` to publish into one you hold elsewhere\n * (`createPointerStore()`).\n */\nexport function PointerContextProvider(\n  { children, store }: { children: ReactNode; store?: PointerContextValue },\n): ReactNode {\n  const [own] = useState(createPointerStore);\n  return <PointerContext.Provider value={store ?? own}>{children}</PointerContext.Provider>;\n}\n\n/** @experimental The surrounding pointer store, or `null` when no provider is\n *  in scope. */\nexport function usePointerContext(): PointerContextValue | null {\n  return useContext(PointerContext);\n}\n\nconst noSubscribe = (): (() => void) => () => {};\nconst noPointer = (): PointerWorldPos => null;\n\n/** @experimental The pointer, re-rendering the caller whenever it changes.\n *  `null` outside a provider. */\nexport function usePointerPosition(): PointerWorldPos {\n  const store = usePointerContext();\n  return useSyncExternalStore(\n    store ? store.subscribe : noSubscribe,\n    store ? store.get : noPointer,\n    store ? store.get : noPointer,\n  );\n}\n"],"mappings":";;;AAsCA,SAASA,EAAQ,GAAoB,GAA6B;CAEhE,OADIC,MAAM,QAAQC,MAAM,OAAaD,MAAMC,IACpCD,EAAE,WAAWC,EAAE,UAAUD,EAAE,WAAWC,EAAE,UAAUD,EAAE,WAAWC,EAAE;AAC1E;AAGA,SAAgBC,IAA0C;CACxD,IAAIC,IAA2B,MAC3BC,IAAU,GACRC,oBAAY,IAAI,IAAgB,GAChCC,UAA6BH;CACnC,OAAO;EACL;EACA,IAAI,GAAM;GACR,IAAI,GAAQA,GAASI,CAAI,GAEzB;IADA,IAAUA,GACV;IACA,KAAK,IAAMC,KAAM,CAAC,GAAGH,CAAS,GAAG,EAAG;GADpC;EAEF;EACA,UAAU,GAAI;GAEZ,OADAA,EAAU,IAAIG,CAAE,SACH;IAAE,EAAU,OAAOA,CAAE;GAAG;EACvC;EACA,kBAAkBJ;EAClB,cAAcE;CAChB;AACF;AAEA,IAAMG,IAAiBC,EAA0C,IAAI;AAYrE,SAAgBC,EACd,EAAE,aAAU,YACD;CACX,IAAM,CAACC,KAAOC,EAASX,CAAkB;CACzC,OAAO,kBAACO,EAAe,UAAhB;EAAyB,OAAOK,KAASF;EAAM;CAAkC,CAAA;AAC1F;AAIA,SAAgBG,IAAgD;CAC9D,OAAOC,EAAWP,CAAc;AAClC;AAEA,IAAMQ,gBAAwC,CAAC,GACzCC,UAAmC;AAIzC,SAAgBC,IAAsC;CACpD,IAAML,IAAQC,EAAkB;CAChC,OAAOK,EACLN,IAAQA,EAAM,YAAYG,GAC1BH,IAAQA,EAAM,MAAMI,GACpBJ,IAAQA,EAAM,MAAMI,CACtB;AACF"}

package/dist/features/selection/SelectionContext.js

@@ -1,51 +0,0 @@
-import { createContext as e, useCallback as t, useContext as n, useEffect as r, useMemo as i, useRef as a, useState as o } from "react";
-import { useLatest as s } from "@weasel-js/react";
-import { Fragment as c, jsx as l } from "react/jsx-runtime";
-//#region src/features/selection/SelectionContext.tsx
-var u = e(null);
-function d({ children: e }) {
-	let [n, r] = o({
-		selection: [],
-		kinds: void 0
-	}), s = a(""), c = t((e, t) => {
-		let n = JSON.stringify([e, t]);
-		n !== s.current && (s.current = n, r({
-			selection: e,
-			kinds: t
-		}));
-	}, []), d = i(() => ({
-		selection: n.selection,
-		...n.kinds === void 0 ? {} : { kinds: n.kinds },
-		publishSelection: c
-	}), [n, c]);
-	return /* @__PURE__ */ l(u.Provider, {
-		value: d,
-		children: e
-	});
-}
-function f() {
-	return n(u);
-}
-function p({ children: e }) {
-	return n(u) === null ? /* @__PURE__ */ l(d, { children: e }) : /* @__PURE__ */ l(c, { children: e });
-}
-function m(e, t) {
-	let i = n(u), a = s(e), o = s(t), c = JSON.stringify([e, t]), l = i?.publishSelection;
-	r(() => {
-		l && l(a.current, o.current);
-	}, [
-		l,
-		c,
-		a,
-		o
-	]);
-	let d = s(i), f = s(c);
-	r(() => () => {
-		let e = d.current;
-		e && JSON.stringify([e.selection, e.kinds]) === f.current && e.publishSelection([]);
-	}, [d, f]);
-}
-//#endregion
-export { d as SelectionContextProvider, p as SelectionContextProviderIfRoot, m as usePublishSelection, f as useSelectionContext };
-
-//# sourceMappingURL=SelectionContext.js.map

package/dist/features/selection/SelectionContext.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SelectionContext.js","names":["_Fragment","SelectionContext","createContext","SelectionContextProvider","state","setState","useState","lastSerializedRef","useRef","publishSelection","useCallback","next","ids","kinds","value","useMemo","useSelectionContext","useContext","SelectionContextProviderIfRoot","Fragment","usePublishSelection","ctx","idsRef","useLatest","kindsRef","serialized","publish","ctxRef","serializedRef","slot"],"sources":["../../../src/features/selection/SelectionContext.tsx"],"sourcesContent":["/**\n * @experimental\n * SelectionContext — a tiny ambient context that publishes \"what's currently\n * selected\" so non-canvas UI (command palette, status bar, breadcrumbs,\n * undo-label generation) can read it without threading a selection prop\n * through the tree.\n *\n * **Single-slot semantics (v1):** the context holds one selection array.\n * Whichever canvas (or other publisher) calls `publishSelection` most\n * recently owns the slot. For single-canvas pages — the typical case —\n * this Just Works. Multi-canvas pages get last-writer-wins, which is\n * approximately \"most recently rendered.\" A v2 could become focus-aware\n * (canvas claims the slot on focus, releases on blur), but that's deferred\n * until a real multi-canvas use case lands.\n *\n * `<SceneCanvas>` calls `publishSelection` automatically when wrapped in a\n * `<SelectionContext>`. Bare-`<Canvas>` consumers opt in by calling\n * `useSelectionContext().publishSelection(ids)` themselves.\n */\nimport {\n  createContext,\n  useCallback,\n  useContext,\n  useEffect,\n  useMemo,\n  useRef,\n  useState,\n  type ReactNode,\n} from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { NodeId } from 'core/scene/types';\n\n/** @experimental */\nexport interface SelectionContextValue {\n  /** The most-recently-published selection. Empty array when no canvas\n   *  has published or when the active canvas's selection is empty. */\n  readonly selection: readonly NodeId[];\n  /** Optional per-id kind label, parallel to `selection`. Publishers that\n   *  know their domain populate it (e.g. `'rectangle'`, `'path'`, `'group'`)\n   *  so consumers can render type-aware copy. Sparse entries (`undefined`)\n   *  are allowed; consumers should treat the kinds array as best-effort.\n   *\n   *  See `docs/TODO.md` (Tier 1.5 → \"Typed scene-object references\") for the\n   *  longer-term direction toward a proper id+kind value type. */\n  readonly kinds?: readonly (string | undefined)[];\n  /** Publish the calling canvas's selection. Idempotent — calling with\n   *  the same array (by content equality) does not trigger a re-render\n   *  of the consumer tree. */\n  publishSelection(ids: readonly NodeId[], kinds?: readonly (string | undefined)[]): void;\n}\n\nconst SelectionContext = createContext<SelectionContextValue | null>(null);\n\n/**\n * @experimental\n * Wrap the part of the React tree that should share a selection context.\n * Usually placed at the demo / app root, alongside `<ActionsProvider>`.\n */\nexport function SelectionContextProvider({ children }: { children: ReactNode }): ReactNode {\n  const [state, setState] = useState<{\n    selection: readonly NodeId[];\n    kinds: readonly (string | undefined)[] | undefined;\n  }>({ selection: [], kinds: undefined });\n  const lastSerializedRef = useRef<string>('');\n\n  const publishSelection = useCallback((\n    ids: readonly NodeId[],\n    kinds?: readonly (string | undefined)[],\n  ): void => {\n    // Cheap content equality via JSON serialization over both ids and kinds.\n    // Selection arrays are typically small (≤ a few dozen entries); the cost\n    // is dwarfed by avoiding a re-render when nothing changed.\n    const next = JSON.stringify([ids, kinds]);\n    if (next === lastSerializedRef.current) return;\n    lastSerializedRef.current = next;\n    setState({ selection: ids, kinds });\n  }, []);\n\n  const value = useMemo<SelectionContextValue>(\n    () => ({\n      selection: state.selection,\n      ...(state.kinds !== undefined ? { kinds: state.kinds } : {}),\n      publishSelection,\n    }),\n    [state, publishSelection],\n  );\n\n  return <SelectionContext.Provider value={value}>{children}</SelectionContext.Provider>;\n}\n\n/**\n * @experimental\n * Read the current selection-context value. Returns `null` when no\n * `<SelectionContextProvider>` is in scope; consumers should fall back\n * gracefully (e.g. command palette hides the \"N selected\" header).\n */\nexport function useSelectionContext(): SelectionContextValue | null {\n  return useContext(SelectionContext);\n}\n\n/**\n * @experimental\n * Conditional `<SelectionContextProvider>` wrapper. Mounts a provider only\n * when no parent provider is in scope — otherwise renders children unwrapped\n * so callers (e.g. `<WeaselProvider>`) defer to the host's existing scope.\n * Mirrors `ActionsProviderIfRoot` / `DepRegistryProviderIfRoot`.\n */\nexport function SelectionContextProviderIfRoot({\n  children,\n}: {\n  children: ReactNode;\n}): ReactNode {\n  const parent = useContext(SelectionContext);\n  if (parent !== null) return <>{children}</>;\n  return <SelectionContextProvider>{children}</SelectionContextProvider>;\n}\n\n/**\n * @experimental\n * Convenience hook for canvas components: publishes the supplied `ids`\n * into the surrounding `<SelectionContextProvider>` whenever the\n * content of `ids` changes. No-op when there's no provider in scope.\n *\n * Used by `<SceneCanvas>` internally to auto-publish; bare-Canvas\n * consumers call `useSelectionContext()` and `publishSelection` directly.\n */\nexport function usePublishSelection(\n  ids: readonly NodeId[],\n  kinds?: readonly (string | undefined)[],\n): void {\n  const ctx = useContext(SelectionContext);\n  // Track latest values via refs so the effect's deps array can use a stable\n  // serialization — avoids re-firing on identity-only changes.\n  const idsRef = useLatest(ids);\n  const kindsRef = useLatest(kinds);\n  const serialized = JSON.stringify([ids, kinds]);\n  // Depend on `publishSelection` rather than `ctx`: the provider mints a new\n  // context value on every publish, so keying on `ctx` refires this effect for\n  // every publisher whenever any one of them publishes.\n  const publish = ctx?.publishSelection;\n  useEffect(() => {\n    if (!publish) return;\n    publish(idsRef.current, kindsRef.current);\n  }, [publish, serialized, idsRef, kindsRef]);\n  // A publisher that goes away takes its selection with it, unless another\n  // has written the slot since.\n  const ctxRef = useLatest(ctx);\n  const serializedRef = useLatest(serialized);\n  useEffect(() => () => {\n    const slot = ctxRef.current;\n    if (slot && JSON.stringify([slot.selection, slot.kinds]) === serializedRef.current) {\n      slot.publishSelection([]);\n    }\n  }, [ctxRef, serializedRef]);\n}\n"],"mappings":";;;;AAmDA,IAAMC,IAAmBC,EAA4C,IAAI;AAOzE,SAAgBC,EAAyB,EAAE,eAAgD;CACzF,IAAM,CAACC,GAAOC,KAAYC,EAGvB;EAAE,WAAW,CAAC;EAAG,OAAO,KAAA;CAAU,CAAC,GAChCC,IAAoBC,EAAe,EAAE,GAErCC,IAAmBC,GACvB,GACA,MACS;EAIT,IAAMC,IAAO,KAAK,UAAU,CAACC,GAAKC,CAAK,CAAC;EACxC,AAAIF,MAASJ,EAAkB,YAC/B,EAAkB,UAAUI,GAC5BN,EAAS;GAAE,WAAWO;GAAK;EAAM,CAAC;CACpC,GAAG,CAAC,CAAC,GAECE,IAAQC,SACL;EACL,WAAWX,EAAM;EACjB,GAAIA,EAAM,UAAU,KAAA,IAAqC,CAAC,IAA1B,EAAE,OAAOA,EAAM,MAAM;EACrD;CACF,IACA,CAACA,GAAOK,CAAgB,CAC1B;CAEA,OAAO,kBAACR,EAAiB,UAAlB;EAAkC;EAAQ;CAAoC,CAAA;AACvF;AAQA,SAAgBe,IAAoD;CAClE,OAAOC,EAAWhB,CAAgB;AACpC;AASA,SAAgBiB,EAA+B,EAC7C,eAGY;CAGZ,OAFeD,EAAWhB,CACtB,MAAW,OACR,kBAACE,GAAD,EAA2B,YAAmC,CAAA,IADzC,kBAAAH,GAAA,EAAG,YAAW,CAAA;AAE5C;AAWA,SAAgBoB,EACd,GACA,GACM;CACN,IAAMC,IAAMJ,EAAWhB,CAAgB,GAGjCqB,IAASC,EAAUX,CAAG,GACtBY,IAAWD,EAAUV,CAAK,GAC1BY,IAAa,KAAK,UAAU,CAACb,GAAKC,CAAK,CAAC,GAIxCa,IAAUL,GAAK;CACrB,QAAgB;EACd,AAAKK,KACLA,EAAQJ,EAAO,SAASE,EAAS,OAAO;CAC1C,GAAG;EAACE;EAASD;EAAYH;EAAQE;CAAQ,CAAC;CAG1C,IAAMG,IAASJ,EAAUF,CAAG,GACtBO,IAAgBL,EAAUE,CAAU;CAC1C,cAAsB;EACpB,IAAMI,IAAOF,EAAO;EACpB,AAAIE,KAAQ,KAAK,UAAU,CAACA,EAAK,WAAWA,EAAK,KAAK,CAAC,MAAMD,EAAc,WACzEC,EAAK,iBAAiB,CAAC,CAAC;CAE5B,GAAG,CAACF,GAAQC,CAAa,CAAC;AAC5B"}

package/dist/features/simulation/createSimulation.js

@@ -1,61 +0,0 @@
-import { DEFAULT_ALPHA_DECAY as e, DEFAULT_ALPHA_MIN as t, DEFAULT_VELOCITY_DECAY as n } from "./types.js";
-//#region src/features/simulation/createSimulation.ts
-function r(r) {
-	let i = r.nodes, a = r.forces ?? [], o = r.alpha ?? 1, s = r.alphaMin ?? t, c = r.alphaDecay ?? e, l = r.alphaTarget ?? 0, u = r.velocityDecay ?? n, d = r.random ?? Math.random;
-	function f(e) {
-		e.forEach((e, t) => {
-			e.index = t, e.vx ??= 0, e.vy ??= 0;
-		});
-	}
-	f(i);
-	for (let e of a) e.initialize?.(i, d);
-	function p() {
-		o += (l - o) * c;
-		for (let e of a) e(o);
-		let e = 1 - u;
-		for (let t of i) t.fx == null ? (t.vx = (t.vx ?? 0) * e, Number.isFinite(t.vx) || (t.vx = 0), t.x += t.vx, Number.isFinite(t.x) || (t.x = 0)) : (t.x = t.fx, t.vx = 0), t.fy == null ? (t.vy = (t.vy ?? 0) * e, Number.isFinite(t.vy) || (t.vy = 0), t.y += t.vy, Number.isFinite(t.y) || (t.y = 0)) : (t.y = t.fy, t.vy = 0);
-	}
-	let m = {
-		get nodes() {
-			return i;
-		},
-		setNodes(e) {
-			i = e, f(i);
-			for (let e of a) e.initialize?.(i, d);
-			return m;
-		},
-		setForces(e) {
-			let t = a;
-			a = e;
-			for (let n of e) t.includes(n) || n.initialize?.(i, d);
-			return m;
-		},
-		alpha(e) {
-			return e === void 0 ? o : (o = e, m);
-		},
-		alphaTarget(e) {
-			return e === void 0 ? l : (l = e, m);
-		},
-		alphaDecay(e) {
-			return e === void 0 ? c : (c = e, m);
-		},
-		alphaMin(e) {
-			return e === void 0 ? s : (s = e, m);
-		},
-		velocityDecay(e) {
-			return e === void 0 ? u : (u = e, m);
-		},
-		tick(e = 1) {
-			for (let t = 0; t < e; t++) p();
-			return m;
-		},
-		isSettled() {
-			return o < s && l === 0;
-		}
-	};
-	return m;
-}
-//#endregion
-export { r as createSimulation };
-
-//# sourceMappingURL=createSimulation.js.map

package/dist/features/simulation/createSimulation.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createSimulation.js","names":["createSimulation","nodes","opts","forces","alpha","alphaMin","DEFAULT_ALPHA_MIN","alphaDecay","DEFAULT_ALPHA_DECAY","alphaTarget","velocityDecay","DEFAULT_VELOCITY_DECAY","random","prime","i","n","f","step","friction","core","next","old","value","iterations"],"sources":["../../../src/features/simulation/createSimulation.ts"],"sourcesContent":["/**\n * The integrator, with no clock attached.\n *\n * Velocity-Verlet over a pluggable force list, contract-compatible with\n * d3-force so d3's own bundled forces drop in untranslated. Nothing here\n * advances time: `tick()` is the only thing that moves a node, and the caller\n * decides how often to call it. `useSimulation` calls it once a frame; a\n * layout pass calls it a few hundred times in one go and reads the result.\n *\n * Splitting it out is what lets a *pure* function run a relaxation — a React\n * hook cannot, and the alternative was a second integrator drifting away from\n * this one.\n */\nimport {\n  DEFAULT_ALPHA_DECAY,\n  DEFAULT_ALPHA_MIN,\n  DEFAULT_VELOCITY_DECAY,\n  type SimulationCore,\n  type SimulationForce,\n  type SimulationNode,\n  type SimulationOptions,\n} from './types';\n\n/**\n * A d3-force-compatible simulation with no clock: nothing moves until `tick()`.\n * Nodes are mutated in place, and primed with `index`, `vx` and `vy` on creation.\n */\nexport function createSimulation<TNode extends SimulationNode>(\n  opts: SimulationOptions<TNode>,\n): SimulationCore<TNode> {\n  let nodes = opts.nodes;\n  let forces = opts.forces ?? [];\n  let alpha = opts.alpha ?? 1;\n  let alphaMin = opts.alphaMin ?? DEFAULT_ALPHA_MIN;\n  let alphaDecay = opts.alphaDecay ?? DEFAULT_ALPHA_DECAY;\n  let alphaTarget = opts.alphaTarget ?? 0;\n  let velocityDecay = opts.velocityDecay ?? DEFAULT_VELOCITY_DECAY;\n  const random = opts.random ?? Math.random;\n\n  /** `index` is what `forceLink` and friends address nodes by, and a d3 force\n   *  does `n.vx += …` without checking, so both must exist before the first\n   *  tick or the first tick produces NaN. */\n  function prime(list: TNode[]): void {\n    list.forEach((n, i) => {\n      n.index = i;\n      if (n.vx == null) n.vx = 0;\n      if (n.vy == null) n.vy = 0;\n    });\n  }\n\n  prime(nodes);\n  for (const f of forces) f.initialize?.(nodes, random);\n\n  function step(): void {\n    alpha += (alphaTarget - alpha) * alphaDecay;\n    for (const f of forces) f(alpha);\n\n    const friction = 1 - velocityDecay;\n    for (const n of nodes) {\n      if (n.fx == null) {\n        n.vx = (n.vx ?? 0) * friction;\n        // A non-finite velocity — force overflow, or two nodes exactly\n        // coincident — would reach the renderer as geometry and cost\n        // pathological tessellation work without throwing anywhere.\n        if (!Number.isFinite(n.vx)) n.vx = 0;\n        n.x += n.vx;\n        if (!Number.isFinite(n.x)) n.x = 0;\n      } else {\n        n.x = n.fx;\n        n.vx = 0;\n      }\n      if (n.fy == null) {\n        n.vy = (n.vy ?? 0) * friction;\n        if (!Number.isFinite(n.vy)) n.vy = 0;\n        n.y += n.vy;\n        if (!Number.isFinite(n.y)) n.y = 0;\n      } else {\n        n.y = n.fy;\n        n.vy = 0;\n      }\n    }\n  }\n\n  /* eslint-disable @typescript-eslint/no-explicit-any */\n  const core: any = {\n    get nodes() {\n      return nodes;\n    },\n    setNodes(next: TNode[]) {\n      nodes = next;\n      prime(nodes);\n      for (const f of forces) f.initialize?.(nodes, random);\n      return core;\n    },\n    setForces(next: SimulationForce<TNode>[]) {\n      const old = forces;\n      forces = next;\n      for (const f of next) {\n        if (!old.includes(f)) f.initialize?.(nodes, random);\n      }\n      return core;\n    },\n    alpha(value?: number) {\n      if (value === undefined) return alpha;\n      alpha = value;\n      return core;\n    },\n    alphaTarget(value?: number) {\n      if (value === undefined) return alphaTarget;\n      alphaTarget = value;\n      return core;\n    },\n    alphaDecay(value?: number) {\n      if (value === undefined) return alphaDecay;\n      alphaDecay = value;\n      return core;\n    },\n    alphaMin(value?: number) {\n      if (value === undefined) return alphaMin;\n      alphaMin = value;\n      return core;\n    },\n    velocityDecay(value?: number) {\n      if (value === undefined) return velocityDecay;\n      velocityDecay = value;\n      return core;\n    },\n    tick(iterations: number = 1) {\n      for (let i = 0; i < iterations; i++) step();\n      return core;\n    },\n    isSettled() {\n      return alpha < alphaMin && alphaTarget === 0;\n    },\n  };\n  /* eslint-enable @typescript-eslint/no-explicit-any */\n  return core as SimulationCore<TNode>;\n}\n"],"mappings":";;AA2BA,SAAgBA,EACd,GACuB;CACvB,IAAIC,IAAQC,EAAK,OACbC,IAASD,EAAK,UAAU,CAAC,GACzBE,IAAQF,EAAK,SAAS,GACtBG,IAAWH,EAAK,YAAYI,GAC5BC,IAAaL,EAAK,cAAcM,GAChCC,IAAcP,EAAK,eAAe,GAClCQ,IAAgBR,EAAK,iBAAiBS,GACpCC,IAASV,EAAK,UAAU,KAAK;CAKnC,SAASW,EAAM,GAAqB;EAClC,EAAK,SAAS,GAAG,MAAM;GAGrB,AAFA,EAAE,QAAQC,GACV,AAAkBC,EAAE,OAAK,GACzB,AAAkBA,EAAE,OAAK;EAC3B,CAAC;CACH;CAEA,EAAMd,CAAK;CACX,KAAK,IAAMe,KAAKb,GAAQ,EAAE,aAAaF,GAAOW,CAAM;CAEpD,SAASK,IAAa;EACpB,MAAUR,IAAcL,KAASG;EACjC,KAAK,IAAMS,KAAKb,GAAQ,EAAEC,CAAK;EAE/B,IAAMc,IAAW,IAAIR;EACrB,KAAK,IAAMK,KAAKd,GAad,AAZIc,EAAE,MAAM,QACV,EAAE,MAAMA,EAAE,MAAM,KAAKG,GAIhB,OAAO,SAASH,EAAE,EAAE,MAAG,EAAE,KAAK,IACnC,EAAE,KAAKA,EAAE,IACJ,OAAO,SAASA,EAAE,CAAC,MAAG,EAAE,IAAI,OAEjC,EAAE,IAAIA,EAAE,IACR,EAAE,KAAK,IAELA,EAAE,MAAM,QACV,EAAE,MAAMA,EAAE,MAAM,KAAKG,GAChB,OAAO,SAASH,EAAE,EAAE,MAAG,EAAE,KAAK,IACnC,EAAE,KAAKA,EAAE,IACJ,OAAO,SAASA,EAAE,CAAC,MAAG,EAAE,IAAI,OAEjC,EAAE,IAAIA,EAAE,IACR,EAAE,KAAK;CAGb;CAGA,IAAMI,IAAY;EAChB,IAAI,QAAQ;GACV,OAAOlB;EACT;EACA,SAAS,GAAe;GAEtB,AADA,IAAQmB,GACRP,EAAMZ,CAAK;GACX,KAAK,IAAMe,KAAKb,GAAQ,EAAE,aAAaF,GAAOW,CAAM;GACpD,OAAOO;EACT;EACA,UAAU,GAAgC;GACxC,IAAME,IAAMlB;GACZ,IAASiB;GACT,KAAK,IAAMJ,KAAKI,GACd,AAAKC,EAAI,SAASL,CAAC,KAAGA,EAAE,aAAaf,GAAOW,CAAM;GAEpD,OAAOO;EACT;EACA,MAAM,GAAgB;GAGpB,OAFIG,MAAU,KAAA,IAAkBlB,KAChC,IAAQkB,GACDH;EACT;EACA,YAAY,GAAgB;GAG1B,OAFIG,MAAU,KAAA,IAAkBb,KAChC,IAAca,GACPH;EACT;EACA,WAAW,GAAgB;GAGzB,OAFIG,MAAU,KAAA,IAAkBf,KAChC,IAAae,GACNH;EACT;EACA,SAAS,GAAgB;GAGvB,OAFIG,MAAU,KAAA,IAAkBjB,KAChC,IAAWiB,GACJH;EACT;EACA,cAAc,GAAgB;GAG5B,OAFIG,MAAU,KAAA,IAAkBZ,KAChC,IAAgBY,GACTH;EACT;EACA,KAAK,IAAqB,GAAG;GAC3B,KAAK,IAAIL,IAAI,GAAGA,IAAIS,GAAY,KAAK,EAAK;GAC1C,OAAOJ;EACT;EACA,YAAY;GACV,OAAOf,IAAQC,KAAYI,MAAgB;EAC7C;CACF;CAEA,OAAOU;AACT"}

package/dist/features/simulation/types.js

@@ -1,6 +0,0 @@
-//#region src/features/simulation/types.ts
-var e = 1 - .001 ** (1 / 300), t = .001, n = .4;
-//#endregion
-export { e as DEFAULT_ALPHA_DECAY, t as DEFAULT_ALPHA_MIN, n as DEFAULT_VELOCITY_DECAY };
-
-//# sourceMappingURL=types.js.map

package/dist/features/simulation/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","names":["DEFAULT_ALPHA_DECAY","DEFAULT_ALPHA_MIN","DEFAULT_VELOCITY_DECAY"],"sources":["../../../src/features/simulation/types.ts"],"sourcesContent":["/**\n * Minimal node interface for the simulation primitive. Matches d3-force's\n * node shape exactly so d3-force's bundled forces work without translation.\n *\n * Consumers extend this with arbitrary additional fields (id, label, etc.).\n */\nexport interface SimulationNode {\n  x: number;\n  y: number;\n  vx?: number;\n  vy?: number;\n  /** Pin x to this value when non-null. The integrator skips x/vx for the node. */\n  fx?: number | null;\n  fy?: number | null;\n  /** Array index, written by `initialize`. Some forces (e.g. forceLink) rely on it. */\n  index?: number;\n}\n\n/**\n * Force protocol — contract-compatible with d3-force. A force is a function\n * called once per tick with the current alpha; it mutates `vx`/`vy` on nodes.\n * Optional `initialize` lets the force compute setup (link indices, etc.).\n */\nexport interface SimulationForce<TNode extends SimulationNode = SimulationNode> {\n  (alpha: number): void;\n  initialize?(nodes: TNode[], random?: () => number): void;\n}\n\n/** Options for `useSimulation`: everything {@link SimulationOptions} carries,\n *  plus the loop's own callbacks and clock. */\nexport interface UseSimulationOptions<TNode extends SimulationNode>\n  extends SimulationOptions<TNode> {\n  /** Fired after each integration step. */\n  onTick?: (nodes: TNode[]) => void;\n  /** Fired once when the sim settles (alpha < alphaMin && alphaTarget === 0). */\n  onEnd?: () => void;\n\n  // Test injection (mirrors useAnimator):\n  /** Optional rAF injection. Defaults to window.requestAnimationFrame. */\n  requestFrame?: (cb: (t: number) => void) => number;\n  cancelFrame?: (handle: number) => void;\n}\n\n/**\n * A force simulation over a set of nodes, with no clock of its own.\n *\n * Each tick applies every force and then integrates velocities, scaled by\n * `alpha` — a temperature that decays toward `alphaTarget` so the layout\n * settles instead of jittering forever. Raise `alphaTarget` to reheat it,\n * which is what a drag does.\n *\n * Nodes are mutated in place; the simulation holds the array, not a copy.\n *\n * Nothing here advances time. {@link Simulation} adds the frame loop; a caller\n * that wants the whole relaxation at once — a layout pass, a pre-warm, a test\n * — drives {@link SimulationCore.tick} itself.\n */\nexport interface SimulationCore<TNode extends SimulationNode> {\n  readonly nodes: TNode[];\n\n  setNodes(nodes: TNode[]): this;\n  setForces(forces: SimulationForce<TNode>[]): this;\n\n  alpha(): number;\n  alpha(value: number): this;\n  alphaTarget(): number;\n  alphaTarget(value: number): this;\n  alphaDecay(): number;\n  alphaDecay(value: number): this;\n  alphaMin(): number;\n  alphaMin(value: number): this;\n  velocityDecay(): number;\n  velocityDecay(value: number): this;\n\n  /**\n   * Run the tick body synchronously `iterations` times. Does NOT fire\n   * onTick or onEnd (matches d3-force). Used for offscreen pre-warm and tests.\n   */\n  tick(iterations?: number): this;\n\n  isSettled(): boolean;\n}\n\n/** A {@link SimulationCore} running on a frame loop. */\nexport interface Simulation<TNode extends SimulationNode> extends SimulationCore<TNode> {\n  /** Resume the RAF loop. If alpha < alphaMin, reset alpha to 1. */\n  restart(): this;\n  /** Cancel the RAF loop. Does not change alpha. */\n  stop(): this;\n}\n\n/** What {@link SimulationCore} needs: the nodes, the forces acting on them,\n *  and the cooling schedule. {@link UseSimulationOptions} adds the loop's. */\nexport interface SimulationOptions<TNode extends SimulationNode> {\n  /** Mutable array of nodes. Kit + forces mutate vx/vy/x/y in place. */\n  nodes: TNode[];\n  /** Forces applied per tick. Each may implement `initialize` for setup. */\n  forces?: SimulationForce<TNode>[];\n\n  /** Initial alpha. Default 1. */\n  alpha?: number;\n  /** Settle threshold. When alpha drops below and alphaTarget is 0, onEnd fires. Default 0.001. */\n  alphaMin?: number;\n  /** Per-tick decay rate toward alphaTarget. Default 1 - 0.001^(1/300) ≈ 0.0228. */\n  alphaDecay?: number;\n  /** Target alpha. Set above alphaMin to keep sim warm (e.g. during drag). Default 0. */\n  alphaTarget?: number;\n  /** Friction multiplier on velocity per tick: vx *= (1 - velocityDecay). Default 0.4. */\n  velocityDecay?: number;\n  /** Handed to each force's `initialize`. Default `Math.random`; pass a seeded\n   *  source to make a run reproducible. */\n  random?: () => number;\n}\n\n/** Default alpha decay: such that alpha drops from 1 to alphaMin (0.001) in 300 ticks. */\nexport const DEFAULT_ALPHA_DECAY = 1 - Math.pow(0.001, 1 / 300);\n/** Alpha below which a cooling simulation is considered settled. */\nexport const DEFAULT_ALPHA_MIN = 0.001;\n/** Fraction of velocity shed each tick — friction. Higher settles sooner and\n *  overshoots less. */\nexport const DEFAULT_VELOCITY_DECAY = 0.4;\n"],"mappings":";AAmHA,IAAaA,IAAsB,IAAa,SAAO,IAAI,MAE9CC,IAAoB,MAGpBC,IAAyB"}

package/dist/features/simulation/useSimulation.js

@@ -1,74 +0,0 @@
-import { createSimulation as e } from "./createSimulation.js";
-import { useVisibleRaf as t } from "../../scheduling/useVisibleRaf.js";
-import { useLayoutEffect as n, useMemo as r, useRef as i } from "react";
-import { useLatest as a } from "@weasel-js/react";
-//#region src/features/simulation/useSimulation.ts
-function o(o) {
-	let s = a(o), c = i(null);
-	c.current ??= e(o);
-	let l = c.current, u = i(!1), d = i(!0), f = t(() => {
-		m();
-	}, {
-		requestFrame: o.requestFrame,
-		cancelFrame: o.cancelFrame
-	}), p = () => {
-		f.cancel();
-	}, m = () => {
-		if (d.current) {
-			if (l.tick(), s.current.onTick?.(l.nodes), l.alpha() < l.alphaMin()) {
-				p(), u.current || (u.current = !0, s.current.onEnd?.());
-				return;
-			}
-			f.request();
-		}
-	}, h = () => {
-		d.current && f.request();
-	};
-	return n(() => (d.current = !0, f.request(), () => {
-		d.current = !1, f.cancel();
-	}), [f]), r(() => {
-		let e = {
-			get nodes() {
-				return l.nodes;
-			},
-			setNodes(t) {
-				return l.setNodes(t), e;
-			},
-			setForces(t) {
-				return l.setForces(t), e;
-			},
-			alpha(t) {
-				return t === void 0 ? l.alpha() : (l.alpha(t), t >= l.alphaMin() && (u.current = !1), e);
-			},
-			alphaTarget(t) {
-				return t === void 0 ? l.alphaTarget() : (l.alphaTarget(t), t > 0 && (u.current = !1), e);
-			},
-			alphaDecay(t) {
-				return t === void 0 ? l.alphaDecay() : (l.alphaDecay(t), e);
-			},
-			alphaMin(t) {
-				return t === void 0 ? l.alphaMin() : (l.alphaMin(t), e);
-			},
-			velocityDecay(t) {
-				return t === void 0 ? l.velocityDecay() : (l.velocityDecay(t), e);
-			},
-			restart() {
-				return l.alpha() < l.alphaMin() && l.alpha(1), u.current = !1, h(), e;
-			},
-			stop() {
-				return p(), e;
-			},
-			tick(t = 1) {
-				return l.tick(t), e;
-			},
-			isSettled() {
-				return l.isSettled();
-			}
-		};
-		return e;
-	}, []);
-}
-//#endregion
-export { o as useSimulation };
-
-//# sourceMappingURL=useSimulation.js.map

package/dist/features/simulation/useSimulation.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useSimulation.js","names":["useSimulation","optsRef","useLatest","opts","coreRef","useRef","createSimulation","core","endedRef","mountedRef","frameLoop","useVisibleRaf","stopRaf","rafTick","startRaf","useLayoutEffect","useMemo","h","newNodes","newForces","value","iterations"],"sources":["../../../src/features/simulation/useSimulation.ts"],"sourcesContent":["import { useLayoutEffect, useMemo, useRef } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { useVisibleRaf } from '../../scheduling/useVisibleRaf';\nimport { createSimulation } from './createSimulation';\nimport {\n  type Simulation,\n  type SimulationCore,\n  type SimulationForce,\n  type SimulationNode,\n  type UseSimulationOptions,\n} from './types';\n\n/**\n * Continuous N-body simulation primitive: `createSimulation`'s integrator on a\n * frame loop.\n *\n * The kit is adapter-agnostic — `onTick(nodes)` fires after each integration\n * step and the consumer decides how (and whether) to write through to scene\n * state. Per-tick history bypass and settle-commit semantics are consumer\n * concerns; the kit doesn't have an opinion.\n */\nexport function useSimulation<TNode extends SimulationNode>(\n  opts: UseSimulationOptions<TNode>,\n): Simulation<TNode> {\n  const optsRef = useLatest(opts);\n\n  const coreRef = useRef<SimulationCore<TNode> | null>(null);\n  coreRef.current ??= createSimulation(opts);\n  const core = coreRef.current;\n\n  /** Whether onEnd has fired since the last energization (restart / alpha set / target raise). */\n  const endedRef = useRef(false);\n  const mountedRef = useRef(true);\n\n  // The loop runs behind the visibility gate: a settling simulation stops\n  // integrating on a page nobody is looking at, and picks up where it left off.\n  // Its step is fixed rather than time-based, so there is no clock to rebase.\n  // The gate defaults an absent clock to `requestAnimationFrame`, so an\n  // injected one passes straight through rather than being defaulted twice.\n  const frameLoop = useVisibleRaf(\n    () => { rafTick(); },\n    {\n      requestFrame: opts.requestFrame,\n      cancelFrame: opts.cancelFrame,\n    },\n  );\n\n  const stopRaf = (): void => { frameLoop.cancel(); };\n\n  const rafTick = (): void => {\n    if (!mountedRef.current) return;\n\n    core.tick();\n    optsRef.current.onTick?.(core.nodes);\n\n    if (core.alpha() < core.alphaMin()) {\n      stopRaf();\n      if (!endedRef.current) {\n        endedRef.current = true;\n        optsRef.current.onEnd?.();\n      }\n      return;\n    }\n\n    frameLoop.request();\n  };\n\n  const startRaf = (): void => {\n    if (!mountedRef.current) return;\n    frameLoop.request();\n  };\n\n  // Starts on every mount, StrictMode's simulated remount included, and in a\n  // layout effect so a host's own layout effects can already `stop()` it.\n  // `createSimulation` has already primed the nodes.\n  useLayoutEffect(() => {\n    mountedRef.current = true;\n    frameLoop.request();\n    return () => {\n      mountedRef.current = false;\n      frameLoop.cancel();\n    };\n  }, [frameLoop]);\n\n  // Stable handle. All methods read through the core, so a fixed identity is safe.\n  const handle = useMemo<Simulation<TNode>>(() => {\n    /* eslint-disable @typescript-eslint/no-explicit-any */\n    const h: any = {\n      get nodes() {\n        return core.nodes;\n      },\n      setNodes(newNodes: TNode[]) {\n        core.setNodes(newNodes);\n        return h;\n      },\n      setForces(newForces: SimulationForce<TNode>[]) {\n        core.setForces(newForces);\n        return h;\n      },\n      alpha(value?: number) {\n        if (value === undefined) return core.alpha();\n        core.alpha(value);\n        if (value >= core.alphaMin()) endedRef.current = false;\n        return h;\n      },\n      alphaTarget(value?: number) {\n        if (value === undefined) return core.alphaTarget();\n        core.alphaTarget(value);\n        if (value > 0) endedRef.current = false;\n        return h;\n      },\n      alphaDecay(value?: number) {\n        if (value === undefined) return core.alphaDecay();\n        core.alphaDecay(value);\n        return h;\n      },\n      alphaMin(value?: number) {\n        if (value === undefined) return core.alphaMin();\n        core.alphaMin(value);\n        return h;\n      },\n      velocityDecay(value?: number) {\n        if (value === undefined) return core.velocityDecay();\n        core.velocityDecay(value);\n        return h;\n      },\n      restart() {\n        if (core.alpha() < core.alphaMin()) core.alpha(1);\n        endedRef.current = false;\n        startRaf();\n        return h;\n      },\n      stop() {\n        stopRaf();\n        return h;\n      },\n      tick(iterations: number = 1) {\n        core.tick(iterations);\n        return h;\n      },\n      isSettled() {\n        return core.isSettled();\n      },\n    };\n    return h as Simulation<TNode>;\n    /* eslint-enable @typescript-eslint/no-explicit-any */\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n\n  return handle;\n}\n"],"mappings":";;;;;AAqBA,SAAgBA,EACd,GACmB;CACnB,IAAMC,IAAUC,EAAUC,CAAI,GAExBC,IAAUC,EAAqC,IAAI;CACzD,EAAQ,YAAYC,EAAiBH,CAAI;CACzC,IAAMI,IAAOH,EAAQ,SAGfI,IAAWH,EAAO,EAAK,GACvBI,IAAaJ,EAAO,EAAI,GAOxBK,IAAYC,QACV;EAAE,EAAQ;CAAG,GACnB;EACE,cAAcR,EAAK;EACnB,aAAaA,EAAK;CACpB,CACF,GAEMS,UAAsB;EAAE,EAAU,OAAO;CAAG,GAE5CC,UAAsB;EAC1B,IAAKJ,EAAW,SAKhB;OAHAF,EAAK,KAAK,GACVN,EAAQ,QAAQ,SAASM,EAAK,KAAK,GAE/BA,EAAK,MAAM,IAAIA,EAAK,SAAS,GAAG;IAElC,AADAK,EAAQ,GACHJ,EAAS,YACZ,EAAS,UAAU,IACnBP,EAAQ,QAAQ,QAAQ;IAE1B;GACF;GAEA,EAAU,QAAQ;EAFlB;CAGF,GAEMa,UAAuB;EAC3B,AAAKL,EAAW,WAChBC,EAAU,QAAQ;CACpB;CA+EA,OA1EAK,SACE,EAAW,UAAU,IACrBL,EAAU,QAAQ,SACL;EAEX,AADA,EAAW,UAAU,IACrBA,EAAU,OAAO;CACnB,IACC,CAACA,CAAS,CAAC,GAGCM,QAAiC;EAE9C,IAAMC,IAAS;GACb,IAAI,QAAQ;IACV,OAAOV,EAAK;GACd;GACA,SAAS,GAAmB;IAE1B,OADAA,EAAK,SAASW,CAAQ,GACfD;GACT;GACA,UAAU,GAAqC;IAE7C,OADAV,EAAK,UAAUY,CAAS,GACjBF;GACT;GACA,MAAM,GAAgB;IAIpB,OAHIG,MAAU,KAAA,IAAkBb,EAAK,MAAM,KAC3CA,EAAK,MAAMa,CAAK,GACZA,KAASb,EAAK,SAAS,MAAG,EAAS,UAAU,KAC1CU;GACT;GACA,YAAY,GAAgB;IAI1B,OAHIG,MAAU,KAAA,IAAkBb,EAAK,YAAY,KACjDA,EAAK,YAAYa,CAAK,GAClBA,IAAQ,MAAG,EAAS,UAAU,KAC3BH;GACT;GACA,WAAW,GAAgB;IAGzB,OAFIG,MAAU,KAAA,IAAkBb,EAAK,WAAW,KAChDA,EAAK,WAAWa,CAAK,GACdH;GACT;GACA,SAAS,GAAgB;IAGvB,OAFIG,MAAU,KAAA,IAAkBb,EAAK,SAAS,KAC9CA,EAAK,SAASa,CAAK,GACZH;GACT;GACA,cAAc,GAAgB;IAG5B,OAFIG,MAAU,KAAA,IAAkBb,EAAK,cAAc,KACnDA,EAAK,cAAca,CAAK,GACjBH;GACT;GACA,UAAU;IAIR,OAHIV,EAAK,MAAM,IAAIA,EAAK,SAAS,KAAGA,EAAK,MAAM,CAAC,GAChD,EAAS,UAAU,IACnBO,EAAS,GACFG;GACT;GACA,OAAO;IAEL,OADAL,EAAQ,GACDK;GACT;GACA,KAAK,IAAqB,GAAG;IAE3B,OADAV,EAAK,KAAKc,CAAU,GACbJ;GACT;GACA,YAAY;IACV,OAAOV,EAAK,UAAU;GACxB;EACF;EACA,OAAOU;CAGT,GAAG,CAAC,CAEG;AACT"}