@weasel-js/core 1.9.4 → 1.10.0

package/dist/core/strokeMarkerShapes.js

@@ -1,139 +0,0 @@
-import { PATH_L as e, PATH_M as t, PATH_Z as n } from "@weasel-js/geom";
-//#region src/core/strokeMarkerShapes.ts
-function r(r, i, a = !0) {
-	let o = r.length / 2, s = new Uint8Array(a ? o + 1 : o);
-	s[0] = t;
-	for (let t = 1; t < o; t++) s[t] = e;
-	a && (s[o] = n);
-	let c = new Float32Array(r.length);
-	for (let e = 0; e < r.length; e++) c[e] = r[e] * i;
-	return {
-		kind: "polygon",
-		commands: s,
-		coords: c,
-		fillRule: "nonzero"
-	};
-}
-function i(e, t, n, i = 32) {
-	let a = [];
-	for (let n = 0; n < i; n++) {
-		let r = n / i * Math.PI * 2;
-		a.push(e + t * Math.cos(r), t * Math.sin(r));
-	}
-	return r(a, n);
-}
-var a = [
-	{
-		id: "arrow",
-		reads: [],
-		inset: 3,
-		path: ({ size: e }) => r([
-			0,
-			0,
-			-3,
-			-1.5,
-			-3,
-			1.5
-		], e)
-	},
-	{
-		id: "arrow-open",
-		reads: [],
-		inset: 0,
-		fill: "none",
-		outline: { width: 1 },
-		path: ({ size: e }) => r([
-			-2.867,
-			-2.007,
-			0,
-			0,
-			-2.867,
-			2.007
-		], e, !1)
-	},
-	{
-		id: "arrow-concave",
-		reads: [],
-		inset: 3,
-		path: ({ size: e }) => r([
-			0,
-			0,
-			-3,
-			-1.5,
-			-2,
-			0,
-			-3,
-			1.5
-		], e)
-	},
-	{
-		id: "diamond",
-		reads: [],
-		inset: 4,
-		path: ({ size: e }) => r([
-			0,
-			0,
-			-2,
-			-1.2,
-			-4,
-			0,
-			-2,
-			1.2
-		], e)
-	},
-	{
-		id: "diamond-hollow",
-		reads: [],
-		inset: 4,
-		fill: "none",
-		outline: { width: .5 },
-		path: ({ size: e }) => r([
-			0,
-			0,
-			-2,
-			-1.2,
-			-4,
-			0,
-			-2,
-			1.2
-		], e)
-	},
-	{
-		id: "circle",
-		reads: [],
-		inset: 2,
-		path: ({ size: e }) => i(-1, 1, e)
-	},
-	{
-		id: "square",
-		reads: [],
-		inset: 2,
-		path: ({ size: e }) => r([
-			0,
-			-1,
-			0,
-			1,
-			-2,
-			1,
-			-2,
-			-1
-		], e)
-	},
-	{
-		id: "bar",
-		reads: [],
-		inset: 0,
-		fill: "none",
-		outline: { width: 1 },
-		path: ({ size: e }) => r([
-			0,
-			-1.5,
-			0,
-			1.5
-		], e, !1)
-	}
-];
-//#endregion
-export { a as BUILTIN_MARKERS };
-
-//# sourceMappingURL=strokeMarkerShapes.js.map

package/dist/core/strokeMarkerShapes.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"strokeMarkerShapes.js","names":["poly","n","pts","commands","close","PATH_M","i","PATH_L","PATH_Z","coords","size","circle","segments","theta","cx","r","BUILTIN_MARKERS"],"sources":["../../src/core/strokeMarkerShapes.ts"],"sourcesContent":["/**\n * The kit's built-in stroke-marker vocabulary.\n *\n * Every entry is authored with its anchor at the origin and pointing +X, so\n * the line arrives from -X and no geometry sits at positive X. Coordinates are\n * in units of `MarkerCtx.size`, which defaults to the resolved stroke width —\n * one definition is therefore correct at any line weight.\n *\n * Not to be confused with `features/paths/markers.ts`, which builds\n * decorative chrome shapes and is unrelated.\n */\n\nimport { PATH_M, PATH_L, PATH_Z, type PolygonPath } from '@weasel-js/geom';\nimport type { MarkerCtx, MarkerEntry } from './strokeMarkers';\n\nfunction poly(pts: readonly number[], size: number, close = true): PolygonPath {\n  const n = pts.length / 2;\n  const commands = new Uint8Array(close ? n + 1 : n);\n  commands[0] = PATH_M;\n  for (let i = 1; i < n; i++) commands[i] = PATH_L;\n  if (close) commands[n] = PATH_Z;\n  const coords = new Float32Array(pts.length);\n  for (let i = 0; i < pts.length; i++) coords[i] = pts[i] * size;\n  return { kind: 'polygon', commands, coords, fillRule: 'nonzero' };\n}\n\n/** Circle of radius `r` centred at `cx`, in marker units. */\nfunction circle(cx: number, r: number, size: number, segments = 32): PolygonPath {\n  const pts: number[] = [];\n  for (let i = 0; i < segments; i++) {\n    const theta = (i / segments) * Math.PI * 2;\n    pts.push(cx + r * Math.cos(theta), r * Math.sin(theta));\n  }\n  return poly(pts, size);\n}\n\n/** The markers the registry is seeded with: `arrow`, `arrow-open`,\n *  `arrow-concave`, `diamond`, `diamond-hollow`, `circle`, `square` and `bar`. */\nexport const BUILTIN_MARKERS: readonly MarkerEntry[] = [\n  {\n    id: 'arrow',\n    reads: [],\n    inset: 3,\n    path: ({ size }: MarkerCtx) => poly([0, 0, -3, -1.5, -3, 1.5], size),\n  },\n  {\n    id: 'arrow-open',\n    reads: [],\n    inset: 0,\n    fill: 'none',\n    outline: { width: 1 },\n    // Open at the back, so the ribbon runs to the vertex and the arms meet it.\n    // Arms 3.5 long at ±35°: the back opening is 4 units against 2 units of\n    // arm, so the V still reads open. Shorter or narrower and the two arms\n    // close the gap themselves and it paints as a solid triangle.\n    path: ({ size }: MarkerCtx) =>\n      poly([-2.867, -2.007, 0, 0, -2.867, 2.007], size, false),\n  },\n  {\n    id: 'arrow-concave',\n    reads: [],\n    inset: 3,\n    path: ({ size }: MarkerCtx) => poly([0, 0, -3, -1.5, -2, 0, -3, 1.5], size),\n  },\n  {\n    id: 'diamond',\n    reads: [],\n    inset: 4,\n    path: ({ size }: MarkerCtx) => poly([0, 0, -2, -1.2, -4, 0, -2, 1.2], size),\n  },\n  {\n    id: 'diamond-hollow',\n    reads: [],\n    inset: 4,\n    fill: 'none',\n    outline: { width: 0.5 },\n    path: ({ size }: MarkerCtx) => poly([0, 0, -2, -1.2, -4, 0, -2, 1.2], size),\n  },\n  {\n    id: 'circle',\n    reads: [],\n    inset: 2,\n    path: ({ size }: MarkerCtx) => circle(-1, 1, size),\n  },\n  {\n    id: 'square',\n    reads: [],\n    inset: 2,\n    path: ({ size }: MarkerCtx) => poly([0, -1, 0, 1, -2, 1, -2, -1], size),\n  },\n  {\n    id: 'bar',\n    reads: [],\n    inset: 0,\n    fill: 'none',\n    outline: { width: 1 },\n    path: ({ size }: MarkerCtx) => poly([0, -1.5, 0, 1.5], size, false),\n  },\n];\n"],"mappings":";;AAeA,SAASA,EAAK,GAAwB,GAAc,IAAQ,IAAmB;CAC7E,IAAMC,IAAIC,EAAI,SAAS,GACjBC,IAAW,IAAI,WAAWC,IAAQH,IAAI,IAAIA,CAAC;CACjD,EAAS,KAAKI;CACd,KAAK,IAAIC,IAAI,GAAGA,IAAIL,GAAG,KAAK,EAASK,KAAKC;CAC1C,AAAIH,MAAO,EAASH,KAAKO;CACzB,IAAMC,IAAS,IAAI,aAAaP,EAAI,MAAM;CAC1C,KAAK,IAAII,IAAI,GAAGA,IAAIJ,EAAI,QAAQ,KAAK,EAAOI,KAAKJ,EAAII,KAAKI;CAC1D,OAAO;EAAE,MAAM;EAAW;EAAU;EAAQ,UAAU;CAAU;AAClE;AAGA,SAASC,EAAO,GAAY,GAAW,GAAc,IAAW,IAAiB;CAC/E,IAAMT,IAAgB,CAAC;CACvB,KAAK,IAAII,IAAI,GAAGA,IAAIM,GAAU,KAAK;EACjC,IAAMC,IAASP,IAAIM,IAAY,KAAK,KAAK;EACzC,EAAI,KAAKE,IAAKC,IAAI,KAAK,IAAIF,CAAK,GAAGE,IAAI,KAAK,IAAIF,CAAK,CAAC;CACxD;CACA,OAAOb,EAAKE,GAAKQ,CAAI;AACvB;AAIA,IAAaM,IAA0C;CACrD;EACE,IAAI;EACJ,OAAO,CAAC;EACR,OAAO;EACP,OAAO,EAAE,cAAsBhB,EAAK;GAAC;GAAG;GAAG;GAAI;GAAM;GAAI;EAAG,GAAGU,CAAI;CACrE;CACA;EACE,IAAI;EACJ,OAAO,CAAC;EACR,OAAO;EACP,MAAM;EACN,SAAS,EAAE,OAAO,EAAE;EAKpB,OAAO,EAAE,cACPV,EAAK;GAAC;GAAQ;GAAQ;GAAG;GAAG;GAAQ;EAAK,GAAGU,GAAM,EAAK;CAC3D;CACA;EACE,IAAI;EACJ,OAAO,CAAC;EACR,OAAO;EACP,OAAO,EAAE,cAAsBV,EAAK;GAAC;GAAG;GAAG;GAAI;GAAM;GAAI;GAAG;GAAI;EAAG,GAAGU,CAAI;CAC5E;CACA;EACE,IAAI;EACJ,OAAO,CAAC;EACR,OAAO;EACP,OAAO,EAAE,cAAsBV,EAAK;GAAC;GAAG;GAAG;GAAI;GAAM;GAAI;GAAG;GAAI;EAAG,GAAGU,CAAI;CAC5E;CACA;EACE,IAAI;EACJ,OAAO,CAAC;EACR,OAAO;EACP,MAAM;EACN,SAAS,EAAE,OAAO,GAAI;EACtB,OAAO,EAAE,cAAsBV,EAAK;GAAC;GAAG;GAAG;GAAI;GAAM;GAAI;GAAG;GAAI;EAAG,GAAGU,CAAI;CAC5E;CACA;EACE,IAAI;EACJ,OAAO,CAAC;EACR,OAAO;EACP,OAAO,EAAE,cAAsBC,EAAO,IAAI,GAAGD,CAAI;CACnD;CACA;EACE,IAAI;EACJ,OAAO,CAAC;EACR,OAAO;EACP,OAAO,EAAE,cAAsBV,EAAK;GAAC;GAAG;GAAI;GAAG;GAAG;GAAI;GAAG;GAAI;EAAE,GAAGU,CAAI;CACxE;CACA;EACE,IAAI;EACJ,OAAO,CAAC;EACR,OAAO;EACP,MAAM;EACN,SAAS,EAAE,OAAO,EAAE;EACpB,OAAO,EAAE,cAAsBV,EAAK;GAAC;GAAG;GAAM;GAAG;EAAG,GAAGU,GAAM,EAAK;CACpE;AACF"}

