@weasel-js/core 1.6.1 → 1.7.1

package/dist/core/ops/slot.js

@@ -0,0 +1,37 @@
+//#region src/core/ops/slot.ts
+function e(e, t, n) {
+	let r = e.getChildren?.(t);
+	if (!r) return null;
+	let i = r.indexOf(n);
+	return i < 0 ? null : {
+		index: i,
+		before: i + 1 < r.length ? r[i + 1] : null
+	};
+}
+function t(e, t) {
+	if (t.before !== null) {
+		if (t.before !== void 0 && e) {
+			let n = e.indexOf(t.before);
+			if (n >= 0) return n;
+		}
+		return t.index >= 0 ? t.index : void 0;
+	}
+}
+function n(e, t) {
+	if (!e.getChildren) return null;
+	let n = e.getParent ? e.getParent(t) : null, r = e.getChildren(n).indexOf(t);
+	return r < 0 ? null : {
+		parentId: n,
+		index: r
+	};
+}
+function r(e) {
+	return { index: e ?? -1 };
+}
+function i(e) {
+	return e.parent ?? null;
+}
+//#endregion
+export { e as captureSlot, n as locateChild, i as parentOf, t as resolveSlot, r as slotFromIndex };
+
+//# sourceMappingURL=slot.js.map

package/dist/core/ops/slot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slot.js","names":["captureSlot","siblings","a","parentId","id","resolveSlot","slot","at","locateChild","index","slotFromIndex","parentOf","node"],"sources":["../../../src/core/ops/slot.ts"],"sourcesContent":["/** Sibling-order read seam. Optional everywhere: a flat adapter has none. */\nexport interface OrderedReader {\n  getChildren?(parentId: string | null): string[];\n}\n\n/**\n * A node's position among its siblings, recorded so an op can put it back.\n *\n * Recorded as an anchor (`before`) plus an ordinal (`index`). The anchor is\n * the source of truth: `History` replays a batch's inverses in reverse order,\n * so an ordinal captured before the mutation is replayed against a list that\n * has not been refilled yet and clamps to the end, while \"put this back before\n * `e`\" stays true however much else has already moved. The ordinal is the\n * fallback for the cases the anchor cannot cover — an adapter with no\n * `getChildren` seam, or an anchor that is itself gone by replay time.\n */\nexport interface SiblingSlot {\n  /** Ordinal among the siblings. `-1` means \"nowhere in particular\". */\n  index: number;\n  /** Id of the sibling that followed at capture time; `null` when the node\n   *  was last. Absent when nothing observed it — `null` survives JSON and\n   *  `undefined` does not, so the two stay distinguishable across a\n   *  serialize/restore round trip. */\n  before?: string | null;\n}\n\n/** Observe `id`'s slot among `parentId`'s children. `null` when the adapter\n *  has no ordering seam or `id` isn't there — callers keep whatever weaker\n *  slot they already had rather than overwriting it with a guess. */\nexport function captureSlot(\n  a: OrderedReader,\n  parentId: string | null,\n  id: string,\n): SiblingSlot | null {\n  const siblings = a.getChildren?.(parentId);\n  if (!siblings) return null;\n  const i = siblings.indexOf(id);\n  if (i < 0) return null;\n  return { index: i, before: i + 1 < siblings.length ? siblings[i + 1]! : null };\n}\n\n/**\n * Index `slot` denotes in `siblings`, which must NOT contain the node being\n * placed. `undefined` means \"no position\" — the caller appends, or lets the\n * adapter's default placement stand.\n */\nexport function resolveSlot(\n  siblings: readonly string[] | undefined,\n  slot: SiblingSlot,\n): number | undefined {\n  if (slot.before === null) return undefined;\n  if (slot.before !== undefined && siblings) {\n    const at = siblings.indexOf(slot.before);\n    if (at >= 0) return at;\n  }\n  return slot.index >= 0 ? slot.index : undefined;\n}\n\n/** The reads that locate a live node: its parent, and that parent's children. */\nexport interface ParentedReader {\n  getParent?(id: string): string | null;\n  getChildren?(parentId: string | null): readonly string[];\n}\n\n/** A node's parent (`null` at the top level) and its ordinal among that\n *  parent's children — the position a replacement takes to keep its z-order. */\nexport interface ChildPosition {\n  parentId: string | null;\n  index: number;\n}\n\n/** Where `id` sits under its parent. An adapter with no `getParent` is flat,\n *  as the reorder ops read it. `null` when there is no `getChildren` or it\n *  does not list `id`. */\nexport function locateChild(a: ParentedReader, id: string): ChildPosition | null {\n  if (!a.getChildren) return null;\n  const parentId = a.getParent ? a.getParent(id) : null;\n  const index = a.getChildren(parentId).indexOf(id);\n  return index < 0 ? null : { parentId, index };\n}\n\n/** Normalize the `index` sugar every op factory accepts into a slot. */\nexport function slotFromIndex(index: number | undefined): SiblingSlot {\n  return { index: index ?? -1 };\n}\n\n/** The parent a node claims. Nodes in a flat adapter have none. */\nexport function parentOf(node: object): string | null {\n  return ((node as { parent?: unknown }).parent ?? null) as string | null;\n}\n"],"mappings":";AA6BA,SAAgBA,EACd,GACA,GACA,GACoB;CACpB,IAAMC,IAAWC,EAAE,cAAcC,CAAQ;CACzC,IAAI,CAACF,GAAU,OAAO;CACtB,IAAM,IAAIA,EAAS,QAAQG,CAAE;CAE7B,OADI,IAAI,IAAU,OACX;EAAE,OAAO;EAAG,QAAQ,IAAI,IAAIH,EAAS,SAASA,EAAS,IAAI,KAAM;CAAK;AAC/E;AAOA,SAAgBI,EACd,GACA,GACoB;CACpB,IAAIC,EAAK,WAAW,MACpB;MAAIA,EAAK,WAAW,KAAA,KAAaL,GAAU;GACzC,IAAMM,IAAKN,EAAS,QAAQK,EAAK,MAAM;GACvC,IAAIC,KAAM,GAAG,OAAOA;EACtB;EACA,OAAOD,EAAK,SAAS,IAAIA,EAAK,QAAQ,KAAA;CADtC;AAEF;AAkBA,SAAgBE,EAAY,GAAmB,GAAkC;CAC/E,IAAI,CAACN,EAAE,aAAa,OAAO;CAC3B,IAAMC,IAAWD,EAAE,YAAYA,EAAE,UAAUE,CAAE,IAAI,MAC3CK,IAAQP,EAAE,YAAYC,CAAQ,CAAC,CAAC,QAAQC,CAAE;CAChD,OAAOK,IAAQ,IAAI,OAAO;EAAE;EAAU;CAAM;AAC9C;AAGA,SAAgBC,EAAc,GAAwC;CACpE,OAAO,EAAE,OAAOD,KAAS,GAAG;AAC9B;AAGA,SAAgBE,EAAS,GAA6B;CACpD,OAASC,EAA8B,UAAU;AACnD"}

package/dist/core/ops/transform.js

@@ -0,0 +1,42 @@
+import { registerOpFactory as e } from "./registry.js";
+//#region src/core/ops/transform.ts
+function t(e) {
+	let { id: r, from: i, to: a, label: o, coalesceKey: s = `transform:${r}` } = e;
+	return {
+		name: "transform",
+		args: {
+			id: r,
+			from: i,
+			to: a,
+			label: o,
+			coalesceKey: s
+		},
+		label: o,
+		coalesceKey: s,
+		apply(e) {
+			if (e.setPose(r, a), n(i, a)) return !1;
+		},
+		invert() {
+			return t({
+				id: r,
+				from: a,
+				to: i,
+				label: o,
+				coalesceKey: s
+			});
+		}
+	};
+}
+e("transform", (e) => t(e));
+function n(e, t) {
+	if (e === t) return !0;
+	if (e === null || t === null || typeof e != "object" || typeof t != "object") return !1;
+	let n = Object.keys(e), r = Object.keys(t);
+	if (n.length !== r.length) return !1;
+	for (let r of n) if (e[r] !== t[r]) return !1;
+	return !0;
+}
+//#endregion
+export { t as createTransformOp };
+
+//# sourceMappingURL=transform.js.map