package/dist/core/strokeMarkers.js

@@ -1,28 +0,0 @@
-import { BUILTIN_MARKERS as e } from "./strokeMarkerShapes.js";
-import { createReflectable as t } from "@weasel-js/registry";
-//#region src/core/strokeMarkers.ts
-var n = t();
-function r() {
-	for (let t of e) n.push(t.id, t, { source: "kit" });
-}
-r();
-var i = n.reflection;
-function a() {
-	return n.getVersion();
-}
-function o(e) {
-	return n.push(e.id, e);
-}
-function s(e) {
-	return e === void 0 ? void 0 : n.get(e);
-}
-function c() {
-	return n.entries().map((e) => e.value);
-}
-function l() {
-	n.clear(), r();
-}
-//#endregion
-export { l as _resetMarkersForTests, s as getMarker, c as listMarkers, a as markerGeneration, i as markerRegistry, o as registerMarker };
-
-//# sourceMappingURL=strokeMarkers.js.map

package/dist/core/strokeMarkers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"strokeMarkers.js","names":["MARKERS","createReflectable","seedBuiltins","entry","BUILTIN_MARKERS","markerRegistry","markerGeneration","registerMarker","getMarker","key","listMarkers","_resetMarkersForTests"],"sources":["../../src/core/strokeMarkers.ts"],"sourcesContent":["/**\n * The stroke-marker registry — arrowheads and other line terminators.\n *\n * Keyed by string, because a key is what sits in `stroke.markerEnd`. That is\n * the difference from `registerNodeShape`, which resolves by first-matching\n * predicate and whose `id` is only a label.\n *\n * A built-in's SVG slot lives in `@weasel-js/svg` and cannot be imported here\n * without inverting a package dependency, so an entry carries `toSvg` for that\n * package to consume — the same split `PaintKindEntry` uses.\n */\n\nimport type { FillStyle, MarkerKey, Stroke } from '@weasel-js/paint';\nimport type { Path } from '@weasel-js/geom';\nimport { createReflectable, type Reflection } from '@weasel-js/registry';\nimport { BUILTIN_MARKERS } from './strokeMarkerShapes';\n\n/** What an entry's `path` is given. Entries that ignore it may return a\n *  constant path. */\nexport interface MarkerCtx {\n  /** One geometry unit, in the same world units the ribbon is tessellated in.\n   *  Defaults to the resolved stroke width. */\n  readonly size: number;\n  /** The stroke this marker belongs to, already width-resolved. */\n  readonly stroke: Stroke;\n}\n\n/** `'line'` means the stroke's own paint — SVG 2's `context-stroke`, as the\n *  default rather than an opt-in. */\nexport type MarkerPaint = FillStyle | 'line' | 'none';\n\n/** A stroke-marker registry entry: a terminator's geometry, paint and inset. */\nexport interface MarkerEntry {\n  /** `'kit:'`-free for built-ins so the key matches the SVG attribute value;\n   *  consumers should prefix (`'app-my-head'`). A key becomes the `id` of the\n   *  emitted `<marker>` def, so it must be a valid XML name — no colons. */\n  id: MarkerKey;\n  /** Geometry with its anchor at the origin, pointing +X, in units of\n   *  `ctx.size`. An arbitrary anchor is expressed by where the geometry is\n   *  drawn, which is why there is no `refX`/`refY`. */\n  path(ctx: MarkerCtx): Path;\n  /** Default `'line'`. */\n  fill?: MarkerPaint;\n  /** Outline width is in the same units as `path`. `false` (the default)\n   *  means no outline. */\n  outline?: { width: number; paint?: MarkerPaint } | false;\n  /** How far back along the line the stroke stops, in units of `ctx.size`.\n   *  Default 0. A property of the shape, not a setting on the stroke: an open\n   *  V needs 0 or its arms stop meeting the line. */\n  inset?: number;\n  /** `'auto'` (default) follows the line; a number is a fixed angle in\n   *  radians, ignoring the line — SVG's `orient=\"<angle>\"`. */\n  orient?: 'auto' | number;\n  /** The stroke fields `path` reads besides `ctx.size` — `[]` for a shape\n   *  drawn from size alone. Declared, a head is reused across stroke objects\n   *  whose listed fields are equal; omitted, only across frames that pass the\n   *  same stroke object, since `path` might read any of it. */\n  reads?: readonly (keyof Stroke)[];\n  /** Emits the `<marker>` def. Consumed by `@weasel-js/svg`. */\n  toSvg?(id: string, entry: MarkerEntry): string;\n}\n\nconst MARKERS = createReflectable<MarkerEntry>();\n\nfunction seedBuiltins(): void {\n  for (const entry of BUILTIN_MARKERS) MARKERS.push(entry.id, entry, { source: 'kit' });\n}\nseedBuiltins();\n\n/** Every registered marker, with the overrides each displaced. */\nexport const markerRegistry: Reflection<MarkerEntry> = MARKERS.reflection;\n\n/** Bumped whenever the registered set changes, for caches of marker geometry. */\nexport function markerGeneration(): number {\n  return MARKERS.getVersion();\n}\n\n/** Register a marker. Returns a disposer. Re-registering an existing id is an\n *  override; disposing it uncovers whatever it displaced rather than deleting the key. */\nexport function registerMarker(entry: MarkerEntry): () => void {\n  return MARKERS.push(entry.id, entry);\n}\n\n/** The entry for `key`, or `undefined`. */\nexport function getMarker(key: string | undefined): MarkerEntry | undefined {\n  return key === undefined ? undefined : MARKERS.get(key);\n}\n\n/** Every registered marker, built-ins first, in registration order. */\nexport function listMarkers(): readonly MarkerEntry[] {\n  return MARKERS.entries().map((e) => e.value);\n}\n\n/** Test helper. Do not call from product code. */\nexport function _resetMarkersForTests(): void {\n  MARKERS.clear();\n  seedBuiltins();\n}\n"],"mappings":";;;AA8DA,IAAMA,IAAUC,EAA+B;AAE/C,SAASC,IAAqB;CAC5B,KAAK,IAAMC,KAASC,GAAiB,EAAQ,KAAKD,EAAM,IAAIA,GAAO,EAAE,QAAQ,MAAM,CAAC;AACtF;AACAD,EAAa;AAGb,IAAaG,IAA0CL,EAAQ;AAG/D,SAAgBM,IAA2B;CACzC,OAAON,EAAQ,WAAW;AAC5B;AAIA,SAAgBO,EAAe,GAAgC;CAC7D,OAAOP,EAAQ,KAAKG,EAAM,IAAIA,CAAK;AACrC;AAGA,SAAgBK,EAAU,GAAkD;CAC1E,OAAOC,MAAQ,KAAA,IAAY,KAAA,IAAYT,EAAQ,IAAIS,CAAG;AACxD;AAGA,SAAgBC,IAAsC;CACpD,OAAOV,EAAQ,QAAQ,CAAC,CAAC,KAAK,MAAM,EAAE,KAAK;AAC7C;AAGA,SAAgBW,IAA8B;CAE5C,AADAX,EAAQ,MAAM,GACdE,EAAa;AACf"}

package/dist/core/viewport/meanScale.js

@@ -1,8 +0,0 @@
-//#region src/core/viewport/meanScale.ts
-function e(e) {
-	return Math.sqrt(Math.abs(e.x * e.y));
-}
-//#endregion
-export { e as meanScale };
-
-//# sourceMappingURL=meanScale.js.map

package/dist/core/viewport/meanScale.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"meanScale.js","names":["meanScale","s"],"sources":["../../../src/core/viewport/meanScale.ts"],"sourcesContent":["/**\n * Geometric mean of a per-axis scale's magnitudes, so a flipped (negative)\n * axis counts by its size. Degenerates to that size when the two axes are\n * equal; otherwise sits between them.\n *\n * **Not for hit-testing.** A screen-pixel length is not one world distance\n * under non-uniform zoom, and collapsing it to a scalar makes a pickable\n * region too generous on one axis and too mean on the other. Use `pxExtent`\n * for a per-axis world length, or `withinPxBox` / `withinPxRadius` to compare\n * in screen space directly. Chrome hit-tests moved off this in 2026-08.\n *\n * Nor for placing chrome or measuring a pick slop: `standoff` and\n * `strokeHitTest`'s `slop` work on screen, which stays exact under a rotated\n * target where no per-axis world answer exists.\n *\n * What legitimately remains is a stroke width for a line that is not\n * axis-aligned. A ribbon takes one world width, and the renderer resolves a\n * `{ px }` width through this same mean, so a picker reading ink widths must\n * too. An axis-aligned line has an exact answer — `pxExtent` on its cross\n * axis, as the grid layer does.\n */\nexport function meanScale(s: { x: number; y: number }): number {\n  return Math.sqrt(Math.abs(s.x * s.y));\n}\n"],"mappings":";AAqBA,SAAgBA,EAAU,GAAqC;CAC7D,OAAO,KAAK,KAAK,KAAK,IAAIC,EAAE,IAAIA,EAAE,CAAC,CAAC;AACtC"}

package/dist/core/viewport/pxExtent.js

@@ -1,42 +0,0 @@
-//#region src/core/viewport/pxExtent.ts
-function e(e, t, n = 0) {
-	if (!n) return {
-		x: e / Math.abs(t.x),
-		y: e / Math.abs(t.y)
-	};
-	let r = Math.cos(n), i = Math.sin(n);
-	return {
-		x: e * Math.hypot(r / t.x, i / t.y),
-		y: e * Math.hypot(i / t.x, r / t.y)
-	};
-}
-function t(e, t, n) {
-	return {
-		x: e * n.x,
-		y: t * n.y
-	};
-}
-function n(e, n, r, i) {
-	let a = t(e, n, i);
-	return Math.abs(a.x) <= r && Math.abs(a.y) <= r;
-}
-function r(e, n, r, i) {
-	let a = t(e, n, i);
-	return a.x * a.x + a.y * a.y <= r * r;
-}
-function i(e, t, n, r) {
-	let i = Math.sign(r.x * r.y) || 1, a = t.x * r.y * i, o = t.y * r.x * i, s = Math.hypot(a, o) || 1;
-	return a /= s, o /= s, {
-		x: e.x + a * n / r.x,
-		y: e.y + o * n / r.y,
-		nx: a,
-		ny: o
-	};
-}
-function a(e, t) {
-	return Math.atan2(Math.sin(e) * t.y, Math.cos(e) * t.x);
-}
-//#endregion
-export { e as pxExtent, t as scaleDelta, a as screenAngleOf, i as standoff, n as withinPxBox, r as withinPxRadius };
-
-//# sourceMappingURL=pxExtent.js.map

package/dist/core/viewport/pxExtent.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"pxExtent.js","names":["pxExtent","rotation","px","scale","c","s","scaleDelta","dx","dy","withinPxBox","withinPxRadius","standoff","k","nx","normal","ny","l","anchor","screenAngleOf"],"sources":["../../../src/core/viewport/pxExtent.ts"],"sourcesContent":["/**\n * Screen-pixel lengths in world units, per axis.\n *\n * Chrome declares its hit zones in screen pixels — an 8px handle stays 8px at\n * every zoom, because it paints in screen space. Converting one such length to\n * world units with a single scalar (see `meanScale`) is exact only under\n * uniform zoom; per-axis it is too generous on one axis and too mean on the\n * other, so the pickable region stops matching the painted one.\n *\n * Prefer {@link withinPxBox} / {@link withinPxRadius}, which compare in screen\n * space and so can't drift from the paint at all. {@link pxExtent} is for the\n * cases that must stay in world units — a tolerance handed to geometry that\n * doesn't know about the view.\n */\n\nexport interface Scale2 {\n  x: number;\n  y: number;\n}\n\n/** One screen-pixel length as world-space extents, per axis. `scale` is a\n *  view's, so neither axis is zero (see `View`).\n *\n *  With `rotation`, the axes are a frame turned that far from world, and each\n *  extent is how far along it an edge across it must move to move `px` on\n *  screen — which, under non-uniform zoom, is not the extent along the screen\n *  axis nearest to it. */\nexport function pxExtent(px: number, scale: Scale2, rotation = 0): { x: number; y: number } {\n  if (!rotation) {\n    return {\n      x: px / Math.abs(scale.x),\n      y: px / Math.abs(scale.y),\n    };\n  }\n  const c = Math.cos(rotation), s = Math.sin(rotation);\n  return {\n    x: px * Math.hypot(c / scale.x, s / scale.y),\n    y: px * Math.hypot(s / scale.x, c / scale.y),\n  };\n}\n\n/** World delta → screen delta. Only the scale participates: translation\n *  cancels in a difference, and the kit's views carry no skew. */\nexport function scaleDelta(dx: number, dy: number, scale: Scale2): { x: number; y: number } {\n  return { x: dx * scale.x, y: dy * scale.y };\n}\n\n/**\n * Is a world-space delta inside a screen-space square of half-extent `px`?\n *\n * The square is axis-aligned **on screen**, which is what a handle painted in\n * screen space actually is — so this stays true under non-uniform zoom and\n * under a rotated target, where an axis-aligned world-space test is a rotated\n * rectangle on screen.\n */\nexport function withinPxBox(dx: number, dy: number, px: number, scale: Scale2): boolean {\n  const s = scaleDelta(dx, dy, scale);\n  return Math.abs(s.x) <= px && Math.abs(s.y) <= px;\n}\n\n/** Is a world-space delta inside a screen-space circle of radius `px`? */\nexport function withinPxRadius(dx: number, dy: number, px: number, scale: Scale2): boolean {\n  const s = scaleDelta(dx, dy, scale);\n  return s.x * s.x + s.y * s.y <= px * px;\n}\n\n/**\n * A world point pushed `px` screen pixels off an edge, along the edge's normal\n * as it lands on screen. `normal` is the edge's outward normal in world space.\n *\n * Scaling the world normal by the view is not the same thing: under\n * non-uniform zoom the image of a normal is no longer perpendicular to the\n * image of its edge, so chrome placed that way drifts sideways and sits closer\n * than `px`. Returns the point in world coords and the on-screen unit normal.\n */\nexport function standoff(\n  anchor: { x: number; y: number },\n  normal: { x: number; y: number },\n  px: number,\n  scale: Scale2,\n): { x: number; y: number; nx: number; ny: number } {\n  // The edge's screen normal is S⁻ᵀn, here scaled by det S to stay finite.\n  const k = Math.sign(scale.x * scale.y) || 1;\n  let nx = normal.x * scale.y * k;\n  let ny = normal.y * scale.x * k;\n  const l = Math.hypot(nx, ny) || 1;\n  nx /= l;\n  ny /= l;\n  return { x: anchor.x + (nx * px) / scale.x, y: anchor.y + (ny * px) / scale.y, nx, ny };\n}\n\n/** The screen angle a frame turned `rotation` from world lands its x axis at.\n *  Equals `rotation` under uniform zoom; non-uniform zoom bends it. */\nexport function screenAngleOf(rotation: number, scale: Scale2): number {\n  return Math.atan2(Math.sin(rotation) * scale.y, Math.cos(rotation) * scale.x);\n}\n"],"mappings":";AA2BA,SAAgBA,EAAS,GAAY,GAAe,IAAW,GAA6B;CAC1F,IAAI,CAACC,GACH,OAAO;EACL,GAAGC,IAAK,KAAK,IAAIC,EAAM,CAAC;EACxB,GAAGD,IAAK,KAAK,IAAIC,EAAM,CAAC;CAC1B;CAEF,IAAMC,IAAI,KAAK,IAAIH,CAAQ,GAAGI,IAAI,KAAK,IAAIJ,CAAQ;CACnD,OAAO;EACL,GAAGC,IAAK,KAAK,MAAME,IAAID,EAAM,GAAGE,IAAIF,EAAM,CAAC;EAC3C,GAAGD,IAAK,KAAK,MAAMG,IAAIF,EAAM,GAAGC,IAAID,EAAM,CAAC;CAC7C;AACF;AAIA,SAAgBG,EAAW,GAAY,GAAY,GAAyC;CAC1F,OAAO;EAAE,GAAGC,IAAKJ,EAAM;EAAG,GAAGK,IAAKL,EAAM;CAAE;AAC5C;AAUA,SAAgBM,EAAY,GAAY,GAAY,GAAY,GAAwB;CACtF,IAAMJ,IAAIC,EAAWC,GAAIC,GAAIL,CAAK;CAClC,OAAO,KAAK,IAAIE,EAAE,CAAC,KAAKH,KAAM,KAAK,IAAIG,EAAE,CAAC,KAAKH;AACjD;AAGA,SAAgBQ,EAAe,GAAY,GAAY,GAAY,GAAwB;CACzF,IAAML,IAAIC,EAAWC,GAAIC,GAAIL,CAAK;CAClC,OAAOE,EAAE,IAAIA,EAAE,IAAIA,EAAE,IAAIA,EAAE,KAAKH,IAAKA;AACvC;AAWA,SAAgBS,EACd,GACA,GACA,GACA,GACkD;CAElD,IAAMC,IAAI,KAAK,KAAKT,EAAM,IAAIA,EAAM,CAAC,KAAK,GACtCU,IAAKC,EAAO,IAAIX,EAAM,IAAIS,GAC1BG,IAAKD,EAAO,IAAIX,EAAM,IAAIS,GACxBI,IAAI,KAAK,MAAMH,GAAIE,CAAE,KAAK;CAGhC,OAFA,KAAMC,GACN,KAAMA,GACC;EAAE,GAAGC,EAAO,IAAKJ,IAAKX,IAAMC,EAAM;EAAG,GAAGc,EAAO,IAAKF,IAAKb,IAAMC,EAAM;EAAG;EAAI;CAAG;AACxF;AAIA,SAAgBe,EAAc,GAAkB,GAAuB;CACrE,OAAO,KAAK,MAAM,KAAK,IAAIjB,CAAQ,IAAIE,EAAM,GAAG,KAAK,IAAIF,CAAQ,IAAIE,EAAM,CAAC;AAC9E"}

package/dist/features/cursor/paintedCursorLayer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"paintedCursorLayer.js","names":["PAINTED_CURSOR_LAYER_ID","pathCache","pathFor","p","d","pathFromD","commandFor","op","createPaintedCursorLayer","frame","state","glyph","GLYPHS","cursor","scale","view","worldSized","size","cursorWorldSize","ops","cursorPaintOps","chromeLineWidthScale","a","b","c","e","f","cursorPaintMatrix"],"sources":["../../../src/features/cursor/paintedCursorLayer.ts"],"sourcesContent":["/**\n * The painted tier: draws a cursor glyph into the scene when it is too big,\n * or too tied to the view, to be a CSS `url()` cursor.\n *\n * A layer rather than something each tool draws in its own overlay, because\n * the alternative is every tool re-wiring the same thing. Riding the layer\n * system also means anything that reaches the cursor pipeline through a layer\n * claim — a HUD widget's `cursorAt` — gets the painted tier without knowing\n * this exists.\n *\n * Screen-space: the glyph is chrome at the pointer, not content in the\n * document, so it must not pan or zoom with the camera. What *does* track the\n * camera is a world-sized glyph's size, and `view.scale` is read for that.\n */\n\nimport { GLYPHS } from '@weasel-js/cursor';\nimport {\n  chromeLineWidthScale,\n  cursorPaintMatrix,\n  cursorPaintOps,\n  cursorWorldSize,\n} from '@weasel-js/cursor';\nimport type { CursorPaintOp } from '@weasel-js/cursor';\nimport type { DrawCommand, PathDrawCommand } from '../../renderer';\nimport type { RenderLayer } from 'core/layers/render';\nimport { pathFromD, type Path } from '@weasel-js/geom';\nimport type { PaintedCursorState } from '@weasel-js/cursor';\n\n/** Layer id, so a consumer can order or hide it like any other. */\nexport const PAINTED_CURSOR_LAYER_ID = 'painted-cursor';\n\n/**\n * `d` strings are fixed by the glyph set, so the parse is done once per glyph\n * member for the life of the process. Handing the renderer the same `Path`\n * object every frame also lets its own mesh cache hit.\n */\nconst pathCache = new Map<string, Path>();\nfunction pathFor(d: string): Path {\n  let p = pathCache.get(d);\n  if (p === undefined) {\n    p = pathFromD(d);\n    pathCache.set(d, p);\n  }\n  return p;\n}\n\nfunction commandFor(op: CursorPaintOp): PathDrawCommand {\n  return {\n    kind: 'path',\n    path: pathFor(op.d),\n    ...(op.fill !== undefined ? { fill: { color: op.fill } } : {}),\n    ...(op.stroke !== undefined\n      ? {\n          stroke: {\n            paint: { color: op.stroke.color },\n            width: op.stroke.width,\n            cap: 'round' as const,\n            join: 'round' as const,\n          },\n        }\n      : {}),\n  };\n}\n\n/**\n * A screen-space layer that draws the glyph `state` currently holds at the pointer,\n * or nothing when it holds none. `<Canvas>` mounts one over its own state already.\n */\nexport function createPaintedCursorLayer(state: PaintedCursorState): RenderLayer<unknown> {\n  return {\n    id: PAINTED_CURSOR_LAYER_ID,\n    label: 'Painted cursor',\n    space: 'screen',\n    draw: (_data, view) => {\n      const frame = state.current();\n      if (!frame) return [];\n      const { cursor, at } = frame;\n      const glyph = GLYPHS[cursor.glyph];\n      if (!glyph) return [];\n\n      // A world-sized glyph is measured against the live camera, and holds its\n      // line weight in CSS px while its geometry grows — a ring at a 400px\n      // radius drawn with scaled weight is a filled blob, not a cursor.\n      // Radial, so a single radius needs one scale factor; average the axes.\n      const scale = (view.scale.x + view.scale.y) / 2;\n      const worldSized = cursor.worldRadius !== undefined;\n      const size = worldSized\n        ? cursorWorldSize(glyph, cursor.worldRadius as number, scale)\n        : (cursor.size ?? 24);\n      if (!(size > 0) || !Number.isFinite(size)) return [];\n\n      const ops = cursorPaintOps(\n        glyph,\n        worldSized ? { lineWidthScale: chromeLineWidthScale(glyph, size) } : {},\n      );\n      const [a, b, c, d, e, f] = cursorPaintMatrix(glyph, {\n        size,\n        angle: cursor.angle,\n        at,\n      });\n      // Column-major, the layout `Mat3` documents.\n      const transform = new Float32Array([a, b, 0, c, d, 0, e, f, 1]);\n      const children: DrawCommand[] = ops.map(commandFor);\n      return [{ kind: 'group', transform, children }];\n    },\n  };\n}\n"],"mappings":";;;AA6BA,IAAaA,IAA0B,kBAOjCC,oBAAY,IAAI,IAAkB;AACxC,SAASC,EAAQ,GAAiB;CAChC,IAAIC,IAAIF,EAAU,IAAIG,CAAC;CAKvB,OAJID,MAAM,KAAA,MACR,IAAIE,EAAUD,CAAC,GACfH,EAAU,IAAIG,GAAGD,CAAC,IAEbA;AACT;AAEA,SAASG,EAAW,GAAoC;CACtD,OAAO;EACL,MAAM;EACN,MAAMJ,EAAQK,EAAG,CAAC;EAClB,GAAIA,EAAG,SAAS,KAAA,IAA2C,CAAC,IAAhC,EAAE,MAAM,EAAE,OAAOA,EAAG,KAAK,EAAE;EACvD,GAAIA,EAAG,WAAW,KAAA,IASd,CAAC,IARD,EACE,QAAQ;GACN,OAAO,EAAE,OAAOA,EAAG,OAAO,MAAM;GAChC,OAAOA,EAAG,OAAO;GACjB,KAAK;GACL,MAAM;EACR,EACF;CAEN;AACF;AAMA,SAAgBC,EAAyB,GAAiD;CACxF,OAAO;EACL,IAAIR;EACJ,OAAO;EACP,OAAO;EACP,OAAO,GAAO,MAAS;GACrB,IAAMS,IAAQC,EAAM,QAAQ;GAC5B,IAAI,CAACD,GAAO,OAAO,CAAC;GACpB,IAAM,EAAE,WAAQ,UAAOA,GACjBE,IAAQC,EAAOC,EAAO;GAC5B,IAAI,CAACF,GAAO,OAAO,CAAC;GAMpB,IAAMG,KAASC,EAAK,MAAM,IAAIA,EAAK,MAAM,KAAK,GACxCC,IAAaH,EAAO,gBAAgB,KAAA,GACpCI,IAAOD,IACTE,EAAgBP,GAAOE,EAAO,aAAuBC,CAAK,IACzDD,EAAO,QAAQ;GACpB,IAAI,EAAEI,IAAO,MAAM,CAAC,OAAO,SAASA,CAAI,GAAG,OAAO,CAAC;GAEnD,IAAME,IAAMC,EACVT,GACAK,IAAa,EAAE,gBAAgBK,EAAqBV,GAAOM,CAAI,EAAE,IAAI,CAAC,CACxE,GACM,CAACK,GAAGC,GAAGC,GAAGpB,GAAGqB,GAAGC,KAAKC,EAAkBhB,GAAO;IAClD;IACA,OAAOE,EAAO;IACd;GACF,CAAC;GAID,OAAO,CAAC;IAAE,MAAM;IAAS,WAAA,IAFH,aAAa;KAACS;KAAGC;KAAG;KAAGC;KAAGpB;KAAG;KAAGqB;KAAGC;KAAG;IAAC,CAEpC;IAAW,UADJP,EAAI,IAAIb,CACJ;GAAS,CAAC;EAChD;CACF;AACF"}