package/dist/core/ops/transform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.js","names":["createTransformOp","id","args","adapter","to","poseShallowEqual","from","registerOpFactory","a","b","ka","kb","k"],"sources":["../../../src/core/ops/transform.ts"],"sourcesContent":["import type { Op } from './types';\nimport { registerOpFactory } from './registry';\n\ninterface TransformAdapter<TPose> {\n  setPose(id: string, pose: TPose): void;\n}\n\n/** Arguments to {@link createTransformOp}: replace node `id`'s pose `from` → `to`. */\nexport interface TransformArgs<TPose> {\n  id: string;\n  from: TPose;\n  to: TPose;\n  label?: string;\n  coalesceKey?: string;\n}\n\n/** Op: set an object's pose, inverting back to `from`. `coalesceKey` defaults to\n *  `transform:${id}` so successive pose writes to the same node (drag-move,\n *  resize, repeated nudges) merge into one undo entry within the history's\n *  coalesce window. Pass an explicit key (or a unique one) to opt out. */\nexport function createTransformOp<TPose>(args: TransformArgs<TPose>): Op {\n  const { id, from, to, label, coalesceKey = `transform:${id}` } = args;\n  return {\n    name: 'transform',\n    args: { id, from, to, label, coalesceKey },\n    label,\n    coalesceKey,\n    apply(adapter) {\n      // Always call setPose so consumers that inspect op behavior (tests,\n      // overlays) see a consistent \"this op writes (id, to)\" signal. When\n      // from and to are structurally identical, additionally report a\n      // no-op to history so the entry can be skipped from the undo stack.\n      // setPose(id, to) is idempotent in this branch — adapters write the\n      // same pose they already had.\n      (adapter as TransformAdapter<TPose>).setPose(id, to);\n      if (poseShallowEqual(from, to)) return false;\n      return undefined;\n    },\n    invert() {\n      return createTransformOp<TPose>({ id, from: to, to: from, label, coalesceKey });\n    },\n  };\n}\n\nregisterOpFactory<TransformArgs<unknown>>('transform', (args) => createTransformOp(args));\n\nfunction poseShallowEqual<TPose>(a: TPose, b: TPose): boolean {\n  if (a === b) return true;\n  if (a === null || b === null || typeof a !== 'object' || typeof b !== 'object') return false;\n  const ka = Object.keys(a as object);\n  const kb = Object.keys(b as object);\n  if (ka.length !== kb.length) return false;\n  for (const k of ka) {\n    if ((a as Record<string, unknown>)[k] !== (b as Record<string, unknown>)[k]) return false;\n  }\n  return true;\n}\n"],"mappings":";;AAoBA,SAAgBA,EAAyB,GAAgC;CACvE,IAAM,EAAE,OAAI,SAAM,OAAI,UAAO,iBAAc,aAAaC,QAASC;CACjE,OAAO;EACL,MAAM;EACN,MAAM;GAAE;GAAI;GAAM;GAAI;GAAO;EAAY;EACzC;EACA;EACA,MAAM,GAAS;GAQb,IADAC,EAAqC,QAAQF,GAAIG,CAAE,GAC/CC,EAAiBC,GAAMF,CAAE,GAAG,OAAO;EAEzC;EACA,SAAS;GACP,OAAOJ,EAAyB;IAAE;IAAI,MAAMI;IAAI,IAAIE;IAAM;IAAO;GAAY,CAAC;EAChF;CACF;AACF;AAEAC,EAA0C,cAAc,MAASP,EAAkBE,CAAI,CAAC;AAExF,SAASG,EAAwB,GAAU,GAAmB;CAC5D,IAAIG,MAAMC,GAAG,OAAO;CACpB,IAAID,MAAM,QAAQC,MAAM,QAAQ,OAAOD,KAAM,YAAY,OAAOC,KAAM,UAAU,OAAO;CACvF,IAAMC,IAAK,OAAO,KAAKF,CAAW,GAC5BG,IAAK,OAAO,KAAKF,CAAW;CAClC,IAAIC,EAAG,WAAWC,EAAG,QAAQ,OAAO;CACpC,KAAK,IAAMC,KAAKF,GACd,IAAKF,EAA8BI,OAAQH,EAA8BG,IAAI,OAAO;CAEtF,OAAO;AACT"}

package/dist/core/paintKinds.js

@@ -0,0 +1,156 @@
+import { gradientForBounds as e, isGradientFill as t, withGradientKind as n } from "./gradient.js";
+import { bumpNodeMemoGeneration as r } from "./scene/nodeMemo.js";
+import { getProgramSource as i, registerProgram as a } from "../renderer/shaders/registerProgram.js";
+import { createReflectable as o } from "@weasel-js/registry";
+//#region src/core/paintKinds.ts
+var s = [
+	{
+		id: "solid",
+		label: "Solid",
+		icon: "paintSolid",
+		seed: (e) => ({ color: e }),
+		colorOf: (e) => (e.fill ?? "solid") === "solid" ? e.color : void 0
+	},
+	c("linear-gradient", "Linear", "paintLinear"),
+	c("radial-gradient", "Radial", "paintRadial"),
+	c("conic-gradient", "Conic", "paintConic"),
+	{
+		id: "pattern",
+		label: "Pattern",
+		icon: "paintPattern",
+		seed: (e) => ({
+			fill: "pattern",
+			pattern: {
+				tile: "hatch",
+				color: e
+			},
+			units: "bounds"
+		}),
+		colorOf: (e) => e.fill === "pattern" ? e.pattern.color : void 0
+	}
+];
+function c(t, n, r) {
+	return {
+		id: t,
+		label: n,
+		icon: r,
+		seed: (n) => e(t, l, u(n), "bounds"),
+		colorOf: (e) => e.stops?.[0]?.color,
+		stopsOf: (e) => e.stops,
+		fromStops: (n) => e(t, l, n, "bounds")
+	};
+}
+var l = {
+	x: 0,
+	y: 0,
+	width: 1,
+	height: 1
+};
+function u(e) {
+	let t = e.slice(0, 7).toLowerCase() === "#ffffff";
+	return [{
+		offset: 0,
+		color: e
+	}, {
+		offset: 1,
+		color: t ? "#000000ff" : "#ffffffff"
+	}];
+}
+var d = o();
+function f() {
+	for (let e of s) d.push(e.id, e, { source: "kit" });
+}
+f(), d.subscribe(r);
+var p = d.reflection;
+function m(e) {
+	return e;
+}
+function h(e) {
+	if (e.stopsOf === void 0 != (e.fromStops === void 0)) {
+		let t = e.stopsOf === void 0 ? "stopsOf" : "fromStops";
+		throw Error(`weasel registerPaintKind: kind "${e.id}" is missing ${t}. A gradient kind reads as a stop list and builds from one; supply both or neither.`);
+	}
+	if (e.inPoseFrame === void 0 != (e.toBoundsFrame === void 0)) {
+		let t = e.inPoseFrame === void 0 ? "inPoseFrame" : "toBoundsFrame";
+		throw Error(`weasel registerPaintKind: kind "${e.id}" is missing ${t}. A kind that converts one frame direction and not the other drifts on the next resize; supply both or neither.`);
+	}
+	for (let [t, n] of Object.entries(e.programs ?? {})) {
+		let e = i(t);
+		(!e || e.vert !== n.vert || e.frag !== n.frag) && a(t, n.vert, n.frag);
+	}
+	return d.push(e.id, e);
+}
+function g(e) {
+	let t = e ?? "solid", n = d.get(t);
+	return !n && _.has(t) && S(t).catch(() => {}), n;
+}
+var _ = /* @__PURE__ */ new Map(), v = /* @__PURE__ */ new Map(), y = [["mesh-gradient", async () => (await import("../features/meshPaint/lazyKind.js")).meshGradientKind]];
+function b() {
+	_.clear(), v.clear();
+	for (let [e, t] of y) _.set(e, t);
+}
+b();
+function x(e, t) {
+	return _.set(e, t), () => {
+		_.get(e) === t && _.delete(e);
+	};
+}
+function S(e) {
+	let t = v.get(e);
+	if (t) return t;
+	let n = _.get(e)().then((t) => {
+		if (t.id !== e) throw Error(`weasel: the loader for paint kind "${e}" resolved to "${t.id}".`);
+		d.has(e) || h(t);
+	}).catch((t) => {
+		throw console.error(`weasel: paint kind "${e}" failed to load:`, t), t;
+	});
+	return v.set(e, n), n;
+}
+function C(e) {
+	return d.has(e) || _.has(e);
+}
+function w(e) {
+	let t = e ?? [..._.keys()], n = [];
+	for (let e of t) if (!d.has(e)) {
+		if (!_.has(e)) return Promise.reject(/* @__PURE__ */ Error(`weasel warmPaintKinds: "${e}" is neither registered nor loadable.`));
+		n.push(S(e));
+	}
+	return Promise.all(n).then(() => void 0);
+}
+function T(e) {
+	let t, n = [];
+	return () => {
+		let r = d.entries();
+		return r !== t && (t = r, n = Object.freeze(e(r))), n;
+	};
+}
+function E() {
+	return D();
+}
+var D = T((e) => e.map((e) => e.value));
+function O() {
+	return k();
+}
+var k = T((e) => e.map((e) => e.value).filter((e) => e.stopsOf && e.fromStops));
+function A(e, r) {
+	let i = j(e), a = g(r);
+	if (!i?.stopsOf || !a?.fromStops) return;
+	if (i.id === a.id) return e;
+	if (t(e) && t({ fill: r })) return n(e, r);
+	let { interpolate: o, opacity: s } = e;
+	return {
+		...a.fromStops(i.stopsOf(e)),
+		...o === void 0 ? {} : { interpolate: o },
+		...s === void 0 ? {} : { opacity: s }
+	};
+}
+function j(e) {
+	return g(e.fill ?? "solid");
+}
+function M() {
+	d.clear(), f(), b();
+}
+//#endregion
+export { M as _resetPaintKindsForTests, m as asPaint, g as getPaintKind, C as isPaintKindKnown, O as listGradientKinds, E as listPaintKinds, j as paintKindOf, p as paintKindRegistry, h as registerPaintKind, x as registerPaintKindLoader, A as switchGradientKind, w as warmPaintKinds };
+
+//# sourceMappingURL=paintKinds.js.map

package/dist/core/paintKinds.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paintKinds.js","names":["BUILTINS","paint","gradientKind","gradientForBounds","id","UNIT_BOX","twoStopRamp","color","stops","isWhite","KINDS","createReflectable","seedBuiltins","entry","bumpNodeMemoGeneration","paintKindRegistry","asPaint","registerPaintKind","missing","src","have","getProgramSource","registerProgram","getPaintKind","kind","LOADERS","startLoad","LOADS","LAZY_BUILTINS","seedLoaders","load","registerPaintKindLoader","running","done","err","isPaintKindKnown","warmPaintKinds","ids","kinds","loads","derivedList","from","list","entries","derive","listPaintKinds","allKinds","all","listGradientKinds","gradientKinds","switchGradientKind","paintKindOf","to","isGradientFill","withGradientKind","interpolate","opacity","fill","_resetPaintKindsForTests"],"sources":["../../src/core/paintKinds.ts"],"sourcesContent":["/**\n * The paint-kind registry — what makes `FillStyle` open.\n *\n * A consumer registers a sixth kind and it renders, converts between the\n * bounds and pose frames, and serializes, with no kit edits. The five built-in\n * kinds are registered here at module load so an editor's kind bar can\n * enumerate every kind through one list.\n *\n * Each kit layer consults this registry for a kind it does not recognize and\n * otherwise runs its own built-in branch. That split is not laziness: a built-in\n * kind's render slot lives in the GL renderer, its serialize slot lives in\n * `@weasel-js/svg`, and neither can be imported from here without inverting a\n * package dependency.\n */\n\nimport type {\n  ColorSpace, FillStyle, GradientFill, GradientKind, GradientUnits, GradStop, TilePatternSpec,\n} from '@weasel-js/paint';\nimport { gradientForBounds, isGradientFill, withGradientKind } from './gradient';\nimport { bumpNodeMemoGeneration } from './scene/nodeMemo';\nimport type { ComponentType } from 'react';\nimport { createReflectable, type ReflectedEntry, type Reflection } from '@weasel-js/registry';\nimport type { FillPoseBox } from './fillInPoseFrame';\nimport type { GlMat3 } from '../renderer/math/mat3';\nimport type { ShaderProgram } from '../renderer/shaders/ShaderProgram';\nimport { getProgramSource, registerProgram, type ProgramSource } from '../renderer/shaders/registerProgram';\n\n/** A compiled GL program. A paint kind gets one from\n *  {@link PaintBindContext.program} and hands it back from `bind`. */\nexport type PaintProgram = ShaderProgram;\n\n/**\n * `FillStyle`'s discriminant, open on the string the way `ChromeId` is: the\n * five kinds the kit ships, plus whatever a consumer registers.\n */\nexport type PaintKind = 'solid' | 'linear-gradient' | 'radial-gradient' | 'conic-gradient' | 'pattern' | (string & {});\n\n/** What a registered kind's editor renders. `PaintInput` in `@weasel-js/ui`\n *  is the control that mounts it. */\nexport interface PaintKindEditorProps {\n  value: FillStyle;\n  onInput?(next: FillStyle): void;\n  onChange(next: FillStyle): void;\n}\n\n/**\n * The lifetime a paint kind's GPU state belongs to: one renderer on one live\n * context. The object itself is the key — a kind caches textures in a\n * `WeakMap` on it, so two renderers sharing a context never trade them — and\n * `onRelease` is where it frees them.\n */\nexport interface PaintResources {\n  /** Run `release` once, when this lifetime ends: the renderer is disposed, or\n   *  its context was lost and restored. Free every GL object made under it\n   *  there. */\n  onRelease(release: () => void): void;\n}\n\n/**\n * The renderer surface a paint kind binds against, narrowed to what a paint\n * needs. The full `DrawContext` is not consumer surface.\n */\nexport interface PaintBindContext {\n  readonly gl: WebGL2RenderingContext;\n  /** The group alpha this draw inherits — multiply it into the paint's own. */\n  readonly alpha: number;\n  /**\n   * The compiled program for a `registerProgram` id, compiled against this\n   * renderer on first use. `null` when no source is registered under `id` or\n   * compilation failed.\n   */\n  program(id: string): PaintProgram | null;\n  /** Send `u_proj` and `u_model`, which every kit vertex shader takes. */\n  setProjAndModel(program: PaintProgram): void;\n  /**\n   * `u_worldInv` for a paint declaring `units` — the inverse of the transform\n   * from the paint's space to the frame the geometry arrives in. Paired with\n   * the vertex shader's `v_world` varying this is *the* paint-space\n   * convention; it is not gradient-specific.\n   *\n   * `null` when that space has no inverse — a transform or view that flattens\n   * an axis. Nothing the paint draws there means anything, so `bind` should\n   * return `null` and draw nothing.\n   */\n  spaceInverse(units: GradientUnits | undefined): GlMat3 | null;\n  /**\n   * The transform from the space `units` names to device pixels of the target\n   * this draw lands in — screen pixels times the pixel ratio on screen, output\n   * pixels in a headless render. It is what a paint baking a texture measures\n   * its resolution against. `null` where `spaceInverse` is.\n   */\n  spaceToDevice(units: GradientUnits | undefined): GlMat3 | null;\n  /** The largest texture side this context accepts, `MAX_TEXTURE_SIZE`. */\n  readonly maxTextureSize: number;\n  /** The lifetime GPU state made for this draw belongs to. Stable across the\n   *  frames of one renderer, so it is the key for a kind's texture cache. */\n  readonly resources: PaintResources;\n  /**\n   * Bake a stop ramp into the frame's ramp atlas, bind that atlas to a texture\n   * unit, and return the `v` the ramp's own row sits at — every ramp in a\n   * frame shares one texture, so a paint must sample at the returned `v` and\n   * not at a constant.\n   *\n   * `space` is the blend the stops are baked through, defaulting to `'rgb'`.\n   * It is part of the atlas key, so the same stops under two spaces take two\n   * rows rather than colliding.\n   */\n  bindRamp(stops: GradStop[], unit: number, space?: ColorSpace): number;\n}\n\n/**\n * One paint kind.\n *\n * `seed`, `label` and `colorOf` are the editor's slots and every kind has\n * them. The rest are optional because a kind may not need them — but\n * `inPoseFrame` and `toBoundsFrame` come as a pair or not at all: a kind that\n * converts one direction and not the other paints correctly once and then\n * drifts on the next resize.\n */\nexport interface PaintKindEntry {\n  id: string;\n  label: string;\n  /** Glyph naming this kind in an editor's kind bar, as an icon name the UI\n   *  layer resolves — the same indirection `ToolPrefBase.icon` uses. A kind\n   *  without one is named by its `label`. */\n  icon?: string;\n  /** A paint of this kind seeded from a color — what an editor writes when a\n   *  consumer switches a solid to this kind. */\n  seed(fromColor: string): FillStyle;\n  /** The single color this paint shows, or `undefined` when it has none. */\n  colorOf(paint: FillStyle): string | undefined;\n  /** Editor slot. */\n  Editor?: ComponentType<PaintKindEditorProps>;\n  /**\n   * The stop list this paint reads as. With `fromStops`, it is what makes a\n   * kind a gradient: `listGradientKinds` returns the kinds carrying both, and\n   * `switchGradientKind` converts between any two of them through the list.\n   */\n  stopsOf?(paint: FillStyle): GradStop[];\n  /** A paint of this kind built from a stop list, in `bounds` units. The\n   *  converse of `stopsOf`; supply both or neither. */\n  fromStops?(stops: GradStop[]): FillStyle;\n  /**\n   * Render slot: bind program, uniforms and textures for `fill` and return the\n   * bound program; `null` declines the paint.\n   *\n   * Binding is split from drawing on purpose — a caller owning its own stencil\n   * state (an inner/outer-aligned stroke, an even-odd fill) must issue its own\n   * draw call, and the kit's draw wrapper would clobber that state. Shader\n   * output must be premultiplied: `outColor = vec4(rgb * a, a)`.\n   *\n   * The geometry is not always the node's own. Text below the outline tier\n   * paints by drawing a quad over its glyphs' screen box into an offscreen\n   * buffer and masking that with glyph coverage, so a paint must come from\n   * `v_world` through `spaceInverse`, not from where `a_position` happens to\n   * lie.\n   */\n  bind?(ctx: PaintBindContext, fill: FillStyle): PaintProgram | null;\n  /** Bounds frame → the frame the node is painted in. */\n  inPoseFrame?(fill: FillStyle, box: FillPoseBox): FillStyle;\n  /** The inverse. Required whenever `inPoseFrame` is supplied. */\n  toBoundsFrame?(fill: FillStyle, box: FillPoseBox): FillStyle;\n  /**\n   * The `<defs>` entry backing a `url(#id)` reference.\n   *\n   * SVG has paint servers for two gradients and a pattern and nothing else, so\n   * a kind beyond those has no element to target: write a foreign-namespaced\n   * one under the `wzl:` prefix `@weasel-js/svg` declares on the root whenever\n   * a document holds such a paint. That package emits the fallback color\n   * beside the reference on its own, from `colorOf`.\n   */\n  toSvg?(id: string, fill: FillStyle): string;\n  /**\n   * Shader programs `bind` looks up through `ctx.program`, keyed by program\n   * id; registering the kind registers them. Declaring them here rather than\n   * calling `registerProgram` at import keeps a kind loaded by\n   * {@link registerPaintKindLoader} free of core's registries.\n   */\n  programs?: Readonly<Record<string, ProgramSource>>;\n}\n\nconst BUILTINS: readonly PaintKindEntry[] = [\n  {\n    id: 'solid',\n    label: 'Solid',\n    icon: 'paintSolid',\n    seed: (color) => ({ color }),\n    colorOf: (paint) => ((paint.fill ?? 'solid') === 'solid'\n      ? (paint as { color: string }).color\n      : undefined),\n  },\n  gradientKind('linear-gradient', 'Linear', 'paintLinear'),\n  gradientKind('radial-gradient', 'Radial', 'paintRadial'),\n  gradientKind('conic-gradient', 'Conic', 'paintConic'),\n  {\n    id: 'pattern',\n    label: 'Pattern',\n    icon: 'paintPattern',\n    seed: (color) => ({\n      fill: 'pattern',\n      pattern: { tile: 'hatch', color },\n      units: 'bounds',\n    }),\n    colorOf: (paint) => (paint.fill === 'pattern'\n      ? (paint.pattern as Partial<TilePatternSpec>).color\n      : undefined),\n  },\n];\n\nfunction gradientKind(id: GradientKind, label: string, icon: string): PaintKindEntry {\n  return {\n    id,\n    label,\n    icon,\n    // `bounds` units make the seed independent of the node's actual size.\n    seed: (color) => gradientForBounds(id, UNIT_BOX, twoStopRamp(color), 'bounds'),\n    colorOf: (paint) => (paint as Partial<GradientFill>).stops?.[0]?.color,\n    stopsOf: (paint) => (paint as GradientFill).stops,\n    fromStops: (stops) => gradientForBounds(id, UNIT_BOX, stops, 'bounds'),\n  };\n}\n\nconst UNIT_BOX = { x: 0, y: 0, width: 1, height: 1 };\n\n/** `color` to a contrasting end — white reads against any hue; against white\n *  itself, black does. */\nfunction twoStopRamp(color: string): GradStop[] {\n  const isWhite = color.slice(0, 7).toLowerCase() === '#ffffff';\n  return [{ offset: 0, color }, { offset: 1, color: isWhite ? '#000000ff' : '#ffffffff' }];\n}\n\nconst KINDS = createReflectable<PaintKindEntry>();\n\nfunction seedBuiltins(): void {\n  for (const entry of BUILTINS) KINDS.push(entry.id, entry, { source: 'kit' });\n}\nseedBuiltins();\n// `NodeShape`'s paint slot memoizes per node and resolves a fill's frame\n// inside it, so the kind set is ambient state that memo cannot see change.\nKINDS.subscribe(bumpNodeMemoGeneration);\n\n/** Every registered paint kind, with the overrides each displaced. */\nexport const paintKindRegistry: Reflection<PaintKindEntry> = KINDS.reflection;\n\n/**\n * A consumer's own paint, typed as a `FillStyle`.\n *\n * `FillStyle` stays a closed union: opening its discriminant would widen every\n * built-in member and break the narrowing the kit's own branches depend on.\n * A registered kind declares its own interface instead and passes it through\n * here — the kit reads only `fill` and hands the whole object back to that\n * kind's slots.\n */\nexport function asPaint<T extends { fill: string }>(paint: T): FillStyle {\n  return paint as unknown as FillStyle;\n}\n\n/** Register a paint kind. Returns a disposer that removes it. Re-registering an\n *  existing id is an override; disposing it uncovers whatever it displaced. */\nexport function registerPaintKind(entry: PaintKindEntry): () => void {\n  if ((entry.stopsOf === undefined) !== (entry.fromStops === undefined)) {\n    const missing = entry.stopsOf === undefined ? 'stopsOf' : 'fromStops';\n    throw new Error(\n      `weasel registerPaintKind: kind \"${entry.id}\" is missing ${missing}. A ` +\n      'gradient kind reads as a stop list and builds from one; supply both or neither.',\n    );\n  }\n  if ((entry.inPoseFrame === undefined) !== (entry.toBoundsFrame === undefined)) {\n    const missing = entry.inPoseFrame === undefined ? 'inPoseFrame' : 'toBoundsFrame';\n    throw new Error(\n      `weasel registerPaintKind: kind \"${entry.id}\" is missing ${missing}. A kind ` +\n      'that converts one frame direction and not the other drifts on the next ' +\n      'resize; supply both or neither.',\n    );\n  }\n  for (const [id, src] of Object.entries(entry.programs ?? {})) {\n    const have = getProgramSource(id);\n    if (!have || have.vert !== src.vert || have.frag !== src.frag) registerProgram(id, src.vert, src.frag);\n  }\n  // Re-registering a built-in id is how a consumer closes a gap the kit leaves,\n  // so disposing that override puts the built-in back rather than deleting the\n  // kind.\n  return KINDS.push(entry.id, entry);\n}\n\n/** The entry for `kind`, or `undefined`. A lookup that misses on a kind with\n *  a loader starts that load; see {@link registerPaintKindLoader}. */\nexport function getPaintKind(kind: string | undefined): PaintKindEntry | undefined {\n  const id = kind ?? 'solid';\n  const entry = KINDS.get(id);\n  if (!entry && LOADERS.has(id)) void startLoad(id).catch(() => {});\n  return entry;\n}\n\n/** Resolves with the entry for a kind that is loaded on first use. */\nexport type PaintKindLoader = () => Promise<PaintKindEntry>;\n\nconst LOADERS = new Map<string, PaintKindLoader>();\n\n/** One load per kind, kept after it settles: a failed load is not retried on\n *  every frame that meets the kind. */\nconst LOADS = new Map<string, Promise<void>>();\n\n// A built-in kind heavy enough to keep off a consumer's bundle until a paint\n// of it turns up. Importing the module statically still registers it at once.\nconst LAZY_BUILTINS: ReadonlyArray<readonly [string, PaintKindLoader]> = [\n  ['mesh-gradient', async () => (await import('../features/meshPaint/lazyKind')).meshGradientKind],\n];\n\nfunction seedLoaders(): void {\n  LOADERS.clear();\n  LOADS.clear();\n  for (const [id, load] of LAZY_BUILTINS) LOADERS.set(id, load);\n}\nseedLoaders();\n\n/**\n * Declare a paint kind that is loaded the first time something looks it up,\n * so its code stays out of the bundle until a paint of it appears — typically\n * `() => import('./myKind').then((m) => m.myKindEntry)`.\n *\n * Until it lands the kind is unregistered: the renderer draws nothing for its\n * paints, and every other reader treats it as unknown. Registering it fires\n * `paintKindRegistry`'s subscribers, which is what `<SceneCanvas>` repaints\n * on. Call {@link warmPaintKinds} to load ahead of the first frame instead.\n *\n * A kind that is already registered never calls its loader. Returns a\n * disposer that removes the loader.\n */\nexport function registerPaintKindLoader(id: string, load: PaintKindLoader): () => void {\n  LOADERS.set(id, load);\n  return () => {\n    if (LOADERS.get(id) === load) LOADERS.delete(id);\n  };\n}\n\nfunction startLoad(id: string): Promise<void> {\n  const running = LOADS.get(id);\n  if (running) return running;\n  const load = LOADERS.get(id)!;\n  const done = load().then(\n    (entry) => {\n      if (entry.id !== id) {\n        throw new Error(`weasel: the loader for paint kind \"${id}\" resolved to \"${entry.id}\".`);\n      }\n      if (!KINDS.has(id)) registerPaintKind(entry);\n    },\n  ).catch((err: unknown) => {\n    console.error(`weasel: paint kind \"${id}\" failed to load:`, err);\n    throw err;\n  });\n  LOADS.set(id, done);\n  return done;\n}\n\n/** Is `id` registered, or declared with a loader? */\nexport function isPaintKindKnown(id: string): boolean {\n  return KINDS.has(id) || LOADERS.has(id);\n}\n\n/**\n * Load paint kinds ahead of their first use, so the first frame that meets\n * one draws it rather than a blank. With no list, loads every kind that has a\n * loader — the kit's lazily loaded built-ins (`mesh-gradient`) plus any a\n * consumer declared with {@link registerPaintKindLoader}.\n *\n * Resolves once every kind is registered; a kind already registered counts\n * as loaded. Rejects when a load fails, or for a kind that is neither\n * registered nor loadable.\n */\nexport function warmPaintKinds(kinds?: readonly string[]): Promise<void> {\n  const ids = kinds ?? [...LOADERS.keys()];\n  const loads: Promise<void>[] = [];\n  for (const id of ids) {\n    if (KINDS.has(id)) continue;\n    if (!LOADERS.has(id)) {\n      return Promise.reject(new Error(\n        `weasel warmPaintKinds: \"${id}\" is neither registered nor loadable.`,\n      ));\n    }\n    loads.push(startLoad(id));\n  }\n  return Promise.all(loads).then(() => undefined);\n}\n\n/** A list derived from the registry, recomputed only when it changes — so\n *  its identity is a `useSyncExternalStore` snapshot. */\nfunction derivedList(\n  derive: (all: readonly ReflectedEntry<PaintKindEntry>[]) => readonly PaintKindEntry[],\n): () => readonly PaintKindEntry[] {\n  let from: readonly ReflectedEntry<PaintKindEntry>[] | undefined;\n  let list: readonly PaintKindEntry[] = [];\n  return () => {\n    const entries = KINDS.entries();\n    if (entries !== from) {\n      from = entries;\n      list = Object.freeze(derive(entries));\n    }\n    return list;\n  };\n}\n\n/** Every registered kind, built-ins first, in registration order. The same\n *  array until the registry changes. */\nexport function listPaintKinds(): readonly PaintKindEntry[] {\n  return allKinds();\n}\nconst allKinds = derivedList((all) => all.map((e) => e.value));\n\n/** Every registered gradient kind — the ones that read as and build from a\n *  stop list — in registration order. The same array until the registry\n *  changes. */\nexport function listGradientKinds(): readonly PaintKindEntry[] {\n  return gradientKinds();\n}\nconst gradientKinds = derivedList(\n  (all) => all.map((e) => e.value).filter((entry) => entry.stopsOf && entry.fromStops),\n);\n\n/**\n * `paint` retargeted to gradient kind `kind`, or `undefined` when either side\n * is not a gradient kind.\n *\n * Between two of the stop gradients this is `withGradientKind`, which carries\n * the geometry. Any other pair goes through the stop list — `stopsOf` on the\n * way out, `fromStops` on the way in — keeping `interpolate` and `opacity`.\n * Lossy wherever the kinds hold different information; an editor that wants a\n * switch to be undoable should keep the original paint.\n */\nexport function switchGradientKind(paint: FillStyle, kind: PaintKind): FillStyle | undefined {\n  const from = paintKindOf(paint);\n  const to = getPaintKind(kind);\n  if (!from?.stopsOf || !to?.fromStops) return undefined;\n  if (from.id === to.id) return paint;\n  if (isGradientFill(paint) && isGradientFill({ fill: kind } as FillStyle)) {\n    return withGradientKind(paint, kind as GradientKind);\n  }\n  const { interpolate, opacity } = paint as { interpolate?: ColorSpace; opacity?: number };\n  return {\n    ...to.fromStops(from.stopsOf(paint)),\n    ...(interpolate !== undefined ? { interpolate } : {}),\n    ...(opacity !== undefined ? { opacity } : {}),\n  } as FillStyle;\n}\n\n/** The registry entry for a paint, or `undefined` when its kind is unknown. */\nexport function paintKindOf(fill: FillStyle): PaintKindEntry | undefined {\n  return getPaintKind(fill.fill ?? 'solid');\n}\n\n/** @internal Test helper — do not call from product code. */\nexport function _resetPaintKindsForTests(): void {\n  KINDS.clear();\n  seedBuiltins();\n  seedLoaders();\n}\n"],"mappings":";;;;;AAqLA,IAAMA,IAAsC;CAC1C;EACE,IAAI;EACJ,OAAO;EACP,MAAM;EACN,OAAO,OAAW,EAAE,SAAM;EAC1B,UAAU,OAAYC,EAAM,QAAQ,aAAa,UAC5CA,EAA4B,QAC7B,KAAA;CACN;CACAC,EAAa,mBAAmB,UAAU,aAAa;CACvDA,EAAa,mBAAmB,UAAU,aAAa;CACvDA,EAAa,kBAAkB,SAAS,YAAY;CACpD;EACE,IAAI;EACJ,OAAO;EACP,MAAM;EACN,OAAO,OAAW;GAChB,MAAM;GACN,SAAS;IAAE,MAAM;IAAS;GAAM;GAChC,OAAO;EACT;EACA,UAAU,MAAWD,EAAM,SAAS,YAC/BA,EAAM,QAAqC,QAC5C,KAAA;CACN;AACF;AAEA,SAASC,EAAa,GAAkB,GAAe,GAA8B;CACnF,OAAO;EACL;EACA;EACA;EAEA,OAAO,MAAUC,EAAkBC,GAAIC,GAAUC,EAAYC,CAAK,GAAG,QAAQ;EAC7E,UAAU,MAAWN,EAAgC,QAAQ,EAAE,EAAE;EACjE,UAAU,MAAWA,EAAuB;EAC5C,YAAY,MAAUE,EAAkBC,GAAIC,GAAUG,GAAO,QAAQ;CACvE;AACF;AAEA,IAAMH,IAAW;CAAE,GAAG;CAAG,GAAG;CAAG,OAAO;CAAG,QAAQ;AAAE;AAInD,SAASC,EAAY,GAA2B;CAC9C,IAAMG,IAAUF,EAAM,MAAM,GAAG,CAAC,CAAC,CAAC,YAAY,MAAM;CACpD,OAAO,CAAC;EAAE,QAAQ;EAAG;CAAM,GAAG;EAAE,QAAQ;EAAG,OAAOE,IAAU,cAAc;CAAY,CAAC;AACzF;AAEA,IAAMC,IAAQC,EAAkC;AAEhD,SAASC,IAAqB;CAC5B,KAAK,IAAMC,KAASb,GAAU,EAAM,KAAKa,EAAM,IAAIA,GAAO,EAAE,QAAQ,MAAM,CAAC;AAC7E;AACAD,EAAa,GAGbF,EAAM,UAAUI,CAAsB;AAGtC,IAAaC,IAAgDL,EAAM;AAWnE,SAAgBM,EAAoC,GAAqB;CACvE,OAAOf;AACT;AAIA,SAAgBgB,EAAkB,GAAmC;CACnE,IAAKJ,EAAM,YAAY,KAAA,MAAgBA,EAAM,cAAc,KAAA,IAAY;EACrE,IAAMK,IAAUL,EAAM,YAAY,KAAA,IAAY,YAAY;EAC1D,MAAU,MACR,mCAAmCA,EAAM,GAAG,eAAeK,EAAQ,oFAErE;CACF;CACA,IAAKL,EAAM,gBAAgB,KAAA,MAAgBA,EAAM,kBAAkB,KAAA,IAAY;EAC7E,IAAMK,IAAUL,EAAM,gBAAgB,KAAA,IAAY,gBAAgB;EAClE,MAAU,MACR,mCAAmCA,EAAM,GAAG,eAAeK,EAAQ,gHAGrE;CACF;CACA,KAAK,IAAM,CAACd,GAAIe,MAAQ,OAAO,QAAQN,EAAM,YAAY,CAAC,CAAC,GAAG;EAC5D,IAAMO,IAAOC,EAAiBjB,CAAE;EAChC,CAAI,CAACgB,KAAQA,EAAK,SAASD,EAAI,QAAQC,EAAK,SAASD,EAAI,SAAMG,EAAgBlB,GAAIe,EAAI,MAAMA,EAAI,IAAI;CACvG;CAIA,OAAOT,EAAM,KAAKG,EAAM,IAAIA,CAAK;AACnC;AAIA,SAAgBU,EAAa,GAAsD;CACjF,IAAMnB,IAAKoB,KAAQ,SACbX,IAAQH,EAAM,IAAIN,CAAE;CAE1B,OADI,CAACS,KAASY,EAAQ,IAAIrB,CAAE,KAAGsB,EAAetB,CAAE,CAAC,CAAC,YAAY,CAAC,CAAC,GACzDS;AACT;AAKA,IAAMY,oBAAU,IAAI,IAA6B,GAI3CE,oBAAQ,IAAI,IAA2B,GAIvCC,IAAmE,CACvE,CAAC,iBAAiB,aAAa,MAAM,OAAO,qCAAA,CAAmC,gBAAgB,CACjG;AAEA,SAASC,IAAoB;CAE3B,AADAJ,EAAQ,MAAM,GACdE,EAAM,MAAM;CACZ,KAAK,IAAM,CAACvB,GAAI0B,MAASF,GAAe,EAAQ,IAAIxB,GAAI0B,CAAI;AAC9D;AACAD,EAAY;AAeZ,SAAgBE,EAAwB,GAAY,GAAmC;CAErF,OADAN,EAAQ,IAAIrB,GAAI0B,CAAI,SACP;EACX,AAAIL,EAAQ,IAAIrB,CAAE,MAAM0B,KAAML,EAAQ,OAAOrB,CAAE;CACjD;AACF;AAEA,SAASsB,EAAU,GAA2B;CAC5C,IAAMM,IAAUL,EAAM,IAAIvB,CAAE;CAC5B,IAAI4B,GAAS,OAAOA;CAEpB,IAAMC,IADOR,EAAQ,IAAIrB,CACZ,CAAA,CAAK,CAAC,CAAC,MACjB,MAAU;EACT,IAAIS,EAAM,OAAOT,GACf,MAAU,MAAM,sCAAsCA,EAAG,iBAAiBS,EAAM,GAAG,GAAG;EAExF,AAAKH,EAAM,IAAIN,CAAE,KAAGa,EAAkBJ,CAAK;CAC7C,CACF,CAAC,CAAC,OAAO,MAAiB;EAExB,MADA,QAAQ,MAAM,uBAAuBT,EAAG,oBAAoB8B,CAAG,GACzDA;CACR,CAAC;CAED,OADAP,EAAM,IAAIvB,GAAI6B,CAAI,GACXA;AACT;AAGA,SAAgBE,EAAiB,GAAqB;CACpD,OAAOzB,EAAM,IAAIN,CAAE,KAAKqB,EAAQ,IAAIrB,CAAE;AACxC;AAYA,SAAgBgC,EAAe,GAA0C;CACvE,IAAMC,IAAMC,KAAS,CAAC,GAAGb,EAAQ,KAAK,CAAC,GACjCc,IAAyB,CAAC;CAChC,KAAK,IAAMnC,KAAMiC,GACf,IAAI,GAAM,IAAIjC,CAAE,GAChB;MAAI,CAACqB,EAAQ,IAAIrB,CAAE,GACjB,OAAO,QAAQ,OAAO,gBAAI,MACxB,2BAA2BA,EAAG,sCAChC,CAAC;EAEH,EAAM,KAAKsB,EAAUtB,CAAE,CAAC;CAFrB;CAIL,OAAO,QAAQ,IAAImC,CAAK,CAAC,CAAC,WAAW,KAAA,CAAS;AAChD;AAIA,SAASC,EACP,GACiC;CACjC,IAAIC,GACAC,IAAkC,CAAC;CACvC,aAAa;EACX,IAAMC,IAAUjC,EAAM,QAAQ;EAK9B,OAJIiC,MAAYF,MACd,IAAOE,GACP,IAAO,OAAO,OAAOC,EAAOD,CAAO,CAAC,IAE/BD;CACT;AACF;AAIA,SAAgBG,IAA4C;CAC1D,OAAOC,EAAS;AAClB;AACA,IAAMA,IAAWN,GAAa,MAAQO,EAAI,KAAK,MAAM,EAAE,KAAK,CAAC;AAK7D,SAAgBC,IAA+C;CAC7D,OAAOC,EAAc;AACvB;AACA,IAAMA,IAAgBT,GACnB,MAAQO,EAAI,KAAK,MAAM,EAAE,KAAK,CAAC,CAAC,QAAQ,MAAUlC,EAAM,WAAWA,EAAM,SAAS,CACrF;AAYA,SAAgBqC,EAAmB,GAAkB,GAAwC;CAC3F,IAAMT,IAAOU,EAAYlD,CAAK,GACxBmD,IAAK7B,EAAaC,CAAI;CAC5B,IAAI,CAACiB,GAAM,WAAW,CAACW,GAAI,WAAW;CACtC,IAAIX,EAAK,OAAOW,EAAG,IAAI,OAAOnD;CAC9B,IAAIoD,EAAepD,CAAK,KAAKoD,EAAe,EAAE,MAAM7B,EAAK,CAAc,GACrE,OAAO8B,EAAiBrD,GAAOuB,CAAoB;CAErD,IAAM,EAAE,gBAAa,eAAYvB;CACjC,OAAO;EACL,GAAGmD,EAAG,UAAUX,EAAK,QAAQxC,CAAK,CAAC;EACnC,GAAIsD,MAAgB,KAAA,IAA8B,CAAC,IAAnB,EAAE,eAAY;EAC9C,GAAIC,MAAY,KAAA,IAA0B,CAAC,IAAf,EAAE,WAAQ;CACxC;AACF;AAGA,SAAgBL,EAAY,GAA6C;CACvE,OAAO5B,EAAakC,EAAK,QAAQ,OAAO;AAC1C;AAGA,SAAgBC,IAAiC;CAG/C,AAFAhD,EAAM,MAAM,GACZE,EAAa,GACbiB,EAAY;AACd"}

package/dist/core/scene/NodeProperties.js

@@ -0,0 +1,20 @@
+//#region src/core/scene/NodeProperties.ts
+function e() {
+	let e = [], t = /* @__PURE__ */ new Map();
+	return {
+		register(n) {
+			if (t.has(n.name)) throw Error(`createNodeProperties: duplicate kind name "${n.name}"`);
+			t.set(n.name, n), e.push(n);
+		},
+		get(e) {
+			return t.get(e);
+		},
+		list() {
+			return e;
+		}
+	};
+}
+//#endregion
+export { e as createNodeProperties };
+
+//# sourceMappingURL=NodeProperties.js.map

package/dist/core/scene/NodeProperties.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeProperties.js","names":["createNodeProperties","entries","byName","entry","name"],"sources":["../../../src/core/scene/NodeProperties.ts"],"sourcesContent":["import type { ToolPrefGroup } from 'tools/prefs';\n\n/**\n * NodePropertiesEntry — one kind's entry in the **properties trait's**\n * registry: a declarative schema of the kind's editable properties.\n *\n * Leaf keys inside `schema` are dotted node paths (`pose.x`,\n * `data.fill`, `data.style.fontSize`) — a path of any depth rooted at\n * `pose` or `data` — so schema consumers (weasel-ui `SelectionPanel`)\n * can read/aggregate/write generically with no per-kind code. Group\n * keys are organizational only; they do not contribute to the node\n * path.\n *\n * Kind names share the routing trait's vocabulary — an entry registered\n * as `'rect'` describes nodes `NodeRouting.classify` maps to `'rect'`.\n * See `docs/superpowers/specs/2026-07-20-selection-panel-design.md` and\n * the trait taxonomy in\n * `docs/superpowers/specs/2026-05-24-node-traits-reframe-design.md`.\n */\nexport interface NodePropertiesEntry {\n  /** Kind name — same vocabulary as the routing trait. */\n  name: string;\n  /** Property schema for this kind. */\n  schema: ToolPrefGroup;\n}\n\n/**\n * NodeProperties — the **properties trait's** registry. Each trait of a\n * node (shape, routing, properties, …) is its own registry; this one\n * answers \"what editable properties does this kind expose?\" Consumed by\n * weasel-ui's `<SelectionPanel>`.\n *\n * (Supersedes the speculative `NodePropertyRows` name in the traits\n * spec — the stored value is a schema, not render contributors.)\n */\nexport interface NodeProperties {\n  /** Register a kind. Throws if a kind with this name is already\n   *  registered. */\n  register(entry: NodePropertiesEntry): void;\n  /** Lookup a kind's entry by name. */\n  get(name: string): NodePropertiesEntry | undefined;\n  /** Enumerate registered kinds in registration order. */\n  list(): readonly NodePropertiesEntry[];\n}\n\n/** Build a registry of per-node-kind property descriptors, which schema-driven\n *  property panels read to know what a node exposes. Registering a duplicate\n *  kind name throws. */\nexport function createNodeProperties(): NodeProperties {\n  const entries: NodePropertiesEntry[] = [];\n  const byName = new Map<string, NodePropertiesEntry>();\n  return {\n    register(entry) {\n      if (byName.has(entry.name)) {\n        throw new Error(\n          `createNodeProperties: duplicate kind name \"${entry.name}\"`,\n        );\n      }\n      byName.set(entry.name, entry);\n      entries.push(entry);\n    },\n    get(name) {\n      return byName.get(name);\n    },\n    list() {\n      return entries;\n    },\n  };\n}\n"],"mappings":";AAgDA,SAAgBA,IAAuC;CACrD,IAAMC,IAAiC,CAAC,GAClCC,oBAAS,IAAI,IAAiC;CACpD,OAAO;EACL,SAAS,GAAO;GACd,IAAIA,EAAO,IAAIC,EAAM,IAAI,GACvB,MAAU,MACR,8CAA8CA,EAAM,KAAK,EAC3D;GAGF,AADAD,EAAO,IAAIC,EAAM,MAAMA,CAAK,GAC5BF,EAAQ,KAAKE,CAAK;EACpB;EACA,IAAI,GAAM;GACR,OAAOD,EAAO,IAAIE,CAAI;EACxB;EACA,OAAO;GACL,OAAOH;EACT;CACF;AACF"}

package/dist/core/scene/NodeRouting.js

@@ -0,0 +1,24 @@
+//#region src/core/scene/NodeRouting.ts
+function e() {
+	let e = [], t = /* @__PURE__ */ new Map();
+	return {
+		register(n) {
+			if (t.has(n.name)) throw Error(`createNodeRouting: duplicate kind name "${n.name}"`);
+			t.set(n.name, n), e.push(n);
+		},
+		classify(t) {
+			for (let n of e) if (n.matches(t)) return n.name;
+			return "unknown";
+		},
+		get(e) {
+			return t.get(e);
+		},
+		list() {
+			return e;
+		}
+	};
+}
+//#endregion
+export { e as createNodeRouting };
+
+//# sourceMappingURL=NodeRouting.js.map

package/dist/core/scene/NodeRouting.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeRouting.js","names":["createNodeRouting","entries","byName","kind","data","name"],"sources":["../../../src/core/scene/NodeRouting.ts"],"sourcesContent":["/**\n * NodeRoutingEntry — a routing-trait classifier entry.\n *\n * The kit consults `NodeRouting` (the routing trait's registry)\n * to derive a kind string for each scene node. Other traits (shape,\n * label, icon, …) are independent registries — fields like `label`\n * or `icon` are NOT future additions to this interface. See:\n * `docs/superpowers/specs/2026-05-24-node-traits-reframe-design.md`.\n */\nexport interface NodeRoutingEntry {\n  /** Unique kind name. Routing tables key on this string. Consumer-defined;\n   *  the kit places no constraint beyond uniqueness within a registry. */\n  name: string;\n  /** Predicate over a node's `data` payload. First registered kind whose\n   *  `matches` returns true claims the node. */\n  matches: (data: unknown) => boolean;\n}\n\n/**\n * NodeRouting — the **routing trait's** registry. Each trait of a\n * node (shape, routing, label, icon, affordances, …) is its own\n * registry; this one answers \"what routing-kind string does this\n * node's data map to?\" The result flows into declarative tool-routing\n * tables (`{ target: 'rect', actionId: 'move' }`).\n *\n * Other traits (shape painters, future label/icon/propertyRows\n * registries) are their own registries — they are NOT optional\n * fields on `NodeRoutingEntry`. See:\n * `docs/superpowers/specs/2026-05-24-node-traits-reframe-design.md`.\n *\n * Instances are constructed by `<SceneCanvas>` from its `routing` prop\n * and used to classify each hit node's `data` into a `kind` string when\n * building `getNodeAtPoint`. Direct use from consumer code is supported\n * but not required for the common SceneCanvas flow.\n */\nexport interface NodeRouting {\n  /** Register a kind. Order matters: first match wins during `classify`.\n   *  Throws if a kind with this name is already registered. */\n  register(kind: NodeRoutingEntry): void;\n  /** Walk registered kinds in registration order; return the first kind\n   *  whose `matches(data)` returns true, or `'unknown'` if none match. */\n  classify(data: unknown): string;\n  /** Lookup a kind entry by name. */\n  get(name: string): NodeRoutingEntry | undefined;\n  /** Enumerate registered kinds in registration order. */\n  list(): readonly NodeRoutingEntry[];\n}\n\n/** Build a registry of per-node-kind routing entries, which decide how a node\n *  kind is drawn, hit-tested and serialized. Registering a duplicate kind name\n *  throws. */\nexport function createNodeRouting(): NodeRouting {\n  const entries: NodeRoutingEntry[] = [];\n  const byName = new Map<string, NodeRoutingEntry>();\n  return {\n    register(kind) {\n      if (byName.has(kind.name)) {\n        throw new Error(\n          `createNodeRouting: duplicate kind name \"${kind.name}\"`,\n        );\n      }\n      byName.set(kind.name, kind);\n      entries.push(kind);\n    },\n    classify(data) {\n      for (const kind of entries) {\n        if (kind.matches(data)) return kind.name;\n      }\n      return 'unknown';\n    },\n    get(name) {\n      return byName.get(name);\n    },\n    list() {\n      return entries;\n    },\n  };\n}\n"],"mappings":";AAmDA,SAAgBA,IAAiC;CAC/C,IAAMC,IAA8B,CAAC,GAC/BC,oBAAS,IAAI,IAA8B;CACjD,OAAO;EACL,SAAS,GAAM;GACb,IAAIA,EAAO,IAAIC,EAAK,IAAI,GACtB,MAAU,MACR,2CAA2CA,EAAK,KAAK,EACvD;GAGF,AADAD,EAAO,IAAIC,EAAK,MAAMA,CAAI,GAC1BF,EAAQ,KAAKE,CAAI;EACnB;EACA,SAAS,GAAM;GACb,KAAK,IAAMA,KAAQF,GACjB,IAAIE,EAAK,QAAQC,CAAI,GAAG,OAAOD,EAAK;GAEtC,OAAO;EACT;EACA,IAAI,GAAM;GACR,OAAOD,EAAO,IAAIG,CAAI;EACxB;EACA,OAAO;GACL,OAAOJ;EACT;CACF;AACF"}

package/dist/core/scene/arrivals.js

@@ -0,0 +1,12 @@
+//#region src/core/scene/arrivals.ts
+var e = class extends Error {
+	arrivals;
+	constructor(e) {
+		let t = [...e.keys()].map((e) => `"${e}"`).join(", ");
+		super(`Scene: ${t} refused the nodes joining it`), this.name = "SceneArrivalRefused", this.arrivals = e;
+	}
+};
+//#endregion
+export { e as SceneArrivalRefused };
+
+//# sourceMappingURL=arrivals.js.map

package/dist/core/scene/arrivals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrivals.js","names":["SceneArrivalRefused","where","arrivals","id"],"sources":["../../../src/core/scene/arrivals.ts"],"sourcesContent":["import type { NodeId } from './types';\n\n/**\n * Thrown by a scene edit — `batch`, `untracked`, or a bare `add` / `move` —\n * whose arrivals the scene's arrival handler refused. The edit has already\n * been reverted when this reaches the caller. An op-driven edit\n * (`applyBatch`, `history.applyOps`, a journal's `applyBatch`) is reverted\n * the same way but does not throw: nothing lands, as with a drop onto a\n * container that takes none.\n */\nexport class SceneArrivalRefused extends Error {\n  /** The nodes refused, by the container they were joining. */\n  readonly arrivals: ReadonlyMap<NodeId, readonly NodeId[]>;\n\n  constructor(arrivals: ReadonlyMap<NodeId, readonly NodeId[]>) {\n    const where = [...arrivals.keys()].map((id) => `\"${id}\"`).join(', ');\n    super(`Scene: ${where} refused the nodes joining it`);\n    this.name = 'SceneArrivalRefused';\n    this.arrivals = arrivals;\n  }\n}\n"],"mappings":";AAUA,IAAaA,IAAb,cAAyC,MAAM;CAE7C;CAEA,YAAY,GAAkD;EAC5D,IAAMC,IAAQ,CAAC,GAAGC,EAAS,KAAK,CAAC,CAAC,CAAC,KAAK,MAAO,IAAIC,EAAG,EAAE,CAAC,CAAC,KAAK,IAAI;EAGnE,AAFA,MAAM,UAAUF,EAAM,8BAA8B,GACpD,KAAK,OAAO,uBACZ,KAAK,WAAWC;CAClB;AACF"}

package/dist/core/scene/composeFrame.js

@@ -0,0 +1,29 @@
+//#region src/core/scene/composeFrame.ts
+var e = {
+	compose: (e, t) => t,
+	decompose: (e, t) => t,
+	closure: "identity"
+};
+function t(e, t, n) {
+	let r = [t], i = /* @__PURE__ */ new Set([t]), a = e.getParent(t);
+	for (; a !== null && !i.has(a);) i.add(a), (e.definesFrame?.(a) ?? !0) && r.push(a), a = e.getParent(a);
+	let o = e.getPose(r[r.length - 1]);
+	for (let t = r.length - 2; t >= 0; t--) o = n(o, e.getPose(r[t]));
+	return o;
+}
+function n(e, n, i, a, o) {
+	let s = r(e, i);
+	return s === null ? n : o(t(e, s, a), n);
+}
+function r(e, t) {
+	let n = /* @__PURE__ */ new Set(), r = t;
+	for (; r !== null && !n.has(r);) {
+		if (e.definesFrame?.(r) ?? !0) return r;
+		n.add(r), r = e.getParent(r);
+	}
+	return null;
+}
+//#endregion
+export { e as IDENTITY_POSE_COMPOSITION, t as composeWorldPose, r as frameAtOrAbove, n as rebaseLocalPose };
+
+//# sourceMappingURL=composeFrame.js.map

package/dist/core/scene/composeFrame.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"composeFrame.js","names":["IDENTITY_POSE_COMPOSITION","child","world","composeWorldPose","chain","id","seen","cursor","adapter","i","compose","rebaseLocalPose","frame","frameAtOrAbove","newParentId","worldPose","decompose"],"sources":["../../../src/core/scene/composeFrame.ts"],"sourcesContent":["/**\n * Folding a node's pose up its parent chain to world, and back down. Lives\n * under `core/` so the scene can lay out in world without reaching up into\n * `features/`; `features/groups/composePose` re-exports all of it.\n */\n\n/** Minimal adapter needed by `composeWorldPose` and friends — pose lookup plus parent walk. */\nexport interface PoseAdapter<TPose> {\n  getPose(id: string): TPose;\n  getParent(id: string): string | null;\n  /** Whether `id`'s pose is a frame its children are expressed in. Absent\n   *  means every node is one. A container whose pose derives from its children\n   *  is not: its children share its frame, so the fold passes over it. */\n  definesFrame?(id: string): boolean;\n}\n\n/**\n * The transforms a `compose` represents **exactly**. A parent transform wider\n * than its strategy's closure is rounded to the nearest pose — for `'rigid'`\n * that means an anisotropically scaled parent turns a rotated child into a\n * parallelogram, which `{x, y, width, height, rotation}` cannot hold, so the\n * shear is dropped.\n *\n * Measured over 50,000 random parent/child pairs: rotation and translation\n * compose to within 5.7e-13, anisotropic scale to a right-angle error of 0.99.\n * See `docs/superpowers/specs/2026-09-10-group-as-frame-design.md`.\n */\nexport type PoseClosure = 'identity' | 'translation' | 'rigid';\n\n/** Consumer's pose-composition strategy for hierarchical scenes. `compose`\n *  folds a child's pose (in parent's frame) up to the next frame; `decompose`\n *  is its inverse. Default is IDENTITY — an absolute-pose scene where every\n *  node already stores world coords (parent is grouping-only, no transform). */\nexport interface PoseComposition<TPose> {\n  compose: (parent: TPose, child: TPose) => TPose;\n  decompose: (parent: TPose, world: TPose) => TPose;\n  closure: PoseClosure;\n}\n\n/** Default pose-composition strategy: IDENTITY. Both `compose` and\n *  `decompose` return the child/world pose unchanged, modeling an\n *  absolute-pose scene where every node stores world coords and parents are\n *  grouping-only (no transform). With this strategy `composeWorldPose`\n *  returns a node's own raw pose and `rebaseLocalPose` is a no-op. */\nexport const IDENTITY_POSE_COMPOSITION: PoseComposition<unknown> = {\n  compose: (_parent, child) => child,\n  decompose: (_parent, world) => world,\n  closure: 'identity',\n};\n\n/**\n * Walk `id`'s parent chain (root first to id last) and fold local poses into\n * a world pose via `compose`. Returns the world pose for `id`. Cycle-safe:\n * a visited-set guard breaks if the chain ever loops back to itself.\n *\n * `compose(parent, child)` interprets `child` as expressed *in `parent`'s\n * local frame* and returns the equivalent pose in the next frame up. For a\n * standard translation-only rect: `world = { x: p.x + c.x, y: p.y + c.y,\n * width: c.width, height: c.height }`.\n */\nexport function composeWorldPose<TPose>(\n  adapter: PoseAdapter<TPose>,\n  id: string,\n  compose: (parent: TPose, child: TPose) => TPose,\n): TPose {\n  const chain: string[] = [id];\n  const seen = new Set<string>([id]);\n  let cursor: string | null = adapter.getParent(id);\n  while (cursor !== null) {\n    if (seen.has(cursor)) break;\n    seen.add(cursor);\n    if (adapter.definesFrame?.(cursor) ?? true) chain.push(cursor);\n    cursor = adapter.getParent(cursor);\n  }\n  // chain is [id, parent, grandparent, ..., root]; fold from the root down.\n  let world = adapter.getPose(chain[chain.length - 1]);\n  for (let i = chain.length - 2; i >= 0; i--) {\n    world = compose(world, adapter.getPose(chain[i]));\n  }\n  return world;\n}\n\n/**\n * Convert `worldPose` into a local pose expressed under `newParentId`'s\n * frame. Used when reparenting so the child's visual world position is\n * preserved despite the change of frame. Inverse of one `compose` step.\n *\n * `decompose(parent, world)` returns the local pose `child` such that\n * `compose(parent, child) === world`. For axis-aligned rects:\n * `child = { ...world, x: world.x - parent.x, y: world.y - parent.y }`.\n *\n * Pass `newParentId === null` for the root frame; the function returns\n * `worldPose` unchanged.\n */\nexport function rebaseLocalPose<TPose>(\n  adapter: PoseAdapter<TPose>,\n  worldPose: TPose,\n  newParentId: string | null,\n  compose: (parent: TPose, child: TPose) => TPose,\n  decompose: (parent: TPose, world: TPose) => TPose,\n): TPose {\n  const frame = frameAtOrAbove(adapter, newParentId);\n  if (frame === null) return worldPose;\n  return decompose(composeWorldPose(adapter, frame, compose), worldPose);\n}\n\n/** The nearest node at or above `id` whose pose is a frame, or `null` for the\n *  root frame. Cycle-safe, like `composeWorldPose`. */\nexport function frameAtOrAbove<TPose>(\n  adapter: PoseAdapter<TPose>,\n  id: string | null,\n): string | null {\n  const seen = new Set<string>();\n  let cursor = id;\n  while (cursor !== null && !seen.has(cursor)) {\n    if (adapter.definesFrame?.(cursor) ?? true) return cursor;\n    seen.add(cursor);\n    cursor = adapter.getParent(cursor);\n  }\n  return null;\n}\n"],"mappings":";AA4CA,IAAaA,IAAsD;CACjE,UAAU,GAAS,MAAUC;CAC7B,YAAY,GAAS,MAAUC;CAC/B,SAAS;AACX;AAYA,SAAgBC,EACd,GACA,GACA,GACO;CACP,IAAMC,IAAkB,CAACC,CAAE,GACrBC,oBAAO,IAAI,IAAY,CAACD,CAAE,CAAC,GAC7BE,IAAwBC,EAAQ,UAAUH,CAAE;CAChD,OAAOE,MAAW,QACZ,GAAK,IAAIA,CAAM,IAGnB,AAFAD,EAAK,IAAIC,CAAM,IACXC,EAAQ,eAAeD,CAAM,KAAK,OAAMH,EAAM,KAAKG,CAAM,GAC7D,IAASC,EAAQ,UAAUD,CAAM;CAGnC,IAAIL,IAAQM,EAAQ,QAAQJ,EAAMA,EAAM,SAAS,EAAE;CACnD,KAAK,IAAIK,IAAIL,EAAM,SAAS,GAAGK,KAAK,GAAG,KACrC,IAAQC,EAAQR,GAAOM,EAAQ,QAAQJ,EAAMK,EAAE,CAAC;CAElD,OAAOP;AACT;AAcA,SAAgBS,EACd,GACA,GACA,GACA,GACA,GACO;CACP,IAAMC,IAAQC,EAAeL,GAASM,CAAW;CAEjD,OADIF,MAAU,OAAaG,IACpBC,EAAUb,EAAiBK,GAASI,GAAOF,CAAO,GAAGK,CAAS;AACvE;AAIA,SAAgBF,EACd,GACA,GACe;CACf,IAAMP,oBAAO,IAAI,IAAY,GACzBC,IAASF;CACb,OAAOE,MAAW,QAAQ,CAACD,EAAK,IAAIC,CAAM,IAAG;EAC3C,IAAIC,EAAQ,eAAeD,CAAM,KAAK,IAAM,OAAOA;EAEnD,AADAD,EAAK,IAAIC,CAAM,GACf,IAASC,EAAQ,UAAUD,CAAM;CACnC;CACA,OAAO;AACT"}

package/dist/core/scene/depMemo.js

@@ -0,0 +1,18 @@
+import { samePoseValue as e, snapshotPose as t } from "./poseSnapshot.js";
+//#region src/core/scene/depMemo.ts
+function n(e, n) {
+	e.nodes.length = 0, e.poses.length = 0;
+	for (let r of n) e.nodes.push(r?.node), e.poses.push(r === void 0 ? void 0 : t(r.pose));
+}
+function r(t, n, r) {
+	if (t.nodes.length !== n.length) return !1;
+	for (let i = 0; i < n.length; i++) {
+		let a = r(n[i]);
+		if (t.nodes[i] !== (a === void 0 ? void 0 : a.node) || a !== void 0 && !e(t.poses[i], a.pose)) return !1;
+	}
+	return !0;
+}
+//#endregion
+export { n as recordDeps, r as sameDeps };
+
+//# sourceMappingURL=depMemo.js.map

package/dist/core/scene/depMemo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"depMemo.js","names":["recordDeps","dep","deps","into","snapshotPose","sameDeps","record","ids","depOf","samePoseValue"],"sources":["../../../src/core/scene/depMemo.ts"],"sourcesContent":["/**\n * What a memoized derivation was derived *from*, so a hit can re-check it.\n *\n * A derivation keyed on the deriving node's own authored pose only notices a\n * change someone pushed. A dependency that moved with nothing pushed behind\n * it — an ancestor's frame moving, a removal, a dependency appearing — is\n * invisible to that key. Recording each dependency's node identity and a copy\n * of the pose it resolved to, and comparing both on the hit path, is what\n * notices it without a trigger.\n */\nimport { samePoseValue, snapshotPose } from './poseSnapshot';\nimport type { DerivedDep, NodeId } from './types';\n\n/** Each dependency's node — an identity, so a restored clone is a different\n *  one — and a copy of the pose it resolved to. */\nexport interface DepRecord<TPose> {\n  nodes: (object | undefined)[];\n  poses: (TPose | undefined)[];\n}\n\n/** Record what `deps` resolved to, in place. Mutating the record is what\n *  updates the memo slot, which holds this object. */\nexport function recordDeps<TPose>(\n  into: DepRecord<TPose>,\n  deps: readonly (DerivedDep<TPose> | undefined)[],\n): void {\n  into.nodes.length = 0;\n  into.poses.length = 0;\n  for (const dep of deps) {\n    into.nodes.push(dep?.node);\n    into.poses.push(dep === undefined ? undefined : snapshotPose(dep.pose));\n  }\n}\n\n/** Whether the dependencies still resolve to the same nodes at the same poses\n *  the record was taken from. Resolves them one at a time rather than taking\n *  an array: this is the hit path, and it walks every derived node's every\n *  dependency on every frame. */\nexport function sameDeps<TPose>(\n  record: DepRecord<TPose>,\n  ids: readonly NodeId[],\n  depOf: (id: NodeId) => DerivedDep<TPose> | undefined,\n): boolean {\n  if (record.nodes.length !== ids.length) return false;\n  for (let i = 0; i < ids.length; i++) {\n    const dep = depOf(ids[i]);\n    if (record.nodes[i] !== (dep === undefined ? undefined : dep.node)) return false;\n    if (dep !== undefined && !samePoseValue(record.poses[i], dep.pose)) return false;\n  }\n  return true;\n}\n"],"mappings":";;AAsBA,SAAgBA,EACd,GACA,GACM;CAEN,AADA,EAAK,MAAM,SAAS,GACpB,EAAK,MAAM,SAAS;CACpB,KAAK,IAAMC,KAAOC,GAEhB,AADAC,EAAK,MAAM,KAAKF,GAAK,IAAI,GACzBE,EAAK,MAAM,KAAKF,MAAQ,KAAA,IAAY,KAAA,IAAYG,EAAaH,EAAI,IAAI,CAAC;AAE1E;AAMA,SAAgBI,EACd,GACA,GACA,GACS;CACT,IAAIC,EAAO,MAAM,WAAWC,EAAI,QAAQ,OAAO;CAC/C,KAAK,IAAI,IAAI,GAAG,IAAIA,EAAI,QAAQ,KAAK;EACnC,IAAMN,IAAMO,EAAMD,EAAI,EAAE;EAExB,IADID,EAAO,MAAM,QAAQL,MAAQ,KAAA,IAAY,KAAA,IAAYA,EAAI,SACzDA,MAAQ,KAAA,KAAa,CAACQ,EAAcH,EAAO,MAAM,IAAIL,EAAI,IAAI,GAAG,OAAO;CAC7E;CACA,OAAO;AACT"}

package/dist/core/scene/dependents.js

@@ -0,0 +1,66 @@
+//#region src/core/scene/dependents.ts
+var e = Object.freeze([]);
+function t(t, n) {
+	let r = t.dependsOn;
+	return r === void 0 ? e : r === "children" ? n(t.id) : r;
+}
+function n() {
+	let t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map();
+	function r(e) {
+		let r = n.get(e);
+		if (r !== void 0) {
+			for (let n of r) {
+				let r = t.get(n);
+				r !== void 0 && (r.delete(e), r.size === 0 && t.delete(n));
+			}
+			n.delete(e);
+		}
+	}
+	return {
+		add(e, i) {
+			if (r(e), i.length !== 0) {
+				n.set(e, [...i]);
+				for (let n of i) {
+					let r = t.get(n);
+					r === void 0 && (r = /* @__PURE__ */ new Set(), t.set(n, r)), r.add(e);
+				}
+			}
+		},
+		remove(e) {
+			r(e);
+		},
+		clear() {
+			t.clear(), n.clear();
+		},
+		isEmpty() {
+			return t.size === 0;
+		},
+		dependentsOf(n) {
+			let r = t.get(n);
+			return r === void 0 ? e : [...r];
+		},
+		transitiveDependentsOf(n) {
+			let r = t.get(n);
+			if (r === void 0) return e;
+			let i = /* @__PURE__ */ new Set(), a = [...r];
+			for (; a.length > 0;) {
+				let e = a.pop();
+				if (!i.has(e)) {
+					i.add(e);
+					for (let n of t.get(e) ?? []) a.push(n);
+				}
+			}
+			return i;
+		}
+	};
+}
+function r(e, t) {
+	if (e === t) return !0;
+	if (e === void 0 || t === void 0 || e === "children" || t === "children" || e.length !== t.length) return !1;
+	for (let n = 0; n < e.length; n++) if (e[n] !== t[n]) return !1;
+	return !0;
+}
+//#endregion
+export { n as createDependentsIndex, t as dependencyIdsOf, r as sameDependsOn };
+
+//# sourceMappingURL=dependents.js.map

package/dist/core/scene/dependents.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependents.js","names":["NONE","dependencyIdsOf","deps","node","childrenOf","createDependentsIndex","forward","reverse","detachOwnDeps","old","id","dep","set","direct","out","stack","next","d","sameDependsOn","a","b","i"],"sources":["../../../src/core/scene/dependents.ts"],"sourcesContent":["/**\n * Which nodes must recompute when a given node's pose changes — the reverse\n * index, plus {@link dependencyIdsOf}, the forward read it is built from.\n */\nimport type { NodeId } from './types';\n\nconst NONE: readonly NodeId[] = Object.freeze([]);\n\n/**\n * The nodes `node`'s geometry derives from: the ids it named, or its own\n * children when it named `'children'`.\n *\n * The `'children'` form is deliberately absent from the reverse index — a\n * container is not a dependent of the children it hugs, or deleting one child\n * would cascade the whole group away. Its invalidation is the ancestor walk in\n * `scene.ts` instead.\n */\nexport function dependencyIdsOf(\n  node: { id: NodeId; dependsOn?: readonly NodeId[] | 'children' },\n  childrenOf: (id: NodeId) => readonly NodeId[],\n): readonly NodeId[] {\n  const deps = node.dependsOn;\n  if (deps === undefined) return NONE;\n  return deps === 'children' ? childrenOf(node.id) : deps;\n}\n\nexport interface DependentsIndex {\n  add(id: NodeId, deps: readonly NodeId[]): void;\n  /** Forget what `id` declared. Deliberately not symmetric: who depends on\n   *  `id` is those nodes' declaration, not `id`'s, and outlives its removal. */\n  remove(id: NodeId): void;\n  /** Forget every registration. */\n  clear(): void;\n  /** True when nothing derives from anything. */\n  isEmpty(): boolean;\n  dependentsOf(id: NodeId): Iterable<NodeId>;\n  /** Nodes that derive from `id` directly or through a chain. Excludes `id`\n   *  itself unless a cycle leads back to it. */\n  transitiveDependentsOf(id: NodeId): Iterable<NodeId>;\n}\n\nexport function createDependentsIndex(): DependentsIndex {\n  /** dependency -> nodes deriving from it */\n  const forward = new Map<NodeId, Set<NodeId>>();\n  /** dependent -> the dependencies it registered against */\n  const reverse = new Map<NodeId, readonly NodeId[]>();\n\n  /** Drop `id`'s registrations against its current dependencies. Shared by\n   *  `add` (which re-registers after) and `remove` (which does not). */\n  function detachOwnDeps(id: NodeId): void {\n    const old = reverse.get(id);\n    if (old === undefined) return;\n    for (const dep of old) {\n      const set = forward.get(dep);\n      if (set === undefined) continue;\n      set.delete(id);\n      if (set.size === 0) forward.delete(dep);\n    }\n    reverse.delete(id);\n  }\n\n  return {\n    add(id, deps) {\n      detachOwnDeps(id);\n      if (deps.length === 0) return;\n      reverse.set(id, [...deps]);\n      for (const dep of deps) {\n        let set = forward.get(dep);\n        if (set === undefined) { set = new Set(); forward.set(dep, set); }\n        set.add(id);\n      }\n    },\n\n    remove(id) {\n      detachOwnDeps(id);\n    },\n\n    clear() {\n      forward.clear();\n      reverse.clear();\n    },\n\n    isEmpty() {\n      return forward.size === 0;\n    },\n\n    dependentsOf(id) {\n      const set = forward.get(id);\n      return set === undefined ? NONE : [...set];\n    },\n\n    transitiveDependentsOf(id) {\n      // Runs per node per frame; the miss must not allocate.\n      const direct = forward.get(id);\n      if (direct === undefined) return NONE;\n      const out = new Set<NodeId>();\n      const stack: NodeId[] = [...direct];\n      while (stack.length > 0) {\n        const next = stack.pop()!;\n        if (out.has(next)) continue;   // also what stops a cycle\n        out.add(next);\n        for (const d of forward.get(next) ?? []) stack.push(d);\n      }\n      return out;\n    },\n  };\n}\n\n/**\n * Whether two `dependsOn` values name the same thing, so a retarget to what a\n * node already declares can be elided. Order is part of it: a router reads its\n * ends positionally, and swapping them reverses the edge.\n */\nexport function sameDependsOn(\n  a: readonly NodeId[] | 'children' | undefined,\n  b: readonly NodeId[] | 'children' | undefined,\n): boolean {\n  if (a === b) return true;\n  if (a === undefined || b === undefined) return false;\n  if (a === 'children' || b === 'children') return false;\n  if (a.length !== b.length) return false;\n  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;\n  return true;\n}\n"],"mappings":";AAMA,IAAMA,IAA0B,OAAO,OAAO,CAAC,CAAC;AAWhD,SAAgBC,EACd,GACA,GACmB;CACnB,IAAMC,IAAOC,EAAK;CAElB,OADID,MAAS,KAAA,IAAkBF,IACxBE,MAAS,aAAaE,EAAWD,EAAK,EAAE,IAAID;AACrD;AAiBA,SAAgBG,IAAyC;CAEvD,IAAMC,oBAAU,IAAI,IAAyB,GAEvCC,oBAAU,IAAI,IAA+B;CAInD,SAASC,EAAc,GAAkB;EACvC,IAAMC,IAAMF,EAAQ,IAAIG,CAAE;EAC1B,IAAID,MAAQ,KAAA,GACZ;QAAK,IAAME,KAAOF,GAAK;IACrB,IAAMG,IAAMN,EAAQ,IAAIK,CAAG;IAC3B,AAAIC,MAAQ,KAAA,MACZA,EAAI,OAAOF,CAAE,GACTE,EAAI,SAAS,KAAGN,EAAQ,OAAOK,CAAG;GACxC;GACA,EAAQ,OAAOD,CAAE;EADjB;CAEF;CAEA,OAAO;EACL,IAAI,GAAI,GAAM;GAEZ,IADAF,EAAcE,CAAE,GACZR,EAAK,WAAW,GACpB;MAAQ,IAAIQ,GAAI,CAAC,GAAGR,CAAI,CAAC;IACzB,KAAK,IAAMS,KAAOT,GAAM;KACtB,IAAIU,IAAMN,EAAQ,IAAIK,CAAG;KAEzB,AADIC,MAAQ,KAAA,MAAa,oBAAM,IAAI,IAAI,GAAGN,EAAQ,IAAIK,GAAKC,CAAG,IAC9DA,EAAI,IAAIF,CAAE;IACZ;GALyB;EAM3B;EAEA,OAAO,GAAI;GACT,EAAcA,CAAE;EAClB;EAEA,QAAQ;GAEN,AADAJ,EAAQ,MAAM,GACdC,EAAQ,MAAM;EAChB;EAEA,UAAU;GACR,OAAOD,EAAQ,SAAS;EAC1B;EAEA,aAAa,GAAI;GACf,IAAMM,IAAMN,EAAQ,IAAII,CAAE;GAC1B,OAAOE,MAAQ,KAAA,IAAYZ,IAAO,CAAC,GAAGY,CAAG;EAC3C;EAEA,uBAAuB,GAAI;GAEzB,IAAMC,IAASP,EAAQ,IAAII,CAAE;GAC7B,IAAIG,MAAW,KAAA,GAAW,OAAOb;GACjC,IAAMc,oBAAM,IAAI,IAAY,GACtBC,IAAkB,CAAC,GAAGF,CAAM;GAClC,OAAOE,EAAM,SAAS,IAAG;IACvB,IAAMC,IAAOD,EAAM,IAAI;IACvB,IAAI,GAAI,IAAIC,CAAI,GAChB;OAAI,IAAIA,CAAI;KACZ,KAAK,IAAMC,KAAKX,EAAQ,IAAIU,CAAI,KAAK,CAAC,GAAG,EAAM,KAAKC,CAAC;IADzC;GAEd;GACA,OAAOH;EACT;CACF;AACF;AAOA,SAAgBI,EACd,GACA,GACS;CACT,IAAIC,MAAMC,GAAG,OAAO;CAGpB,IAFID,MAAM,KAAA,KAAaC,MAAM,KAAA,KACzBD,MAAM,cAAcC,MAAM,cAC1BD,EAAE,WAAWC,EAAE,QAAQ,OAAO;CAClC,KAAK,IAAIC,IAAI,GAAGA,IAAIF,EAAE,QAAQ,KAAK,IAAIA,EAAEE,OAAOD,EAAEC,IAAI,OAAO;CAC7D,OAAO;AACT"}

package/dist/core/scene/derivedPath.js

@@ -0,0 +1,31 @@
+import { dropPoseKeyedMemoSlots as e, nodeMemo as t } from "./nodeMemo.js";
+import { recordDeps as n, sameDeps as r } from "./depMemo.js";
+import { dependencyIdsOf as i } from "./dependents.js";
+//#region src/core/scene/derivedPath.ts
+var a = "kit:derivedPath", o = /* @__PURE__ */ new Set(), s = 0;
+function c(n, c, u, d = a) {
+	let f = n.derivePath;
+	if (f === void 0) return null;
+	let p = i(n, u);
+	if (p.length === 0) return null;
+	if (o.has(n.id)) return s++, null;
+	o.add(n.id);
+	let m = s;
+	try {
+		let i = !1, a = t(n, d, n.pose, () => (i = !0, l(n, f, p.map(c), {
+			nodes: [],
+			poses: [],
+			path: null
+		})));
+		return !i && !r(a, p, c) && l(n, f, p.map(c), a), s !== m && e(n), a.path;
+	} finally {
+		o.delete(n.id);
+	}
+}
+function l(e, t, r, i) {
+	return i.path = t(e, r), n(i, r), i;
+}
+//#endregion
+export { c as resolveDerivedPath };
+
+//# sourceMappingURL=derivedPath.js.map

package/dist/core/scene/derivedPath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"derivedPath.js","names":["SLOT","resolving","cycleHits","resolveDerivedPath","derivePath","node","ids","dependencyIdsOf","childrenOf","hitsBefore","computed","record","nodeMemo","memoSlot","draw","depOf","sameDeps","dropPoseKeyedMemoSlots","deps","recordDeps","into"],"sources":["../../../src/core/scene/derivedPath.ts"],"sourcesContent":["/**\n * `resolveDerivedPath` — the path a node computes from its dependencies.\n *\n * It sits beside `derivedPose` rather than in `canvas/` because a *pose* can\n * now derive from a dependency's path: an edge label is positioned along the\n * route it labels, and `effectivePose` is what resolves it. The render walk's\n * wrapper stays in `canvas/derivedPath.ts`.\n *\n * Invalidation is both pushed and pulled. The scene pushes — dropping the\n * dependent's memo slot on the edits it performs — and on a memo hit this\n * module re-resolves the dependencies and compares their poses *by value*\n * against the ones the cached path was drawn from. The pull is what covers a\n * dependency that moved with no scene edit behind it: a lookup answering poses\n * of its own (`sceneDepLookup(scene, toPose)`), an ancestor's frame moving, a\n * dependency appearing or going away. Value, not reference: a pose override\n * mutates its buffer in place, so the reference never moves.\n *\n * The pull covers poses only. A derivation is handed each dependency's whole\n * node, so one reading `data` or `layer` still rides on the scene's push.\n */\nimport type { Path } from '@weasel-js/geom';\nimport { dependencyIdsOf } from './dependents';\nimport { dropPoseKeyedMemoSlots, nodeMemo } from './nodeMemo';\nimport { recordDeps, sameDeps, type DepRecord } from './depMemo';\nimport type { DerivedDep, NodeId } from './types';\n\nconst SLOT = 'kit:derivedPath';\n\n/** The subset of a node this module reads. Structural so a `Node` satisfies it\n *  without importing the full generic shape. */\nexport interface PathDerivingNode<TPose> {\n  id: NodeId;\n  pose: TPose;\n  /** Read only by the memo, which keys on its reference alongside the pose. */\n  data?: unknown;\n  dependsOn?: readonly NodeId[] | 'children';\n  derivePath?: (\n    node: never,\n    deps: readonly (DerivedDep<TPose> | undefined)[],\n  ) => Path | null;\n}\n\n/** A cached path, with what it was drawn from. */\ninterface PathMemo<TPose> extends DepRecord<TPose> {\n  path: Path | null;\n}\n\n/** Ids whose path is on the stack. A dependency graph is meant to be acyclic\n *  and `dependsOn` is unvalidated; now that a path can read another path, a\n *  cycle has to resolve to `null` at whichever node closes it rather than\n *  overflowing the stack. */\nconst resolving = new Set<NodeId>();\n\n/** Bumped each time the guard above fires, so a value computed from a\n *  fallback is not cached — it is an artifact of which node was asked first. */\nlet cycleHits = 0;\n\n/**\n * The path `node` computes from its dependencies, or `null` when it derives\n * from nothing (the normal case) or its `derivePath` has nothing to draw.\n *\n * `depOf` supplies each dependency — its node, the pose it is painted at, and\n * its own path; one it cannot resolve reaches `derivePath` as `undefined`.\n * `childrenOf` answers a node whose `dependsOn` is `'children'`.\n *\n * `memoSlot` separates a `depOf` that answers different poses than the scene's\n * own — the memo key cannot see which lookup filled it.\n */\nexport function resolveDerivedPath<TPose>(\n  node: PathDerivingNode<TPose>,\n  depOf: (id: NodeId) => DerivedDep<TPose> | undefined,\n  childrenOf: (id: NodeId) => readonly NodeId[],\n  memoSlot: string = SLOT,\n): Path | null {\n  const derivePath = node.derivePath;\n  if (derivePath === undefined) return null;\n  const ids = dependencyIdsOf(node, childrenOf);\n  if (ids.length === 0) return null;\n  if (resolving.has(node.id)) {\n    cycleHits++;\n    return null;\n  }\n  resolving.add(node.id);\n  const hitsBefore = cycleHits;\n  try {\n    let computed = false;\n    const record = nodeMemo<PathMemo<TPose>>(node, memoSlot, node.pose, () => {\n      computed = true;\n      return draw(node, derivePath, ids.map(depOf), { nodes: [], poses: [], path: null });\n    });\n    // Mutating the record in place is what updates the memo slot, which holds\n    // this object.\n    if (!computed && !sameDeps(record, ids, depOf)) {\n      draw(node, derivePath, ids.map(depOf), record);\n    }\n    if (cycleHits !== hitsBefore) dropPoseKeyedMemoSlots(node);\n    return record.path;\n  } finally {\n    resolving.delete(node.id);\n  }\n}\n\n/** Run `derivePath` against `deps` and record what it was run against. */\nfunction draw<TPose>(\n  node: PathDerivingNode<TPose>,\n  derivePath: NonNullable<PathDerivingNode<TPose>['derivePath']>,\n  deps: readonly (DerivedDep<TPose> | undefined)[],\n  into: PathMemo<TPose>,\n): PathMemo<TPose> {\n  into.path = derivePath(node as never, deps);\n  recordDeps(into, deps);\n  return into;\n}\n\n"],"mappings":";;;;AA0BA,IAAMA,IAAO,mBAyBPC,oBAAY,IAAI,IAAY,GAI9BC,IAAY;AAahB,SAAgBC,EACd,GACA,GACA,GACA,IAAmBH,GACN;CACb,IAAMI,IAAaC,EAAK;CACxB,IAAID,MAAe,KAAA,GAAW,OAAO;CACrC,IAAME,IAAMC,EAAgBF,GAAMG,CAAU;CAC5C,IAAIF,EAAI,WAAW,GAAG,OAAO;CAC7B,IAAIL,EAAU,IAAII,EAAK,EAAE,GAEvB,OADA,KACO;CAET,EAAU,IAAIA,EAAK,EAAE;CACrB,IAAMI,IAAaP;CACnB,IAAI;EACF,IAAIQ,IAAW,IACTC,IAASC,EAA0BP,GAAMQ,GAAUR,EAAK,aAC5D,IAAW,IACJS,EAAKT,GAAMD,GAAYE,EAAI,IAAIS,CAAK,GAAG;GAAE,OAAO,CAAC;GAAG,OAAO,CAAC;GAAG,MAAM;EAAK,CAAC,EACnF;EAOD,OAJI,CAACL,KAAY,CAACM,EAASL,GAAQL,GAAKS,CAAK,KAC3CD,EAAKT,GAAMD,GAAYE,EAAI,IAAIS,CAAK,GAAGJ,CAAM,GAE3CT,MAAcO,KAAYQ,EAAuBZ,CAAI,GAClDM,EAAO;CAChB,UAAU;EACR,EAAU,OAAON,EAAK,EAAE;CAC1B;AACF;AAGA,SAASS,EACP,GACA,GACA,GACA,GACiB;CAGjB,OAFA,EAAK,OAAOV,EAAWC,GAAea,CAAI,GAC1CC,EAAWC,GAAMF,CAAI,GACdE;AACT"}