package/dist/features/focus/gateLayer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"gateLayer.js","names":["gateLayer","opts","wrapped","layer","visible","data","view","dims","deps","hitTest","args","subscribeToSources"],"sources":["../../../src/features/focus/gateLayer.ts"],"sourcesContent":["/**\n * `RenderLayer` wrapper that conditionally emits draw commands based on a\n * predicate. Most common use: hide selection-overlay handles when the\n * canvas isn't focused.\n *\n * The predicate is a getter (`() => boolean`), not a static value, because\n * RenderLayers are constructed once but their `draw` runs every frame —\n * a static value would lock in whatever the predicate returned at\n * construction time.\n */\nimport { subscribeToSources, type RenderLayer } from 'core/layers/render';\n\n/** Options for `gateLayer`. */\nexport interface GateLayerOptions<TData> {\n  /** The wrapped layer. Everything but `draw`, `hitTest`, and `deps` flows\n   *  through unchanged. */\n  layer: RenderLayer<TData>;\n  /** Returns `true` to render the layer this frame, `false` to skip. */\n  visible: () => boolean;\n}\n\n/** Wrap a render layer so it only draws, and is only hit, while `visible()`\n *  is true. The predicate is consulted per frame, which is how chrome follows\n *  canvas focus without the layer knowing anything about focus. */\nexport function gateLayer<TData>(opts: GateLayerOptions<TData>): RenderLayer<TData> {\n  const { layer, visible } = opts;\n  const wrapped: RenderLayer<TData> = {\n    ...layer,\n    draw: (data, view, dims) => (visible() ? layer.draw(data, view, dims) : []),\n  };\n  const { deps, hitTest } = layer;\n  if (deps) wrapped.deps = (data, view, dims) => [visible(), ...deps(data, view, dims)];\n  if (hitTest) wrapped.hitTest = (...args) => (visible() ? hitTest(...args) : null);\n  if (layer.subscribe) wrapped.subscribe = subscribeToSources([layer]);\n  return wrapped;\n}\n"],"mappings":";;AAwBA,SAAgBA,EAAiB,GAAmD;CAClF,IAAM,EAAE,UAAO,eAAYC,GACrBC,IAA8B;EAClC,GAAGC;EACH,OAAO,GAAM,GAAM,MAAUC,EAAQ,IAAID,EAAM,KAAKE,GAAMC,GAAMC,CAAI,IAAI,CAAC;CAC3E,GACM,EAAE,SAAM,eAAYJ;CAI1B,OAHIK,MAAM,EAAQ,QAAQ,GAAM,GAAM,MAAS,CAACJ,EAAQ,GAAG,GAAGI,EAAKH,GAAMC,GAAMC,CAAI,CAAC,IAChFE,MAAS,EAAQ,WAAW,GAAGC,MAAUN,EAAQ,IAAIK,EAAQ,GAAGC,CAAI,IAAI,OACxEP,EAAM,cAAW,EAAQ,YAAYQ,EAAmB,CAACR,CAAK,CAAC,IAC5DD;AACT"}

package/dist/features/focus/useCanvasFocus.js

@@ -1,29 +0,0 @@
-import { useCallback as e, useMemo as t, useRef as n, useState as r } from "react";
-//#region src/features/focus/useCanvasFocus.ts
-function i(i = {}) {
-	let { initial: a = !1, tabIndex: o = 0 } = i, [s, c] = r(a), l = n(a), u = e(() => {
-		l.current || (l.current = !0, c(!0));
-	}, []), d = e(() => {
-		l.current && (l.current = !1, c(!1));
-	}, []), f = e(() => l.current, []), p = e((e) => {
-		l.current !== e && (l.current = e, c(e));
-	}, []);
-	return {
-		focused: s,
-		focusProps: t(() => ({
-			tabIndex: o,
-			onFocus: u,
-			onBlur: d
-		}), [
-			o,
-			u,
-			d
-		]),
-		getFocused: f,
-		setFocused: p
-	};
-}
-//#endregion
-export { i as useCanvasFocus };
-
-//# sourceMappingURL=useCanvasFocus.js.map

package/dist/features/focus/useCanvasFocus.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useCanvasFocus.js","names":["useCanvasFocus","options","focused","setFocusedState","useState","initial","focusedRef","useRef","onFocus","useCallback","onBlur","getFocused","setFocused","next","useMemo","tabIndex"],"sources":["../../../src/features/focus/useCanvasFocus.ts"],"sourcesContent":["/**\n * Track DOM focus on a canvas (or any focusable host element). Returns the\n * live `focused` boolean, props to spread onto the focusable element, and a\n * stable `getFocused()` getter for use inside per-frame closures (notably\n * `RenderLayer.draw`, which is constructed once but called every frame).\n *\n * Pure feature module — no Canvas/SceneCanvas integration. Consumers compose\n * the hook + `gateLayer` (or their own gate) to hide affordances when blurred.\n */\nimport { useCallback, useMemo, useRef, useState } from 'react';\n\n/** Options for `useCanvasFocus`. */\nexport interface UseCanvasFocusOptions {\n  /** Initial focus state. Default `false` — handles hidden until first click. */\n  initial?: boolean;\n  /** `tabIndex` to set on the focusable element. Default `0` (focusable in\n   *  document tab order). Set to `-1` for programmatic-only focus. */\n  tabIndex?: number;\n}\n\n/** What `useCanvasFocus` hands back: the focus state, the props that\n *  maintain it, and a getter for reading it from per-frame code. */\nexport interface CanvasFocusReturn {\n  /** Live boolean — true when the element has DOM focus. Triggers re-renders\n   *  when the focus state changes (set via React state). */\n  focused: boolean;\n  /** Spread onto the focusable element (e.g. the canvas). Includes\n   *  `tabIndex`, `onFocus`, `onBlur`. */\n  focusProps: {\n    tabIndex: number;\n    onFocus: () => void;\n    onBlur: () => void;\n  };\n  /** Stable getter for the live focused state. Use inside per-frame closures\n   *  like `RenderLayer.draw`, where the layer is constructed once and\n   *  reading `focused` directly would capture the value at construction\n   *  time. The getter always returns the current value. */\n  getFocused: () => boolean;\n  /** Imperative focus / blur. Useful for tests and programmatic control. */\n  setFocused: (next: boolean) => void;\n}\n\n/** Track DOM focus on the canvas, so chrome that should only show while the\n *  canvas is focused can be gated on it. */\nexport function useCanvasFocus(options: UseCanvasFocusOptions = {}): CanvasFocusReturn {\n  const { initial = false, tabIndex = 0 } = options;\n  const [focused, setFocusedState] = useState<boolean>(initial);\n  // Every state change goes through a handler below that writes this first.\n  const focusedRef = useRef<boolean>(initial);\n\n  const onFocus = useCallback(() => {\n    if (!focusedRef.current) {\n      focusedRef.current = true;\n      setFocusedState(true);\n    }\n  }, []);\n  const onBlur = useCallback(() => {\n    if (focusedRef.current) {\n      focusedRef.current = false;\n      setFocusedState(false);\n    }\n  }, []);\n  const getFocused = useCallback(() => focusedRef.current, []);\n  const setFocused = useCallback((next: boolean) => {\n    if (focusedRef.current === next) return;\n    focusedRef.current = next;\n    setFocusedState(next);\n  }, []);\n\n  // Stable until tabIndex changes, so it can be spread onto memoized elements\n  // without retriggering downstream effects.\n  const focusProps = useMemo(() => ({ tabIndex, onFocus, onBlur }), [tabIndex, onFocus, onBlur]);\n\n  return {\n    focused,\n    focusProps,\n    getFocused,\n    setFocused,\n  };\n}\n"],"mappings":";;AA4CA,SAAgBA,EAAe,IAAiC,CAAC,GAAsB;CACrF,IAAM,EAAE,aAAU,IAAO,cAAW,MAAMC,GACpC,CAACC,GAASC,KAAmBC,EAAkBC,CAAO,GAEtDC,IAAaC,EAAgBF,CAAO,GAEpCG,IAAUC,QAAkB;EAChC,AAAKH,EAAW,YACd,EAAW,UAAU,IACrBH,EAAgB,EAAI;CAExB,GAAG,CAAC,CAAC,GACCO,IAASD,QAAkB;EAC/B,AAAIH,EAAW,YACb,EAAW,UAAU,IACrBH,EAAgB,EAAK;CAEzB,GAAG,CAAC,CAAC,GACCQ,IAAaF,QAAkBH,EAAW,SAAS,CAAC,CAAC,GACrDM,IAAaH,GAAa,MAAkB;EAChD,AAAIH,EAAW,YAAYO,MAC3B,EAAW,UAAUA,GACrBV,EAAgBU,CAAI;CACtB,GAAG,CAAC,CAAC;CAML,OAAO;EACL;EACA,YAJiBC,SAAe;GAAE;GAAU;GAAS;EAAO,IAAI;GAACC;GAAUP;GAASE;EAAM,CAI1F;EACA;EACA;CACF;AACF"}

package/dist/features/groups/children.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"children.js","names":["createChildrenLayer","opts","getChildren","ids","out","id","sub","data","view","cmd"],"sources":["../../../src/features/groups/children.ts"],"sourcesContent":["/**\n * Z-ordered child renderer — replaces the manual `for (id of getChildren()) ...`\n * pattern with a `RenderLayer` factory that consumes an `OrderedAdapter`.\n *\n * Children are drawn in z-order (forward iteration: index 0 = bottom). The\n * caller supplies a `drawChild` callback that emits `DrawCommand[]` for one\n * object; this layer is the boilerplate-free way to plug a scene graph's\n * z-order into the layer composition system.\n *\n * If the adapter doesn't implement `getChildren` (it's optional on\n * `OrderedAdapter`), the layer is a silent no-op — adopt z-order incrementally\n * without breaking existing layers.\n */\n\nimport type { DrawCommand } from '../../renderer';\nimport type { RenderLayer } from 'core/layers/render';\nimport type { View } from 'core/viewport/view';\nimport type { OrderedAdapter } from 'core/adapters/types';\n\n/** Options for `createChildrenLayer`. */\nexport interface CreateChildrenLayerOpts<TData> {\n  /** Layer id for the visibility/order map. Default `'children'`. */\n  id?: string;\n  /** Human-readable label. Default `'Children'`. */\n  label?: string;\n  /** Source of `getChildren`. Only the read side is used. */\n  adapter: Pick<OrderedAdapter, 'getChildren'>;\n  /** Parent id (null = root). Function form lets the layer follow a moving\n   *  selection or focus. Default `null`. */\n  parentId?: string | null | (() => string | null);\n  /** Draw one child. Called once per id in z-order (bottom → top). The\n   *  per-child outputs are concatenated into the layer's `DrawCommand[]`. */\n  drawChild(id: string, data: TData, view: View): DrawCommand[];\n  /** Forwarded to the produced `RenderLayer`. */\n  defaultVisible?: boolean;\n  /** Forwarded to the produced `RenderLayer`. */\n  alwaysOn?: boolean;\n}\n\n/** Build a `RenderLayer` that draws an `OrderedAdapter`'s children in z-order. */\nexport function createChildrenLayer<TData = unknown>(\n  opts: CreateChildrenLayerOpts<TData>,\n): RenderLayer<TData> {\n  return {\n    id: opts.id ?? 'children',\n    label: opts.label ?? 'Children',\n    defaultVisible: opts.defaultVisible,\n    alwaysOn: opts.alwaysOn,\n    draw: (data, view) => {\n      const getChildren = opts.adapter.getChildren;\n      if (!getChildren) return [];\n      const parent =\n        typeof opts.parentId === 'function'\n          ? opts.parentId()\n          : opts.parentId ?? null;\n      const ids = getChildren(parent);\n      const out: DrawCommand[] = [];\n      for (const id of ids) {\n        const sub = opts.drawChild(id, data, view);\n        for (const cmd of sub) out.push(cmd);\n      }\n      return out;\n    },\n  };\n}\n"],"mappings":";AAwCA,SAAgBA,EACd,GACoB;CACpB,OAAO;EACL,IAAIC,EAAK,MAAM;EACf,OAAOA,EAAK,SAAS;EACrB,gBAAgBA,EAAK;EACrB,UAAUA,EAAK;EACf,OAAO,GAAM,MAAS;GACpB,IAAMC,IAAcD,EAAK,QAAQ;GACjC,IAAI,CAACC,GAAa,OAAO,CAAC;GAK1B,IAAMC,IAAMD,EAHV,OAAOD,EAAK,YAAa,aACrBA,EAAK,SAAS,IACdA,EAAK,YAAY,IACO,GACxBG,IAAqB,CAAC;GAC5B,KAAK,IAAMC,KAAMF,GAAK;IACpB,IAAMG,IAAML,EAAK,UAAUI,GAAIE,GAAMC,CAAI;IACzC,KAAK,IAAMC,KAAOH,GAAK,EAAI,KAAKG,CAAG;GACrC;GACA,OAAOL;EACT;CACF;AACF"}

package/dist/features/groups/composePose.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"composePose.js","names":["composeRectPose","child","parent","translateRectPose","pose","dx","dy","decomposeRectPose","world","turn","c","r","s","cx","x","y","cy","composeRigidPose","pr","wcx","wcy","decomposeRigidPose","ux","uy","RECT_POSE_COMPOSITION","RIGID_POSE_COMPOSITION","worldPoseLookup","composeWorldPose","adapter","id","compose","IDENTITY_POSE_COMPOSITION","frameAtOrAbove","rebaseLocalPose"],"sources":["../../../src/features/groups/composePose.ts"],"sourcesContent":["/**\n * Pose composition for hierarchical scene graphs.\n *\n * As of the nesting change, `getPose(id)` on adapters returns the\n * **local** pose — relative to the object's direct parent. Anything in the\n * kit that needs to draw, hit-test, snap, or otherwise reason about world\n * coordinates routes through `composeWorldPose`, which walks the parent\n * chain and folds local poses together via a consumer-supplied `compose`.\n *\n * Pose shape is generic, so the compose strategy is too. For the common\n * `{x, y, width, height}` axis-aligned rect, use `composeRectPose` —\n * translation only, child dimensions preserved. Custom pose shapes (paths,\n * matrix transforms) supply their own.\n *\n * The inverse — `rebaseLocalPose` — converts a world-space pose into a\n * local pose under a target parent. Used when reparenting so the visual\n * world position of a child is preserved across the parent change.\n */\n\n/** Re-exported; the declaration lives in `core/scene/types.ts`, which names\n *  it and may not import from features. */\nimport type { RectPose } from 'core/scene/types';\nexport type { RectPose };\n\n/** Re-exported from `core/scene/composeFrame.ts`, for the same reason. */\nimport {\n  IDENTITY_POSE_COMPOSITION,\n  composeWorldPose,\n  frameAtOrAbove,\n  rebaseLocalPose,\n  type PoseAdapter,\n  type PoseClosure,\n  type PoseComposition,\n} from 'core/scene/composeFrame';\nexport { IDENTITY_POSE_COMPOSITION, composeWorldPose, frameAtOrAbove, rebaseLocalPose };\nexport type { PoseAdapter, PoseClosure, PoseComposition };\n\n/**\n * Default `compose` for axis-aligned rectangles. Adds translation; preserves\n * child width/height. Treat as the canonical compose for any\n * `{x, y, width, height}` pose under a translation-only hierarchy.\n *\n * Generic over the concrete pose type so callers with a wider pose\n * (e.g. `RectPose & { rotation }`) can pass it through; the extra fields\n * are taken from the child unchanged.\n */\nexport function composeRectPose<TPose extends RectPose>(parent: TPose, child: TPose): TPose {\n  return {\n    ...child,\n    x: parent.x + child.x,\n    y: parent.y + child.y,\n  };\n}\n\n/**\n * Translate a `RectPose`-shaped pose by `(dx, dy)`. Suitable as the default\n * `translatePose` for `useMove` when poses carry top-level `x`/`y`. Other\n * fields (width/height, plus any extra props on `TPose`) are preserved.\n */\nexport function translateRectPose<TPose extends RectPose>(pose: TPose, dx: number, dy: number): TPose {\n  return { ...pose, x: pose.x + dx, y: pose.y + dy };\n}\n\n/** Inverse of `composeRectPose` — subtracts parent translation. */\nexport function decomposeRectPose<TPose extends RectPose>(parent: TPose, world: TPose): TPose {\n  return {\n    ...world,\n    x: world.x - parent.x,\n    y: world.y - parent.y,\n  };\n}\n\n/** Turn `(x, y)` about `(cx, cy)` by `r` radians. */\nfunction turn(cx: number, cy: number, r: number, x: number, y: number): [number, number] {\n  const c = Math.cos(r);\n  const s = Math.sin(r);\n  return [cx + (x - cx) * c - (y - cy) * s, cy + (x - cx) * s + (y - cy) * c];\n}\n\n/**\n * `compose` for a container whose pose defines a **frame**: the child's local\n * pose is offset into the parent's unrotated box, then the whole thing is\n * turned about the parent's center. Rotations add; the child keeps its size.\n *\n * Reduces to `composeRectPose` when the parent is upright, so a scene that\n * never rotates a container behaves identically under either strategy.\n *\n * Exact for translation and rotation. A parent carrying scale is outside what\n * this can express — see `PoseClosure`.\n */\nexport function composeRigidPose<TPose extends RectPose>(parent: TPose, child: TPose): TPose {\n  const pr = parent.rotation ?? 0;\n  const [wcx, wcy] = turn(\n    parent.x + parent.width / 2,\n    parent.y + parent.height / 2,\n    pr,\n    parent.x + child.x + child.width / 2,\n    parent.y + child.y + child.height / 2,\n  );\n  return {\n    ...child,\n    x: wcx - child.width / 2,\n    y: wcy - child.height / 2,\n    rotation: (child.rotation ?? 0) + pr,\n  };\n}\n\n/** Inverse of `composeRigidPose` — un-turns about the parent's center, then\n *  subtracts the parent's offset. */\nexport function decomposeRigidPose<TPose extends RectPose>(parent: TPose, world: TPose): TPose {\n  const pr = parent.rotation ?? 0;\n  const [ux, uy] = turn(\n    parent.x + parent.width / 2,\n    parent.y + parent.height / 2,\n    -pr,\n    world.x + world.width / 2,\n    world.y + world.height / 2,\n  );\n  return {\n    ...world,\n    x: ux - parent.x - world.width / 2,\n    y: uy - parent.y - world.height / 2,\n    rotation: (world.rotation ?? 0) - pr,\n  };\n}\n\n/** Translation-only composition over `RectPose`. What a scene wants when a\n *  container groups its children but never turns them. */\nexport const RECT_POSE_COMPOSITION: PoseComposition<RectPose> = {\n  compose: composeRectPose,\n  decompose: decomposeRectPose,\n  closure: 'translation',\n};\n\n/** Composition over `RectPose` where a container's pose is a frame: rotating\n *  the container rotates its contents. */\nexport const RIGID_POSE_COMPOSITION: PoseComposition<RectPose> = {\n  compose: composeRigidPose,\n  decompose: decomposeRigidPose,\n  closure: 'rigid',\n};\n\n/**\n * Build a `(id) => world pose | null` callback over a `PoseAdapter`.\n * Convenience for RenderLayers that take a `getPose` callback (selection\n * overlays, debug layers, etc.) so consumers don't hand-write a\n * `composeWorldPose` call per layer.\n *\n * Returns `null` when `adapter.getPose` or `adapter.getParent` throws — the\n * common case is an id removed mid-render between selection state and the\n * next paint. Layers should treat `null` as \"skip this id.\"\n */\nexport function worldPoseLookup<TPose>(\n  adapter: PoseAdapter<TPose>,\n  compose: (parent: TPose, child: TPose) => TPose,\n): (id: string) => TPose | null {\n  return (id: string) => {\n    try {\n      return composeWorldPose(adapter, id, compose);\n    } catch {\n      return null;\n    }\n  };\n}\n"],"mappings":";;AA8CA,SAAgBA,EAAwC,GAAe,GAAqB;CAC1F,OAAO;EACL,GAAGC;EACH,GAAGC,EAAO,IAAID,EAAM;EACpB,GAAGC,EAAO,IAAID,EAAM;CACtB;AACF;AAOA,SAAgBE,EAA0C,GAAa,GAAY,GAAmB;CACpG,OAAO;EAAE,GAAGC;EAAM,GAAGA,EAAK,IAAIC;EAAI,GAAGD,EAAK,IAAIE;CAAG;AACnD;AAGA,SAAgBC,EAA0C,GAAe,GAAqB;CAC5F,OAAO;EACL,GAAGC;EACH,GAAGA,EAAM,IAAIN,EAAO;EACpB,GAAGM,EAAM,IAAIN,EAAO;CACtB;AACF;AAGA,SAASO,EAAK,GAAY,GAAY,GAAW,GAAW,GAA6B;CACvF,IAAMC,IAAI,KAAK,IAAIC,CAAC,GACdC,IAAI,KAAK,IAAID,CAAC;CACpB,OAAO,CAACE,KAAMC,IAAID,KAAMH,KAAKK,IAAIC,KAAMJ,GAAGI,KAAMF,IAAID,KAAMD,KAAKG,IAAIC,KAAMN,CAAC;AAC5E;AAaA,SAAgBO,EAAyC,GAAe,GAAqB;CAC3F,IAAMC,IAAKhB,EAAO,YAAY,GACxB,CAACiB,GAAKC,KAAOX,EACjBP,EAAO,IAAIA,EAAO,QAAQ,GAC1BA,EAAO,IAAIA,EAAO,SAAS,GAC3BgB,GACAhB,EAAO,IAAID,EAAM,IAAIA,EAAM,QAAQ,GACnCC,EAAO,IAAID,EAAM,IAAIA,EAAM,SAAS,CACtC;CACA,OAAO;EACL,GAAGA;EACH,GAAGkB,IAAMlB,EAAM,QAAQ;EACvB,GAAGmB,IAAMnB,EAAM,SAAS;EACxB,WAAWA,EAAM,YAAY,KAAKiB;CACpC;AACF;AAIA,SAAgBG,EAA2C,GAAe,GAAqB;CAC7F,IAAMH,IAAKhB,EAAO,YAAY,GACxB,CAACoB,GAAIC,KAAMd,EACfP,EAAO,IAAIA,EAAO,QAAQ,GAC1BA,EAAO,IAAIA,EAAO,SAAS,GAC3B,CAACgB,GACDV,EAAM,IAAIA,EAAM,QAAQ,GACxBA,EAAM,IAAIA,EAAM,SAAS,CAC3B;CACA,OAAO;EACL,GAAGA;EACH,GAAGc,IAAKpB,EAAO,IAAIM,EAAM,QAAQ;EACjC,GAAGe,IAAKrB,EAAO,IAAIM,EAAM,SAAS;EAClC,WAAWA,EAAM,YAAY,KAAKU;CACpC;AACF;AAIA,IAAaM,IAAmD;CAC9D,SAASxB;CACT,WAAWO;CACX,SAAS;AACX,GAIakB,IAAoD;CAC/D,SAASR;CACT,WAAWI;CACX,SAAS;AACX;AAYA,SAAgBK,EACd,GACA,GAC8B;CAC9B,QAAQ,MAAe;EACrB,IAAI;GACF,OAAOC,EAAiBC,GAASC,GAAIC,CAAO;EAC9C,QAAQ;GACN,OAAO;EACT;CACF;AACF"}

package/dist/features/groups/nestedHit.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"nestedHit.js","names":["nestedHitTester","d","opts","AUTO_POSE_DESCRIPTOR","isGroup","worldOf","worldPoseLookup","adapter","ancestorChain","chain","cur","id","hitLeaf","objs","i","o","w","b","poseDescriptorForNode","wx","wy","leaf","alt","selection"],"sources":["../../../src/features/groups/nestedHit.ts"],"sourcesContent":["import { worldPoseLookup } from './composePose';\nimport { poseDescriptorForNode, type PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport { AUTO_POSE_DESCRIPTOR } from 'interactions/actions/resize/autoPoseDescriptor';\n\n/** @internal */\ninterface HitAdapter<TNode extends { id: string }, TPose> {\n  getNode: (id: string) => TNode | undefined;\n  getNodes: () => TNode[];\n  getPose: (id: string) => TPose;\n  getParent: (id: string) => string | null;\n}\n\n/** Options for `nestedHitTester`. */\nexport interface NestedHitOpts<TNode extends { id: string }, TPose> {\n  /** Compose a child's local pose into world coords given its parent's world\n   *  pose. Same shape as `composeRectPose` (the default expectation). */\n  composePose: (parent: TPose, child: TPose) => TPose;\n  /** How to read world poses. Default `AUTO_POSE_DESCRIPTOR`. */\n  poseDescriptor?: PoseDescriptor<TPose>;\n  /** Predicate for \"this object is a nesting parent body\". The leaf scan\n   *  skips objects for which this returns true so a click on a parent's\n   *  painted body resolves to a child leaf, not the parent itself. Default:\n   *  never (treat every object as hittable). */\n  isGroup?: (id: string, obj: TNode | undefined) => boolean;\n}\n\n/** Hit-test entry points for a nested scene: one that always picks the\n *  outermost ancestor, and one that steps deeper on alt-click. */\nexport interface NestedHitTester {\n  /** Outermost-ancestor pick. Suitable as the chrome-level `pickEvery`: a\n   *  casual click selects the whole top-level ancestor. Returns `null` on\n   *  empty space. */\n  pickOutermost: (worldX: number, worldY: number) => string | null;\n  /** Alt-aware selection-update pick. Without `alt`, returns the outermost\n   *  ancestor (same as `pickOutermost`). With `alt`, returns one level\n   *  deeper than the deepest currently-selected ancestor in the leaf's\n   *  chain — repeated alt-clicks step ancestor → descendant → leaf. With\n   *  `alt` and nothing in the chain selected, jumps straight to the leaf.\n   *  Plug into `useSelectTool({ pickBest })`. */\n  pickBest: (\n    worldX: number,\n    worldY: number,\n    alt: boolean,\n    selection: readonly string[],\n  ) => string | null;\n}\n\n/** Build hit-testers that respect containers: a plain click selects the\n *  top-level ancestor, and alt-clicking descends one level at a time toward\n *  the leaf actually under the pointer. */\nexport function nestedHitTester<TNode extends { id: string }, TPose>(\n  adapter: HitAdapter<TNode, TPose>,\n  opts: NestedHitOpts<TNode, TPose>,\n): NestedHitTester {\n  const d = (opts.poseDescriptor ?? AUTO_POSE_DESCRIPTOR) as PoseDescriptor<TPose>;\n  const isGroup = opts.isGroup ?? (() => false);\n  const worldOf = worldPoseLookup(adapter, opts.composePose);\n\n  const ancestorChain = (id: string): string[] => {\n    const chain: string[] = [];\n    let cur: string | null = id;\n    while (cur !== null) {\n      chain.unshift(cur);\n      cur = adapter.getParent(cur);\n    }\n    return chain;\n  };\n\n  const hitLeaf = (wx: number, wy: number): string | null => {\n    const objs = adapter.getNodes();\n    for (let i = objs.length - 1; i >= 0; i--) {\n      const o = objs[i];\n      if (isGroup(o.id, o)) continue;\n      const w = worldOf(o.id);\n      if (!w) continue;\n      const b = poseDescriptorForNode(d, o).getBounds(w);\n      if (wx >= b.x && wx <= b.x + b.width && wy >= b.y && wy <= b.y + b.height) {\n        return o.id;\n      }\n    }\n    return null;\n  };\n\n  const pickOutermost = (wx: number, wy: number): string | null => {\n    const leaf = hitLeaf(wx, wy);\n    return leaf === null ? null : ancestorChain(leaf)[0];\n  };\n\n  const pickBest = (\n    wx: number,\n    wy: number,\n    alt: boolean,\n    selection: readonly string[],\n  ): string | null => {\n    const leaf = hitLeaf(wx, wy);\n    if (leaf === null) return null;\n    const chain = ancestorChain(leaf);\n    if (!alt) return chain[0];\n    for (let i = chain.length - 1; i >= 0; i--) {\n      if (selection.includes(chain[i])) {\n        return chain[Math.min(i + 1, chain.length - 1)];\n      }\n    }\n    return chain[chain.length - 1];\n  };\n\n  return { pickOutermost, pickBest };\n}\n"],"mappings":";;;;AAkDA,SAAgBA,EACd,GACA,GACiB;CACjB,IAAMC,IAAKC,EAAK,kBAAkBC,GAC5BC,IAAUF,EAAK,kBAAkB,KACjCG,IAAUC,EAAgBC,GAASL,EAAK,WAAW,GAEnDM,KAAiB,MAAyB;EAC9C,IAAMC,IAAkB,CAAC,GACrBC,IAAqBC;EACzB,OAAOD,MAAQ,OAEb,AADAD,EAAM,QAAQC,CAAG,GACjB,IAAMH,EAAQ,UAAUG,CAAG;EAE7B,OAAOD;CACT,GAEMG,KAAW,GAAY,MAA8B;EACzD,IAAMC,IAAON,EAAQ,SAAS;EAC9B,KAAK,IAAIO,IAAID,EAAK,SAAS,GAAGC,KAAK,GAAG,KAAK;GACzC,IAAMC,IAAIF,EAAKC;GACf,IAAIV,EAAQW,EAAE,IAAIA,CAAC,GAAG;GACtB,IAAMC,IAAIX,EAAQU,EAAE,EAAE;GACtB,IAAI,CAACC,GAAG;GACR,IAAMC,IAAIC,EAAsBjB,GAAGc,CAAC,CAAC,CAAC,UAAUC,CAAC;GACjD,IAAIG,KAAMF,EAAE,KAAKE,KAAMF,EAAE,IAAIA,EAAE,SAASG,KAAMH,EAAE,KAAKG,KAAMH,EAAE,IAAIA,EAAE,QACjE,OAAOF,EAAE;EAEb;EACA,OAAO;CACT;CAyBA,OAAO;EAAE,gBAvBc,GAAY,MAA8B;GAC/D,IAAMM,IAAOT,EAAQO,GAAIC,CAAE;GAC3B,OAAOC,MAAS,OAAO,OAAOb,EAAca,CAAI,CAAC,CAAC;EACpD;EAoBwB,WAjBtB,GACA,GACA,GACA,MACkB;GAClB,IAAMA,IAAOT,EAAQO,GAAIC,CAAE;GAC3B,IAAIC,MAAS,MAAM,OAAO;GAC1B,IAAMZ,IAAQD,EAAca,CAAI;GAChC,IAAI,CAACC,GAAK,OAAOb,EAAM;GACvB,KAAK,IAAIK,IAAIL,EAAM,SAAS,GAAGK,KAAK,GAAG,KACrC,IAAIS,EAAU,SAASd,EAAMK,EAAE,GAC7B,OAAOL,EAAM,KAAK,IAAIK,IAAI,GAAGL,EAAM,SAAS,CAAC;GAGjD,OAAOA,EAAMA,EAAM,SAAS;EAC9B;CAEiC;AACnC"}

package/dist/features/groups/unionOfChildren.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"unionOfChildren.js","names":["unionOfChildrenVia","boxes","d","deps","visualBoundsViaDescriptor","poseDescriptorForNode","descriptor","u","unionAABB","node"],"sources":["../../../src/features/groups/unionOfChildren.ts"],"sourcesContent":["import { unionAABB } from 'core/geometry/unionBounds';\nimport {\n  poseDescriptorForNode,\n  visualBoundsViaDescriptor,\n  type PoseDescriptor,\n} from 'interactions/actions/resize/geometry';\nimport type { DerivePoseFn } from 'core/scene/types';\n\n/**\n * A container's pose as the envelope of what it holds, read through\n * `descriptor` — a rotated member contributes the extent of its ink. Register\n * the result under `UNION_OF_CHILDREN` in `createScene`'s `registry` to teach\n * a scene how to size its groups around a pose shape the kit cannot read.\n *\n * Returns `null` for an emptied container, which falls back to its authored\n * pose rather than collapsing to a zero box at the origin.\n */\nexport function unionOfChildrenVia<TPose>(\n  descriptor: PoseDescriptor<TPose>,\n): DerivePoseFn<TPose> {\n  return (node, deps) => {\n    const boxes = [];\n    for (const d of deps) {\n      if (d !== undefined) {\n        boxes.push(visualBoundsViaDescriptor(d.pose, poseDescriptorForNode(descriptor, d)));\n      }\n    }\n    const u = unionAABB(boxes);\n    return u === null\n      ? null\n      : poseDescriptorForNode(descriptor, node).fromBounds(u, node.pose);\n  };\n}\n"],"mappings":";;;AAiBA,SAAgBA,EACd,GACqB;CACrB,QAAQ,GAAM,MAAS;EACrB,IAAMC,IAAQ,CAAC;EACf,KAAK,IAAMC,KAAKC,GACd,AAAID,MAAM,KAAA,KACRD,EAAM,KAAKG,EAA0BF,EAAE,MAAMG,EAAsBC,GAAYJ,CAAC,CAAC,CAAC;EAGtF,IAAMK,IAAIC,EAAUP,CAAK;EACzB,OAAOM,MAAM,OACT,OACAF,EAAsBC,GAAYG,CAAI,CAAC,CAAC,WAAWF,GAAGE,EAAK,IAAI;CACrE;AACF"}

package/dist/features/images/imageCache.js

@@ -1,104 +0,0 @@
-import { maxImageTextureSide as e, releaseImageSource as t } from "../../renderer/cache/GLImageCache.js";
-//#region src/features/images/imageCache.ts
-var n = 16777216, r = 4, i = 300, a = 150, o = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Set(), c = /* @__PURE__ */ new Map();
-function l(e) {
-	return /^data:image\/svg\+xml[;,]/i.test(e) ? !0 : !/^(data|blob):/i.test(e) && /\.svgz?$/i.test(e.replace(/[?#].*$/, ""));
-}
-function u() {
-	if (typeof Image > "u" || typeof createImageBitmap > "u") throw Error("weasel imageCache: no DOM image loader in this environment");
-}
-async function d(e) {
-	let t = new Image();
-	return t.crossOrigin = "anonymous", t.src = e, await t.decode(), t;
-}
-function f(e) {
-	let t = c.get(e);
-	return t || (t = d(e), c.set(e, t), t.catch(() => c.delete(e))), t;
-}
-async function p(e, t) {
-	let n = await f(e), r = t?.width ?? (n.naturalWidth || i), o = t?.height ?? (n.naturalHeight || a), s = typeof OffscreenCanvas < "u" ? new OffscreenCanvas(r, o) : Object.assign(document.createElement("canvas"), {
-		width: r,
-		height: o
-	}), c = s.getContext("2d");
-	if (!c) throw Error("weasel imageCache: no 2D context to rasterize an SVG");
-	return c.drawImage(n, 0, 0, r, o), createImageBitmap(s);
-}
-var m = async (e, t) => (u(), l(e) ? p(e, t) : createImageBitmap(await d(e)));
-function h() {
-	for (let e of s) e();
-}
-function g(e) {
-	let t = { status: "loading" };
-	o.set(e, t), m(e).then((n) => {
-		o.get(e) === t && (o.set(e, {
-			status: "ready",
-			bitmap: n,
-			...l(e) ? { vector: {
-				natural: {
-					width: n.width,
-					height: n.height
-				},
-				scale: 1,
-				failed: /* @__PURE__ */ new Set(),
-				floor: 0
-			} } : {}
-		}), h());
-	}, () => {
-		o.get(e) === t && (o.set(e, { status: "error" }), h());
-	});
-}
-function _(t, r) {
-	let i = Math.max(r.width / t.width, r.height / t.height);
-	if (!(i > 0) || !Number.isFinite(i)) return;
-	let a = e(), o = Math.min(a / t.width, a / t.height, Math.sqrt(n / (t.width * t.height)));
-	return Math.min(2 ** Math.ceil(Math.log2(i)), o);
-}
-function v(e, n, i, a) {
-	if (i.pending !== void 0) return;
-	let s = _(i.natural, a);
-	if (s === void 0) return;
-	let c = s > i.scale;
-	c && i.shrunkTo === i.scale && (i.floor = Math.max(i.floor, s));
-	let l = c ? s : Math.max(s, i.floor);
-	if (!(!c && l * r > i.scale)) {
-		for (let e of i.failed) if (l === e || c && e > i.scale && l >= e) return;
-		i.pending = l, m(e, {
-			width: Math.max(1, Math.round(i.natural.width * l)),
-			height: Math.max(1, Math.round(i.natural.height * l))
-		}).then((r) => {
-			if (o.get(e) !== n) return;
-			i.pending = void 0;
-			let a = n.bitmap;
-			n.bitmap = r, i.shrunkTo = c ? void 0 : l, i.scale = l, a && a !== r && t(a), h();
-		}, () => {
-			o.get(e) === n && (i.pending = void 0, i.failed.add(l));
-		});
-	}
-}
-function y(e, t) {
-	let n = o.get(e);
-	if (!n) {
-		g(e);
-		return;
-	}
-	return t && n.vector && v(e, n, n.vector, t), n.bitmap;
-}
-function b(e) {
-	return o.get(e)?.status ?? "idle";
-}
-function x(e) {
-	let n = o.get(e);
-	o.delete(e), c.delete(e), n?.bitmap && t(n.bitmap);
-}
-function S(e) {
-	o.get(e)?.status === "error" && (g(e), h());
-}
-function C(e) {
-	return s.add(e), () => {
-		s.delete(e);
-	};
-}
-//#endregion
-export { y as getImageBitmap, b as imageStatus, l as isVectorImageSrc, x as releaseImage, S as retryImage, C as subscribeImageReady };
-
-//# sourceMappingURL=imageCache.js.map

package/dist/features/images/imageCache.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"imageCache.js","names":["MAX_VECTOR_RASTER_PIXELS","SHRINK_SLACK","FALLBACK_WIDTH","FALLBACK_HEIGHT","cache","subscribers","decodedVectors","isVectorImageSrc","src","requireDom","decodeImage","img","decodeVector","decoded","rasterizeVector","width","size","height","canvas","c2d","loader","notify","cb","startLoad","entry","bitmap","rasterScaleFor","need","drawnAt","natural","side","maxImageTextureSide","cap","maybeReraster","v","wanted","grow","target","f","old","releaseImageSource","getImageBitmap","imageStatus","releaseImage","retryImage","subscribeImageReady"],"sources":["../../../src/features/images/imageCache.ts"],"sourcesContent":["/**\n * imageCache — the kit's per-`src` image loader + cache.\n *\n * The shape-painter chain (`kit:image` in `NodeShape.ts`) is synchronous, but\n * decoding an image is async. This module bridges the two: `getImageBitmap` is\n * a synchronous read that returns the decoded `ImageBitmap` when ready, and\n * otherwise returns `undefined` and lazily kicks off a de-duped async load.\n * When a load resolves (or errors), every `subscribeImageReady` listener fires\n * — `<SceneCanvas>` subscribes and calls `requestRedraw()`, so the painter\n * re-runs and emits the now-ready bitmap.\n *\n * `src` is any browser-loadable image string: a remote URL, a `blob:` URL, or\n * a `data:image/…;base64,…` URI (the embedded-bytes path). The decoded bitmap\n * lives only here, keyed by `src` — never in node `data` — so `scene.toJSON()`\n * round-trips the (serializable) `src` string untouched.\n */\n\nimport { maxImageTextureSide, releaseImageSource } from 'renderer/cache/GLImageCache';\n\n/** Public shape of an image node's `data`. `src` round-trips through\n *  serialization; the decoded bitmap is held in this cache, not on the node. */\nexport interface ImageNodeData {\n  image: {\n    src: string;\n    opacity?: number;\n    /** The part of the bitmap drawn into the pose rect, as fractions of the\n     *  bitmap's width and height from its top-left. Omitted draws the whole\n     *  bitmap. Fractions, so the data means the same thing before the bitmap\n     *  has decoded and after `src` is swapped for another resolution. */\n    source?: { x: number; y: number; width: number; height: number };\n    /** Mirror the drawn region within the pose rect. The rect does not move. */\n    flipX?: boolean;\n    flipY?: boolean;\n  };\n}\n\n/** Where an image is in its load: never requested, in flight, decoded, or\n *  failed. Renderers paint a placeholder for anything but `'ready'`. */\nexport type ImageStatus = 'idle' | 'loading' | 'ready' | 'error';\n\n/** A size in device pixels. */\nexport interface ImageRasterSize {\n  width: number;\n  height: number;\n}\n\n/** A vector source's raster bookkeeping. `scale` is the current raster's size\n *  over the natural one, always a power of two unless a cap cut it short. */\ninterface VectorRaster {\n  natural: ImageRasterSize;\n  scale: number;\n  pending?: number;\n  failed: Set<number>;\n  /** The scale the last shrink left, until something asks for more. */\n  shrunkTo?: number;\n  /** The largest scale a shrunk raster was asked to grow back to. One raster\n   *  serves every size a source is drawn at, so that request may be a second\n   *  consumer the shrink starved; shrinking below it again would loop. */\n  floor: number;\n}\n\ninterface Entry {\n  status: ImageStatus;\n  bitmap?: ImageBitmap;\n  vector?: VectorRaster;\n}\n\n/** `size` is absent for the first load, which decodes at natural size. */\ntype Loader = (src: string, size?: ImageRasterSize) => Promise<ImageBitmap>;\n\n/** One vector raster may hold at most 64MB of RGBA. */\nconst MAX_VECTOR_RASTER_PIXELS = 4096 * 4096;\n/** A raster is only shrunk once it is this many times larger than needed, so\n *  zooming back and forth across a bucket edge does not re-raster each way. */\nconst SHRINK_SLACK = 4;\n// CSS default object size, as `kit:svg` measures a viewBox-only SVG.\nconst FALLBACK_WIDTH = 300;\nconst FALLBACK_HEIGHT = 150;\n\nconst cache = new Map<string, Entry>();\nconst subscribers = new Set<() => void>();\nconst decodedVectors = new Map<string, Promise<HTMLImageElement>>();\n\n/** True when `src` names SVG — a `data:image/svg+xml` URI, or a URL whose path\n *  ends in `.svg`/`.svgz`. Such sources re-rasterize at the size they are drawn\n *  at; everything else decodes once. A `blob:` URL carries no type and counts\n *  as raster. */\nexport function isVectorImageSrc(src: string): boolean {\n  if (/^data:image\\/svg\\+xml[;,]/i.test(src)) return true;\n  if (/^(data|blob):/i.test(src)) return false;\n  return /\\.svgz?$/i.test(src.replace(/[?#].*$/, ''));\n}\n\nfunction requireDom(): void {\n  if (typeof Image === 'undefined' || typeof createImageBitmap === 'undefined') {\n    throw new Error('weasel imageCache: no DOM image loader in this environment');\n  }\n}\n\nasync function decodeImage(src: string): Promise<HTMLImageElement> {\n  const img = new Image();\n  img.crossOrigin = 'anonymous';\n  img.src = src;\n  await img.decode();\n  return img;\n}\n\nfunction decodeVector(src: string): Promise<HTMLImageElement> {\n  let decoded = decodedVectors.get(src);\n  if (!decoded) {\n    decoded = decodeImage(src);\n    decodedVectors.set(src, decoded);\n    decoded.catch(() => decodedVectors.delete(src));\n  }\n  return decoded;\n}\n\n// `createImageBitmap` rejects SVG blobs and resamples an SVG `<img>` rather\n// than re-drawing it, so vectors go through a canvas `drawImage` at full size.\nasync function rasterizeVector(src: string, size?: ImageRasterSize): Promise<ImageBitmap> {\n  const img = await decodeVector(src);\n  const width = size?.width ?? (img.naturalWidth || FALLBACK_WIDTH);\n  const height = size?.height ?? (img.naturalHeight || FALLBACK_HEIGHT);\n  const canvas: OffscreenCanvas | HTMLCanvasElement = typeof OffscreenCanvas !== 'undefined'\n    ? new OffscreenCanvas(width, height)\n    : Object.assign(document.createElement('canvas'), { width, height });\n  const c2d = canvas.getContext('2d') as CanvasDrawImage | null;\n  if (!c2d) throw new Error('weasel imageCache: no 2D context to rasterize an SVG');\n  c2d.drawImage(img, 0, 0, width, height);\n  return createImageBitmap(canvas);\n}\n\nconst defaultLoader: Loader = async (src, size) => {\n  requireDom();\n  if (isVectorImageSrc(src)) return rasterizeVector(src, size);\n  return createImageBitmap(await decodeImage(src));\n};\n\nlet loader: Loader = defaultLoader;\n\nfunction notify(): void {\n  for (const cb of subscribers) cb();\n}\n\nfunction startLoad(src: string): void {\n  const entry: Entry = { status: 'loading' };\n  cache.set(src, entry);\n  loader(src).then(\n    (bitmap) => {\n      // The entry may have been replaced/cleared mid-flight (reset, etc.);\n      // only commit if this src is still the one we started loading.\n      if (cache.get(src) !== entry) return;\n      cache.set(src, {\n        status: 'ready',\n        bitmap,\n        ...(isVectorImageSrc(src)\n          ? { vector: { natural: { width: bitmap.width, height: bitmap.height }, scale: 1, failed: new Set<number>(), floor: 0 } }\n          : {}),\n      });\n      notify();\n    },\n    () => {\n      // Cache the error so a broken `src` doesn't reload-storm.\n      if (cache.get(src) !== entry) return;\n      cache.set(src, { status: 'error' });\n      notify();\n    },\n  );\n}\n\n/** The raster scale `drawnAt` calls for: the next power of two at or above the\n *  natural-to-drawn ratio, capped by texture size and the pixel ceiling. */\nfunction rasterScaleFor(natural: ImageRasterSize, drawnAt: ImageRasterSize): number | undefined {\n  const need = Math.max(drawnAt.width / natural.width, drawnAt.height / natural.height);\n  if (!(need > 0) || !Number.isFinite(need)) return undefined;\n  const side = maxImageTextureSide();\n  const cap = Math.min(\n    side / natural.width,\n    side / natural.height,\n    Math.sqrt(MAX_VECTOR_RASTER_PIXELS / (natural.width * natural.height)),\n  );\n  return Math.min(2 ** Math.ceil(Math.log2(need)), cap);\n}\n\nfunction maybeReraster(src: string, entry: Entry, v: VectorRaster, drawnAt: ImageRasterSize): void {\n  if (v.pending !== undefined) return;\n  const wanted = rasterScaleFor(v.natural, drawnAt);\n  if (wanted === undefined) return;\n  const grow = wanted > v.scale;\n  if (grow && v.shrunkTo === v.scale) v.floor = Math.max(v.floor, wanted);\n  const target = grow ? wanted : Math.max(wanted, v.floor);\n  if (!grow && target * SHRINK_SLACK > v.scale) return;\n  for (const f of v.failed) if (target === f || (grow && f > v.scale && target >= f)) return;\n\n  v.pending = target;\n  const size = {\n    width: Math.max(1, Math.round(v.natural.width * target)),\n    height: Math.max(1, Math.round(v.natural.height * target)),\n  };\n  loader(src, size).then(\n    (bitmap) => {\n      if (cache.get(src) !== entry) return;\n      v.pending = undefined;\n      const old = entry.bitmap;\n      entry.bitmap = bitmap;\n      v.shrunkTo = grow ? undefined : target;\n      v.scale = target;\n      if (old && old !== bitmap) releaseImageSource(old);\n      notify();\n    },\n    () => {\n      // The previous raster keeps painting; only this scale is given up on.\n      if (cache.get(src) !== entry) return;\n      v.pending = undefined;\n      v.failed.add(target);\n    },\n  );\n}\n\n/** Synchronous read. Returns the decoded bitmap when ready; otherwise returns\n *  `undefined` and lazily starts a de-duped async load for `src`.\n *\n *  `drawnAt` is the size in device pixels the image is about to cover. A\n *  vector source ({@link isVectorImageSrc}) uses it to re-rasterize in\n *  power-of-two steps — the current raster is returned until the sharper one\n *  is ready. Raster sources ignore it. */\nexport function getImageBitmap(src: string, drawnAt?: ImageRasterSize): ImageBitmap | undefined {\n  const entry = cache.get(src);\n  if (!entry) {\n    startLoad(src);\n    return undefined;\n  }\n  if (drawnAt && entry.vector) maybeReraster(src, entry, entry.vector, drawnAt);\n  return entry.bitmap;\n}\n\n/** Current load status for `src` (`'idle'` if never requested). */\nexport function imageStatus(src: string): ImageStatus {\n  return cache.get(src)?.status ?? 'idle';\n}\n\n/**\n * Forget `src`: drop its decoded bitmap, its decoded SVG, and the texture every\n * live renderer holds for it, and abandon a load in flight. The cache is keyed\n * by `src` across every scene on the page, so it cannot know when the last use\n * is gone; whoever does know calls this. A later {@link getImageBitmap} for the\n * same `src` loads it again.\n */\nexport function releaseImage(src: string): void {\n  const entry = cache.get(src);\n  cache.delete(src);\n  decodedVectors.delete(src);\n  if (entry?.bitmap) releaseImageSource(entry.bitmap);\n}\n\n/** Load a `src` whose last load failed again. Does nothing for a `src` in any\n *  other state; one that failed otherwise stays `'error'` for the page's life. */\nexport function retryImage(src: string): void {\n  if (cache.get(src)?.status !== 'error') return;\n  startLoad(src);\n  notify();\n}\n\n/** Subscribe to load-resolution events (fires after any `src` resolves or\n *  errors). Returns an unsubscribe. */\nexport function subscribeImageReady(cb: () => void): () => void {\n  subscribers.add(cb);\n  return () => {\n    subscribers.delete(cb);\n  };\n}\n\n/** @internal test seam — override the async loader so unit tests don't need\n *  a real DOM image. Not part of the public barrel. */\nexport function __setImageLoaderForTests(fn: Loader): void {\n  loader = fn;\n}\n\n/** @internal test seam — clear cache + subscribers and restore the default\n *  loader. Not part of the public barrel. */\nexport function _resetImageCacheForTests(): void {\n  cache.clear();\n  subscribers.clear();\n  decodedVectors.clear();\n  loader = defaultLoader;\n}\n"],"mappings":"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"}

package/dist/features/ingestion/index.js

@@ -1,8 +0,0 @@
-import "./imageHandler.js";
-import "./svgHandler.js";
-import "./weaselJsonHandler.js";
-import { registerContentHandler as e } from "./contentHandlers.js";
-import { acquireKitContentHandlers as t } from "./registerKitHandlers.js";
-import { openFilePicker as n } from "./openFilePicker.js";
-import { itemsFromFiles as r } from "@weasel-js/routing";
-export { t as acquireKitContentHandlers, r as itemsFromFiles, n as openFilePicker, e as registerContentHandler };

package/dist/features/meshPaint/bake.js

@@ -1,79 +0,0 @@
-import { resolveColor as e } from "../../renderer/math/color.js";
-import { evalPatch as t, isValidPatch as n, patchBounds as r } from "./surface.js";
-import { lerpColorArray as i } from "@weasel-js/paint";
-//#region src/features/meshPaint/bake.ts
-var a = 256, o = 10;
-function s(e) {
-	return Math.max(24, Math.ceil(e / o));
-}
-function c(e) {
-	let t = Infinity, i = Infinity, a = -Infinity, o = -Infinity;
-	for (let s of e) {
-		if (!n(s)) continue;
-		let e = r(s);
-		t = Math.min(t, e.x), i = Math.min(i, e.y), a = Math.max(a, e.x + e.width), o = Math.max(o, e.y + e.height);
-	}
-	return !Number.isFinite(t) || a <= t || o <= i ? null : {
-		x: t,
-		y: i,
-		width: a - t,
-		height: o - i
-	};
-}
-function l(e, t, n, r) {
-	let a = i(e[0], e[1], t, r), o = i(e[3], e[2], t, r);
-	return i(a, o, n, r);
-}
-function u(r, i = "rgb", o = a) {
-	let u = c(r);
-	if (!u) return null;
-	let f = new Uint8ClampedArray(o * o * 4), p = s(o), m = (e) => ({
-		x: (e.x - u.x) / u.width * (o - 1) + .5,
-		y: (e.y - u.y) / u.height * (o - 1) + .5
-	});
-	for (let a of r) {
-		if (!n(a)) continue;
-		let r = a.colors.map((t) => e(t));
-		for (let e = 0; e < p; e++) for (let n = 0; n < p; n++) {
-			let s = e / p, c = (e + 1) / p, u = n / p, h = (n + 1) / p, g = [
-				{
-					at: m(t(a, s, u)),
-					color: l(r, s, u, i)
-				},
-				{
-					at: m(t(a, c, u)),
-					color: l(r, c, u, i)
-				},
-				{
-					at: m(t(a, c, h)),
-					color: l(r, c, h, i)
-				},
-				{
-					at: m(t(a, s, h)),
-					color: l(r, s, h, i)
-				}
-			];
-			d(f, o, g[0], g[1], g[2]), d(f, o, g[0], g[2], g[3]);
-		}
-	}
-	return {
-		pixels: f,
-		size: o,
-		box: u
-	};
-}
-function d(e, t, n, r, i) {
-	let a = Math.max(0, Math.floor(Math.min(n.at.x, r.at.x, i.at.x))), o = Math.min(t - 1, Math.ceil(Math.max(n.at.x, r.at.x, i.at.x))), s = Math.max(0, Math.floor(Math.min(n.at.y, r.at.y, i.at.y))), c = Math.min(t - 1, Math.ceil(Math.max(n.at.y, r.at.y, i.at.y)));
-	if (o < a || c < s) return;
-	let l = (r.at.x - n.at.x) * (i.at.y - n.at.y) - (i.at.x - n.at.x) * (r.at.y - n.at.y);
-	if (!(Math.abs(l) < 1e-9)) for (let u = s; u <= c; u++) for (let s = a; s <= o; s++) {
-		let a = s + .5, o = u + .5, c = ((r.at.x - a) * (i.at.y - o) - (i.at.x - a) * (r.at.y - o)) / l, d = ((i.at.x - a) * (n.at.y - o) - (n.at.x - a) * (i.at.y - o)) / l, f = 1 - c - d;
-		if (c < -1e-6 || d < -1e-6 || f < -1e-6) continue;
-		let p = (u * t + s) * 4;
-		for (let t = 0; t < 4; t++) e[p + t] = (c * n.color[t] + d * r.color[t] + f * i.color[t]) * 255;
-	}
-}
-//#endregion
-export { a as MESH_BAKE_SIZE, u as bakeMesh, c as meshBounds };
-
-//# sourceMappingURL=bake.js.map