@weasel-js/core 1.7.0 → 1.7.1

package/dist/core/gradient.js

@@ -0,0 +1,136 @@
+import { resolveColor as e, rgbaToHex as t } from "../renderer/math/color.js";
+import { lerpColorArray as n } from "@weasel-js/paint";
+//#region src/core/gradient.ts
+function r(e) {
+	return e == null ? !1 : e.fill === "linear-gradient" || e.fill === "radial-gradient" || e.fill === "conic-gradient";
+}
+function i(t) {
+	return [...t].sort((e, t) => e.offset - t.offset).map((t) => ({
+		offset: t.offset,
+		rgba: e(t.color)
+	}));
+}
+function a(e, t, r = "rgb") {
+	if (e.length === 0) return o;
+	let i = e[0], a = e[e.length - 1];
+	if (t <= i.offset) return i.rgba;
+	if (t >= a.offset) return a.rgba;
+	for (let i = 0; i < e.length - 1; i++) {
+		let a = e[i], o = e[i + 1];
+		if (t < a.offset || t > o.offset) continue;
+		let s = o.offset - a.offset;
+		if (s <= 0) return o.rgba;
+		let c = (t - a.offset) / s, [l, u, d, f] = n(a.rgba, o.rgba, c, r);
+		return [
+			l,
+			u,
+			d,
+			f
+		];
+	}
+	return a.rgba;
+}
+var o = [
+	0,
+	0,
+	0,
+	0
+];
+function s(e, n, r = "rgb") {
+	return e.length === 0 ? "rgba(0,0,0,0)" : t(a(i(e), n, r));
+}
+function c(e, t) {
+	if (e.fill === t) return e;
+	let n = {
+		stops: e.stops,
+		units: e.units,
+		interpolate: e.interpolate,
+		opacity: e.opacity
+	}, { center: r, radius: i, angle: a } = l(e);
+	if (t === "linear-gradient") {
+		let e = Math.cos(a) * i, t = Math.sin(a) * i;
+		return {
+			fill: "linear-gradient",
+			from: {
+				x: r.x - e,
+				y: r.y - t
+			},
+			to: {
+				x: r.x + e,
+				y: r.y + t
+			},
+			...n
+		};
+	}
+	return t === "radial-gradient" ? {
+		fill: "radial-gradient",
+		center: r,
+		radius: i,
+		...n
+	} : {
+		fill: "conic-gradient",
+		center: r,
+		angle: a,
+		...n
+	};
+}
+function l(e) {
+	if (e.fill === "linear-gradient") {
+		let t = e.to.x - e.from.x, n = e.to.y - e.from.y;
+		return {
+			center: {
+				x: (e.from.x + e.to.x) / 2,
+				y: (e.from.y + e.to.y) / 2
+			},
+			radius: Math.hypot(t, n) / 2,
+			angle: Math.atan2(n, t)
+		};
+	}
+	return e.fill === "radial-gradient" ? {
+		center: e.center,
+		radius: e.radius,
+		angle: 0
+	} : {
+		center: e.center,
+		radius: u(e.units),
+		angle: e.angle
+	};
+}
+function u(e) {
+	return e === "bounds" ? .5 : 50;
+}
+function d(e, t, n, r) {
+	let i = {
+		x: t.x + t.width / 2,
+		y: t.y + t.height / 2
+	};
+	return e === "linear-gradient" ? {
+		fill: "linear-gradient",
+		from: {
+			x: t.x,
+			y: i.y
+		},
+		to: {
+			x: t.x + t.width,
+			y: i.y
+		},
+		stops: n,
+		units: r
+	} : e === "radial-gradient" ? {
+		fill: "radial-gradient",
+		center: i,
+		radius: Math.max(t.width, t.height) / 2,
+		stops: n,
+		units: r
+	} : {
+		fill: "conic-gradient",
+		center: i,
+		angle: 0,
+		stops: n,
+		units: r
+	};
+}
+//#endregion
+export { d as gradientForBounds, l as gradientGeometry, r as isGradientFill, i as resolveGradientStops, s as sampleGradientStops, a as sampleResolvedStops, c as withGradientKind };
+
+//# sourceMappingURL=gradient.js.map

package/dist/core/gradient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gradient.js","names":["isGradientFill","fill","resolveGradientStops","stops","a","b","s","resolveColor","sampleResolvedStops","TRANSPARENT","first","last","lo","hi","span","f","r","g","lerpColorArray","space","sampleGradientStops","rgbaToHex","t","withGradientKind","kind","common","gradientGeometry","dx","angle","radius","dy","center","conicArmRadius","units","gradientForBounds","bounds"],"sources":["../../src/core/gradient.ts"],"sourcesContent":["/**\n * Gradient helpers shared by renderers, editors and exporters: reading a\n * color out of a stop list, and moving a gradient between its three kinds.\n *\n * The stop list is the part every consumer agrees on; the geometry\n * (`from`/`to`, `center`, `radius`, `angle`) differs per kind, which is what\n * `withGradientKind` exists to translate.\n */\n\nimport { resolveColor, rgbaToHex } from '../renderer/math/color';\nimport { lerpColorArray } from '@weasel-js/paint';\nimport type { ColorSpace, FillStyle, GradStop, GradientFill, GradientKind } from '@weasel-js/paint';\n\n/** A stop with its color already parsed to 0..1 RGBA. */\nexport interface ResolvedGradientStop {\n  offset: number;\n  rgba: readonly [number, number, number, number];\n}\n\n/** Narrow a paint to the gradient members of `FillStyle`. The three\n *  discriminants are the union's own definition of `GradientFill`, so every\n *  consumer that reaches for gradient geometry starts here. */\nexport function isGradientFill(fill: FillStyle | null | undefined): fill is GradientFill {\n  if (fill == null) return false;\n  return fill.fill === 'linear-gradient'\n    || fill.fill === 'radial-gradient'\n    || fill.fill === 'conic-gradient';\n}\n\n/**\n * Sort a stop list by offset and parse each color to 0..1 RGBA — the reading\n * of a stop list that `sampleResolvedStops` works from, hoisted out so a\n * caller sampling many positions (the GL ramp) parses each color once.\n *\n * Colors go through `resolveColor`, so any CSS color the kit understands is a\n * legal stop, not just hex.\n */\nexport function resolveGradientStops(stops: readonly GradStop[]): ResolvedGradientStop[] {\n  return [...stops]\n    .sort((a, b) => a.offset - b.offset)\n    .map((s) => ({ offset: s.offset, rgba: resolveColor(s.color) }));\n}\n\n/**\n * RGBA (0..1) at position `t` along resolved stops: flat extension past\n * either end, interpolation between neighbors in `space`, alpha included.\n *\n * The single definition of what a stop list means. The GL ramp texture bakes\n * this at 256 positions and an editor calls it per pixel of a track; a second\n * implementation is a gradient that paints differently from its own swatch.\n *\n * `space` is a gradient's `interpolate`. Alpha is linear in every space —\n * only the color channels travel through OKLab or OKLCh.\n *\n * Returns transparent black for an empty list.\n */\nexport function sampleResolvedStops(\n  stops: readonly ResolvedGradientStop[], t: number, space: ColorSpace = 'rgb',\n): readonly [number, number, number, number] {\n  if (stops.length === 0) return TRANSPARENT;\n  const first = stops[0];\n  const last = stops[stops.length - 1];\n  if (t <= first.offset) return first.rgba;\n  if (t >= last.offset) return last.rgba;\n\n  for (let i = 0; i < stops.length - 1; i++) {\n    const lo = stops[i];\n    const hi = stops[i + 1];\n    if (t < lo.offset || t > hi.offset) continue;\n    const span = hi.offset - lo.offset;\n    // Coincident stops are a hard color break: take the later one.\n    if (span <= 0) return hi.rgba;\n    const f = (t - lo.offset) / span;\n    const [r, g, b, a] = lerpColorArray(lo.rgba, hi.rgba, f, space);\n    return [r, g, b, a];\n  }\n  return last.rgba;\n}\n\nconst TRANSPARENT: readonly [number, number, number, number] = [0, 0, 0, 0];\n\n/**\n * Color at position `t` (0..1) along a stop list, as a hex string — the same\n * sampling the GL ramp texture bakes, so an editor track and the painted\n * gradient cannot disagree.\n *\n * Returns transparent black for an empty list.\n */\nexport function sampleGradientStops(\n  stops: readonly GradStop[], t: number, space: ColorSpace = 'rgb',\n): string {\n  if (stops.length === 0) return 'rgba(0,0,0,0)';\n  return rgbaToHex(sampleResolvedStops(resolveGradientStops(stops), t, space));\n}\n\n/**\n * Retarget a gradient to a different kind, preserving stops, `units` and\n * `opacity`, and carrying the geometry across as faithfully as the kinds\n * allow.\n *\n * Linear carries a segment; radial and conic carry a center. Converting\n * between them keeps the center fixed and reads the radius / angle off the\n * segment, so switching kind in an editor moves the paint as little as\n * possible instead of snapping to an arbitrary default.\n *\n * Lossy in both directions, because the kinds hold different information: a\n * radial gradient stores no angle, so a round trip through one leaves the\n * segment horizontal; a conic stores no radius, so a round trip through one\n * resets the segment's length. An editor that wants a kind switch to be\n * undoable should keep the original paint rather than converting back.\n */\nexport function withGradientKind(fill: GradientFill, kind: GradientKind): GradientFill {\n  if (fill.fill === kind) return fill;\n  const common = {\n    stops: fill.stops, units: fill.units,\n    interpolate: fill.interpolate, opacity: fill.opacity,\n  };\n  const { center, radius, angle } = gradientGeometry(fill);\n\n  if (kind === 'linear-gradient') {\n    const dx = Math.cos(angle) * radius;\n    const dy = Math.sin(angle) * radius;\n    return {\n      fill: 'linear-gradient',\n      from: { x: center.x - dx, y: center.y - dy },\n      to: { x: center.x + dx, y: center.y + dy },\n      ...common,\n    };\n  }\n  if (kind === 'radial-gradient') {\n    return { fill: 'radial-gradient', center, radius, ...common };\n  }\n  return { fill: 'conic-gradient', center, angle, ...common };\n}\n\n/**\n * Center / radius / angle for any gradient kind — the shared polar reading\n * `withGradientKind` converts through, and what on-canvas handles position\n * themselves from.\n *\n * For a linear gradient the center is the segment midpoint, the radius is\n * half its length, and the angle is its direction.\n */\nexport function gradientGeometry(fill: GradientFill): {\n  center: { x: number; y: number };\n  radius: number;\n  angle: number;\n} {\n  if (fill.fill === 'linear-gradient') {\n    const dx = fill.to.x - fill.from.x;\n    const dy = fill.to.y - fill.from.y;\n    return {\n      center: { x: (fill.from.x + fill.to.x) / 2, y: (fill.from.y + fill.to.y) / 2 },\n      radius: Math.hypot(dx, dy) / 2,\n      angle: Math.atan2(dy, dx),\n    };\n  }\n  if (fill.fill === 'radial-gradient') {\n    return { center: fill.center, radius: fill.radius, angle: 0 };\n  }\n  return { center: fill.center, radius: conicArmRadius(fill.units), angle: fill.angle };\n}\n\n/**\n * Conic gradients carry no radius, but converting one to a linear or radial\n * gradient needs a non-zero length to build from.\n *\n * Unit-dependent, and that is the whole point: `'bounds'` geometry runs `0..1`\n * across the box, so a pixel-flavored default there does not mean \"a bit under\n * half the box\", it means fifty times it.\n */\nfunction conicArmRadius(units: GradientFill['units']): number {\n  return units === 'bounds' ? 0.5 : 50;\n}\n\n/**\n * A gradient spanning a box left edge to right edge through its vertical\n * center (linear) or filling it (radial / conic) — the sensible starting\n * geometry when a consumer turns a solid fill into a gradient and has only\n * the shape's bounds to go on.\n */\nexport function gradientForBounds(\n  kind: GradientKind,\n  bounds: { x: number; y: number; width: number; height: number },\n  stops: GradStop[],\n  units?: GradientFill['units'],\n): GradientFill {\n  const center = { x: bounds.x + bounds.width / 2, y: bounds.y + bounds.height / 2 };\n  if (kind === 'linear-gradient') {\n    return {\n      fill: 'linear-gradient',\n      from: { x: bounds.x, y: center.y },\n      to: { x: bounds.x + bounds.width, y: center.y },\n      stops,\n      units,\n    };\n  }\n  if (kind === 'radial-gradient') {\n    return {\n      fill: 'radial-gradient',\n      center,\n      radius: Math.max(bounds.width, bounds.height) / 2,\n      stops,\n      units,\n    };\n  }\n  return { fill: 'conic-gradient', center, angle: 0, stops, units };\n}\n"],"mappings":"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"}

package/dist/core/isPlainObject.js

@@ -0,0 +1,11 @@
+//#region src/core/isPlainObject.ts
+function e(e) {
+	return e === Object.prototype || e === null || Object.getPrototypeOf(e) === null;
+}
+function t(t) {
+	return typeof t == "object" && !!t && e(Object.getPrototypeOf(t));
+}
+//#endregion
+export { t as isPlainObject, e as isPlainPrototype };
+
+//# sourceMappingURL=isPlainObject.js.map

package/dist/core/isPlainObject.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isPlainObject.js","names":["isPlainPrototype","proto","isPlainObject","value"],"sources":["../../src/core/isPlainObject.ts"],"sourcesContent":["/** Whether `proto` is the prototype a plain object has: `null`, or some\n *  realm's `Object.prototype`. Comparing against this realm's alone misses\n *  objects made in an iframe, a VM context, or by `structuredClone` under jsdom. */\nexport function isPlainPrototype(proto: object | null): boolean {\n  return proto === Object.prototype || proto === null || Object.getPrototypeOf(proto) === null;\n}\n\n/** Whether `value` is a plain object — a literal or `Object.create(null)` — from any realm. */\nexport function isPlainObject(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && isPlainPrototype(Object.getPrototypeOf(value));\n}\n"],"mappings":";AAGA,SAAgBA,EAAiB,GAA+B;CAC9D,OAAOC,MAAU,OAAO,aAAaA,MAAU,QAAQ,OAAO,eAAeA,CAAK,MAAM;AAC1F;AAGA,SAAgBC,EAAc,GAAkD;CAC9E,OAAO,OAAOC,KAAU,cAAYA,KAAkBH,EAAiB,OAAO,eAAeG,CAAK,CAAC;AACrG"}

package/dist/core/layers/render.js

@@ -0,0 +1,150 @@
+import { viewToMat3 as e } from "../../renderer/math/viewToMat3.js";
+//#region src/core/layers/render.ts
+var t = {
+	x: 0,
+	y: 0,
+	scale: {
+		x: 1,
+		y: 1
+	}
+};
+function n({ layerId: e, error: t }) {
+	console.error(`[weasel] layer "${e}" threw while drawing; it painted nothing this frame.`, t);
+}
+function r(e) {
+	return (t) => {
+		let n = (typeof e == "function" ? e() : e).flatMap((e) => e.subscribe ? [e.subscribe(t)] : []);
+		return () => {
+			for (let e of n) e();
+		};
+	};
+}
+function i() {
+	return typeof performance < "u" ? performance.now() : Date.now();
+}
+function a(e, r, a, l, d, f, p, m = n, h, g) {
+	let _ = new Map(e.map((e) => [e.id, e])), v = l ? l.map((e) => _.get(e)).filter((e) => e !== void 0) : e, y = d ?? t, b = [];
+	if (p) for (let e of [...p.keys()]) _.has(e) || p.delete(e);
+	let x = o(h, _.keys()), S = /* @__PURE__ */ new Set(), C = null, w = () => {
+		if (!C) return;
+		let e = b.length, t = g ? i() : 0;
+		for (let e of s(C.group, C.children, y, f)) b.push(e);
+		g?.push({
+			id: C.group.id,
+			start: e,
+			end: b.length,
+			buildMs: C.buildMs + i() - t
+		}), C = null;
+	};
+	for (let e of v) {
+		if (!c(e, a)) continue;
+		let t = g ? i() : 0, n = u(e, r, y, f, p, m), o = g ? i() - t : 0;
+		if (n.length === 0) {
+			g?.push({
+				id: e.id,
+				start: b.length,
+				end: b.length,
+				buildMs: o
+			});
+			continue;
+		}
+		let s = x?.get(e.id);
+		if (C && C.group !== s && w(), !s) {
+			let t = b.length;
+			for (let e of n) b.push(e);
+			g?.push({
+				id: e.id,
+				start: t,
+				end: b.length,
+				buildMs: o
+			});
+			continue;
+		}
+		C ||= (S.has(s) && console.warn(`[weasel] layer group "${s.id}" is not one run — another layer is drawn between its members, so it composites as more than one pass over more than one buffer. Move its members together in the layer order.`), S.add(s), {
+			group: s,
+			children: [],
+			buildMs: 0
+		}), C.buildMs += o;
+		for (let e of n) C.children.push(e);
+	}
+	return w(), b;
+}
+function o(e, t) {
+	if (!e || e.length === 0) return null;
+	let n = [...t], r = /* @__PURE__ */ new Map();
+	for (let t of e) for (let e of t.layers) {
+		let i = !1;
+		for (let a of n) {
+			if (a !== e && !a.startsWith(`${e}:`)) continue;
+			i = !0;
+			let n = r.get(a);
+			if (n !== t) {
+				if (n) {
+					console.warn(`[weasel] layer "${a}" is claimed by layer groups "${n.id}" and "${t.id}"; it stays in "${n.id}".`);
+					continue;
+				}
+				r.set(a, t);
+			}
+		}
+		i || console.warn(`[weasel] layer group "${t.id}" names "${e}", which matches no layer being drawn, so it groups nothing. Check the id against the layer stack — a scene with declared layers draws as "scene:<layerId>", which "scene" covers.`);
+	}
+	return r;
+}
+function s(e, t, n, r) {
+	let i = typeof e.effects == "function" ? e.effects(n, r) : e.effects, a = i && i.length > 0 ? i : void 0;
+	return !a && e.alpha === void 0 && e.colorMatrix === void 0 ? t : [{
+		kind: "group",
+		...a ? { effects: a } : {},
+		...e.alpha === void 0 ? {} : { alpha: e.alpha },
+		...e.colorMatrix === void 0 ? {} : { colorMatrix: e.colorMatrix },
+		children: t
+	}];
+}
+function c(e, t) {
+	return e.alwaysOn ? !0 : e.id in t ? t[e.id] : e.defaultVisible ?? !0;
+}
+function l(e, t, n) {
+	return n && !n.includes(e.id) ? !1 : c(e, t);
+}
+function u(t, r, i, a, o, s = n) {
+	let c;
+	try {
+		c = d(t, r, i, a, o);
+	} catch (e) {
+		return o?.delete(t.id), s({
+			layerId: t.id,
+			error: e
+		}), [];
+	}
+	if (c.length === 0) return [];
+	let l = t.effects && t.effects.length > 0 ? t.effects : void 0;
+	return (t.space ?? "world") === "screen" ? l ? [{
+		kind: "group",
+		effects: l,
+		children: c
+	}] : c : [{
+		kind: "group",
+		transform: e(i),
+		...l ? { effects: l } : {},
+		children: c
+	}];
+}
+function d(e, t, n, r, i) {
+	if (!i || !e.deps) return e.draw(t, n, r);
+	let a = e.deps(t, n, r), o = i.get(e.id);
+	if (o && f(o.deps, a)) return o.cmds;
+	let s = e.draw(t, n, r);
+	return i.set(e.id, {
+		deps: a,
+		cmds: s
+	}), s;
+}
+function f(e, t) {
+	if (e.length !== t.length) return !1;
+	for (let n = 0; n < e.length; n++) if (!Object.is(e[n], t[n])) return !1;
+	return !0;
+}
+//#endregion
+export { f as depsUnchanged, a as drawLayers, u as drawOneLayer, l as isLayerPainted, c as isLayerVisible, r as subscribeToSources };
+
+//# sourceMappingURL=render.js.map

package/dist/core/layers/render.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.js","names":["IDENTITY_VIEW","reportLayerFailure","layerId","error","subscribeToSources","offs","sources","l","listener","off","clockMs","drawLayers","layerById","layers","sequence","order","id","v","view","out","cache","groupOf","groupMembership","groups","bracketed","run","closeRun","start","t0","spans","c","wrapGroup","dims","layer","isLayerVisible","visibility","cmds","drawOneLayer","data","onLayerError","buildMs","group","stack","layerIds","byLayer","name","matched","claimed","declared","effects","children","isLayerPainted","layerCommands","viewToMat3","deps","entry","depsUnchanged","a","b","i"],"sources":["../../../src/core/layers/render.ts"],"sourcesContent":["import { viewToMat3, type DrawCommand } from '../../renderer';\nimport type { Effect } from '../../renderer/effects/types';\nimport type { View } from 'core/viewport/view';\n\nconst IDENTITY_VIEW: View = { x: 0, y: 0, scale: { x: 1, y: 1 } };\n\n/**\n * Canvas size in CSS pixels — passed to `draw` for layers that anchor to\n * canvas edges (e.g. the debug overlay's layer-list panel). The GL backend\n * supplies it explicitly so layers don't have to know about DPR.\n */\nexport interface Dims {\n  width: number;\n  height: number;\n}\n\n/**\n * What a layer's `draw` threw, and which layer threw it.\n *\n * A `draw` runs on the frame loop, so a throw that escapes it surfaces as an\n * uncaught `requestAnimationFrame` error on the window and takes the whole\n * frame with it — every other layer included. One broken layer painting\n * nothing, named in the console, is the lesser wrong.\n */\nexport interface LayerDrawFailure {\n  layerId: string;\n  error: unknown;\n}\n\n/** Default report: name the layer, keep the frame. */\nfunction reportLayerFailure({ layerId, error }: LayerDrawFailure): void {\n  console.error(\n    `[weasel] layer \"${layerId}\" threw while drawing; it painted nothing this frame.`,\n    error,\n  );\n}\n\n/**\n * Several consecutive layers composited as one.\n *\n * A layer's own `effects` run over that layer alone, which is the wrong\n * picture whenever a pass reads neighboring pixels: `blur(A over B)` is not\n * `blur(A) over blur(B)`, and it costs a buffer and a pass chain per layer. A\n * group draws its members into one buffer, runs one chain over it, and\n * composites the result back once.\n *\n * Membership is by `RenderLayer.id` — the same names `layerOrder` and\n * `layerVisibility` use, not the `layers` map's slot keys.\n *\n * Only *consecutive* members share a buffer, because anything drawn between\n * two members has to land between them. A group whose members are separated in\n * the render order is drawn as one bracket per run, with a warning: the\n * picture is right, the declaration almost certainly is not.\n *\n * This is a render-stack bracket, not a scene `ContainerNode` — it holds no\n * ids, survives no reload, and nothing in the scene knows about it.\n */\nexport interface LayerGroup {\n  /** Names the group in warnings; not a layer id and never drawn. */\n  id: string;\n  /**\n   * Member layer ids. Order here is ignored — the render order decides.\n   *\n   * A name claims that layer and every layer under it in the `:` namespace, so\n   * `'scene'` covers the `scene:<layerId>` layers a scene with declared layers\n   * draws as — the same set `before`/`after: 'scene'` anchors against. The\n   * separator is required: `'scene'` does not reach `scenery`. A name matching\n   * no layer being drawn is warned about rather than ignored.\n   */\n  layers: readonly string[];\n  /**\n   * Passes over the group's combined pixels, in order. A thunk is re-read on\n   * every frame, so an animating radius costs no React render; an array is\n   * read once per frame either way.\n   */\n  effects?: readonly Effect[] | ((view: View, dims: Dims) => readonly Effect[]);\n  /** Opacity applied to the group's composited result, not to each member. */\n  alpha?: number;\n  /** 4×5 color matrix (row-major, 20 numbers) applied to the composited\n   *  result. See `GroupDrawCommand.colorMatrix`. */\n  colorMatrix?: number[];\n}\n\n/** One layer's memoized output, keyed by layer id. Owned by the canvas that\n *  calls `drawLayers`, not by `drawLayers` itself — the function is pure. */\nexport type LayerCommandCache = Map<\n  string,\n  { deps: readonly unknown[]; cmds: DrawCommand[] }\n>;\n\n/**\n * A single named render sub-layer within a canvas renderer.\n *\n * @template TData - The data object passed to each draw call.\n */\n/** Something outside React whose changes a paint reads — a mode registry, a\n *  scoping lookup. A notification repaints the canvas; the listener takes no\n *  arguments and the returned function unsubscribes. */\nexport interface RedrawSource {\n  subscribe(listener: () => void): () => void;\n}\n\n/** The `subscribe` for a layer that draws `sources`: it notifies whenever any\n *  of them does. A thunk is read when the subscription is made. Every layer\n *  that draws other layers declares this, so wrapping never silences what\n *  repaints a source. */\nexport function subscribeToSources(\n  sources: readonly { subscribe?: RedrawSource['subscribe'] }[]\n    | (() => readonly { subscribe?: RedrawSource['subscribe'] }[]),\n): RedrawSource['subscribe'] {\n  return (listener) => {\n    const list = typeof sources === 'function' ? sources() : sources;\n    const offs = list.flatMap((l) => (l.subscribe ? [l.subscribe(listener)] : []));\n    return () => { for (const off of offs) off(); };\n  };\n}\n\n/** One layer of a canvas: `draw` turns `data` and the view into draw commands;\n *  the other fields control caching, visibility, coordinate space and hit-testing. */\nexport interface RenderLayer<TData> {\n  /** Unique identifier used in visibility maps and ordering arrays. When a\n   *  cache is in use, an id must identify the same logical layer across\n   *  frames — reusing it for a different layer can serve cross-layer commands. */\n  id: string;\n  /** Human-readable name for UI toggles. */\n  label: string;\n  /**\n   * Emit a DrawCommand tree for the GL backend to dispatch.\n   *\n   * For world-space layers (the default), emit commands in WORLD COORDS —\n   * `drawLayers` automatically wraps them in `{ kind: 'group', transform:\n   * viewToMat3(view), ... }` before handing them to the renderer. Do NOT\n   * apply the view transform yourself.\n   *\n   * For screen-space layers (`space: 'screen'`), emit commands in CSS-pixel\n   * coords directly; `drawLayers` passes them through unchanged. If part\n   * of a screen-space layer's output needs to track the view, wrap that\n   * subset manually with `viewToMat3(view)`.\n   */\n  draw: (data: TData, view: View, dims: Dims) => DrawCommand[];\n  /**\n   * Optional cache key. When present and a `LayerCommandCache` is supplied to\n   * `drawLayers`, the layer's previous `DrawCommand[]` is reused as long as\n   * every entry is `Object.is`-equal to the previous call's. A layer with no\n   * `deps` rebuilds on every frame.\n   *\n   * **The returned commands must be treated as immutable.** A cached tree is\n   * handed to the renderer again on later frames, so mutating a tree you\n   * previously returned corrupts the cache silently rather than erroring.\n   *\n   * **Screen-space layers are not protected against a stale `view`/`dims`\n   * the way world-space layers are** (see `space` below) — include them in\n   * `deps` if `draw` reads them.\n   */\n  deps?: (data: TData, view: View, dims: Dims) => readonly unknown[];\n  /**\n   * Whether the layer is shown when no explicit visibility entry exists.\n   * Defaults to `true` when absent.\n   */\n  defaultVisible?: boolean;\n  /**\n   * When true, the layer is always drawn regardless of the visibility map.\n   * Useful for layers that must never be hidden (e.g. base grid).\n   */\n  alwaysOn?: boolean;\n  /**\n   * Coordinate space the layer draws in.\n   *\n   * - `'world'` (default): the layer's `draw` returns world-space commands;\n   *   `drawLayers` wraps them in a `kind: 'group'` with `viewToMat3(view)`\n   *   automatically.\n   * - `'screen'`: the layer's `draw` returns screen-space (CSS-pixel)\n   *   commands; `drawLayers` passes them through unchanged. World-anchored\n   *   chrome inside a screen-space layer must call `worldToScreen` or wrap\n   *   the relevant subset with `viewToMat3(view)` manually.\n   */\n  space?: 'world' | 'screen';\n  /**\n   * Where the layer learns that state `draw` reads, outside the scene and the\n   * props, has changed. The canvas painting it subscribes while the layer is\n   * mounted and repaints on every notification, so a layer reading a mode\n   * registry needs no consumer code to follow a mode switch.\n   */\n  subscribe?: RedrawSource['subscribe'];\n  /**\n   * Full-screen passes run over this layer's own pixels before it joins the\n   * frame — a blur here blurs the world and leaves the HUD drawn above it\n   * sharp, which is the thing a CSS `filter` on the `<canvas>` cannot do.\n   *\n   * Costs nothing while empty: the renderer allocates no offscreen buffer\n   * until a layer actually declares one. See `GroupDrawCommand.effects` for\n   * what a pass may read, and {@link LayerGroup} to run one chain over\n   * several layers at once instead of one chain each.\n   */\n  effects?: readonly Effect[];\n  /**\n   * Optional hit-test for **consumer-attached** layers.\n   *\n   * Only layers registered through `CanvasExtensionApi.registerLayer` are\n   * hit-tested: `hitTestExtras` walks them last-registered-first on\n   * pointerdown, and `<SceneCanvas>` folds the result into its `affordanceAt`\n   * thunk ahead of the kit's own selection chrome. First non-null result\n   * wins; null means \"I don't claim this hit, try the next layer.\"\n   *\n   * Layers that reach the draw stack some other way — a `Tool.overlay`, an\n   * entry in the `layers` map — are painted but never hit-tested, so defining\n   * `hitTest` on one has no effect. (The kit's own chrome doesn't need it: it\n   * goes through `buildAffordanceAt`.)\n   *\n   * Coordinates are world-space. The `data` arg is the layer's\n   * configured data slot (same as `draw`); `view` and `dims` mirror\n   * `draw`'s arguments.\n   */\n  hitTest?: (\n    worldX: number,\n    worldY: number,\n    data: TData,\n    view: View,\n    dims: Dims,\n    /** Chrome-caps visibility predicate. When supplied, the layer must\n     *  not return a hit from any chrome element whose id reports\n     *  `false`. Absent → every element is hittable. */\n    isVisible?: (id: string) => boolean,\n  ) => import('../../affordances/types').LayerHit | null;\n  /**\n   * Called on every pointermove when no gesture is currently captured.\n   * Lets layers (e.g. HUD widgets) track hover state without participating\n   * in the drag pipeline. Coords are world-space; the layer is responsible\n   * for any further conversion (e.g. world→screen for screen-space layers)\n   * and for its own throttling.\n   */\n  onUncapturedMove?: (\n    worldX: number,\n    worldY: number,\n    evt: PointerEvent,\n    view: View,\n    dims: Dims,\n  ) => void;\n  /**\n   * Called when the cursor leaves the canvas element. Lets layers clear\n   * any hover state they're holding.\n   */\n  onUncapturedLeave?: () => void;\n}\n\n/** Where one layer's commands landed in {@link drawLayers}' output,\n *  `[start, end)`, and the CPU milliseconds its `draw` took. A layer group's\n *  run is one span under the group's id. */\nexport interface LayerDrawSpan {\n  id: string;\n  start: number;\n  end: number;\n  buildMs: number;\n}\n\nfunction clockMs(): number {\n  return typeof performance !== 'undefined' ? performance.now() : Date.now();\n}\n\n/**\n * Walk visible layers and concatenate their emitted DrawCommand arrays into\n * one flat list, ready to feed to `WeaselRenderer.render(commands)`.\n *\n * Visibility resolution order:\n *   1. `alwaysOn` — always drawn, ignores visibility map.\n *   2. Explicit entry in `visibility` map — overrides default.\n *   3. `layer.defaultVisible` — falls back to `true` when absent.\n *\n * Transform composition: world-space layers (the default; `space` unset or\n * `'world'`) have their commands wrapped in a `kind: 'group'` with\n * `viewToMat3(view)` before they reach the renderer. Screen-space layers\n * (`space: 'screen'`) pass through unchanged.\n *\n * A layer whose `draw` throws is dropped for the frame and reported through\n * `onLayerError` — the rest of the frame still paints.\n *\n * `groups` brackets runs of consecutive layers so they composite as one — see\n * `LayerGroup`. A layer named by no group is emitted exactly as it was before\n * groups existed, and a frame that declares none allocates nothing.\n *\n * `spans`, when passed, receives one {@link LayerDrawSpan} per layer drawn.\n */\nexport function drawLayers<TData>(\n  layers: RenderLayer<TData>[],\n  data: TData,\n  visibility: Record<string, boolean>,\n  order: string[] | undefined,\n  view: View | undefined,\n  dims: Dims,\n  cache?: LayerCommandCache,\n  onLayerError: (failure: LayerDrawFailure) => void = reportLayerFailure,\n  groups?: readonly LayerGroup[],\n  spans?: LayerDrawSpan[],\n): DrawCommand[] {\n  const layerById = new Map(layers.map((l) => [l.id, l]));\n  const sequence = order\n    ? order.map((id) => layerById.get(id)).filter((l): l is RenderLayer<TData> => l !== undefined)\n    : layers;\n  const v = view ?? IDENTITY_VIEW;\n  const out: DrawCommand[] = [];\n\n  if (cache) {\n    for (const id of [...cache.keys()]) {\n      if (!layerById.has(id)) cache.delete(id);\n    }\n  }\n\n  const groupOf = groupMembership(groups, layerById.keys());\n  const bracketed = new Set<LayerGroup>();\n  let run: { group: LayerGroup; children: DrawCommand[]; buildMs: number } | null = null;\n\n  const closeRun = () => {\n    if (!run) return;\n    const start = out.length;\n    const t0 = spans ? clockMs() : 0;\n    for (const c of wrapGroup(run.group, run.children, v, dims)) out.push(c);\n    spans?.push({ id: run.group.id, start, end: out.length, buildMs: run.buildMs + clockMs() - t0 });\n    run = null;\n  };\n\n  for (const layer of sequence) {\n    // `order` is already applied by `sequence`; passing it again would be a\n    // second, redundant lookup for the same answer.\n    if (!isLayerVisible(layer, visibility)) continue;\n\n    const t0 = spans ? clockMs() : 0;\n    const cmds = drawOneLayer(layer, data, v, dims, cache, onLayerError);\n    const buildMs = spans ? clockMs() - t0 : 0;\n    // A layer that painted nothing neither joins a run nor breaks one. Letting\n    // it break one would split a group over a debug overlay that is switched\n    // on but currently empty.\n    if (cmds.length === 0) {\n      spans?.push({ id: layer.id, start: out.length, end: out.length, buildMs });\n      continue;\n    }\n\n    const group = groupOf?.get(layer.id);\n    if (run && run.group !== group) closeRun();\n    if (!group) {\n      const start = out.length;\n      for (const c of cmds) out.push(c);\n      spans?.push({ id: layer.id, start, end: out.length, buildMs });\n      continue;\n    }\n    if (!run) {\n      if (bracketed.has(group)) {\n        console.warn(\n          `[weasel] layer group \"${group.id}\" is not one run — another layer is drawn ` +\n          'between its members, so it composites as more than one pass over more than ' +\n          'one buffer. Move its members together in the layer order.',\n        );\n      }\n      bracketed.add(group);\n      run = { group, children: [], buildMs: 0 };\n    }\n    run.buildMs += buildMs;\n    for (const c of cmds) run.children.push(c);\n  }\n  closeRun();\n\n  return out;\n}\n\n/**\n * Layer id → the group that owns it.\n *\n * A member name claims the layer of that exact id and every layer under it in\n * the `:` namespace, so `'scene'` claims the whole split scene slot. First\n * claim wins across groups, so a second one is a declaration bug rather than a\n * silent reassignment; the same group naming a layer twice — `['scene',\n * 'scene:tiles']` — is redundant, not a conflict, and passes quietly.\n */\nfunction groupMembership(\n  groups: readonly LayerGroup[] | undefined,\n  layerIds: Iterable<string>,\n): Map<string, LayerGroup> | null {\n  if (!groups || groups.length === 0) return null;\n  const stack = [...layerIds];\n  const byLayer = new Map<string, LayerGroup>();\n  for (const group of groups) {\n    for (const name of group.layers) {\n      let matched = false;\n      for (const id of stack) {\n        if (id !== name && !id.startsWith(`${name}:`)) continue;\n        matched = true;\n        const claimed = byLayer.get(id);\n        if (claimed === group) continue;\n        if (claimed) {\n          console.warn(\n            `[weasel] layer \"${id}\" is claimed by layer groups \"${claimed.id}\" and ` +\n            `\"${group.id}\"; it stays in \"${claimed.id}\".`,\n          );\n          continue;\n        }\n        byLayer.set(id, group);\n      }\n      if (!matched) {\n        console.warn(\n          `[weasel] layer group \"${group.id}\" names \"${name}\", which matches no layer ` +\n          'being drawn, so it groups nothing. Check the id against the layer stack — a ' +\n          'scene with declared layers draws as \"scene:<layerId>\", which \"scene\" covers.',\n        );\n      }\n    }\n  }\n  return byLayer;\n}\n\n/**\n * Put one run of a group's commands under its shared compositing.\n *\n * No transform: every member already carries its own space wrap, so a second\n * one here would apply the view twice to world layers and once to screen ones.\n * A group that composites plainly gets no wrapper at all — an extra group\n * command that changes nothing is still a push and a pop per frame.\n */\nfunction wrapGroup(\n  group: LayerGroup,\n  children: DrawCommand[],\n  view: View,\n  dims: Dims,\n): DrawCommand[] {\n  const declared = typeof group.effects === 'function'\n    ? group.effects(view, dims)\n    : group.effects;\n  const effects = declared && declared.length > 0 ? declared : undefined;\n  if (!effects && group.alpha === undefined && group.colorMatrix === undefined) return children;\n  return [{\n    kind: 'group',\n    ...(effects ? { effects } : {}),\n    ...(group.alpha !== undefined ? { alpha: group.alpha } : {}),\n    ...(group.colorMatrix !== undefined ? { colorMatrix: group.colorMatrix } : {}),\n    children,\n  }];\n}\n\n/**\n * Resolve one layer's visibility: `alwaysOn` wins, then an explicit entry in\n * `visibility`, then `defaultVisible`, defaulting to shown.\n */\nexport function isLayerVisible<TData>(\n  layer: RenderLayer<TData>,\n  visibility: Record<string, boolean>,\n): boolean {\n  if (layer.alwaysOn) return true;\n  if (layer.id in visibility) return visibility[layer.id]!;\n  return layer.defaultVisible ?? true;\n}\n\n/**\n * Does this layer reach the screen at all — both gates, in the order\n * `drawLayers` applies them.\n *\n * **A listed `order` is the whole list**, so omission from it drops a layer\n * that `visibility` would have shown, and `alwaysOn` does not rescue it.\n * Hit-testing asks this, not `isLayerVisible`: a layer that is not painted\n * but still claims pointer events is a pointer landing on nothing the user\n * can see.\n */\nexport function isLayerPainted<TData>(\n  layer: RenderLayer<TData>,\n  visibility: Record<string, boolean>,\n  order: string[] | undefined,\n): boolean {\n  if (order && !order.includes(layer.id)) return false;\n  return isLayerVisible(layer, visibility);\n}\n\n/**\n * Draw one layer and put its commands in the space its `space` declares:\n * world-space output wrapped in a `viewToMat3(view)` group, screen-space\n * output passed through.\n *\n * Anything rendering layers through a view — the canvas itself, a viewport\n * node's inner pass — goes through here. A second copy of this rule that\n * forgets the wrap draws world content at raw world coords, which looks\n * plausible at the identity view and wrong everywhere else.\n *\n * A `draw` that throws yields no commands, and `onLayerError` is told which\n * layer it was. The layer's cache entry goes with it, so the next frame is a\n * real re-attempt rather than a stale tree served under fresh deps.\n */\nexport function drawOneLayer<TData>(\n  layer: RenderLayer<TData>,\n  data: TData,\n  view: View,\n  dims: Dims,\n  cache?: LayerCommandCache,\n  onLayerError: (failure: LayerDrawFailure) => void = reportLayerFailure,\n): DrawCommand[] {\n  let cmds: DrawCommand[];\n  try {\n    cmds = layerCommands(layer, data, view, dims, cache);\n  } catch (error) {\n    cache?.delete(layer.id);\n    onLayerError({ layerId: layer.id, error });\n    return [];\n  }\n  if (cmds.length === 0) return [];\n  const effects = layer.effects && layer.effects.length > 0 ? layer.effects : undefined;\n  if ((layer.space ?? 'world') === 'screen') {\n    return effects ? [{ kind: 'group', effects, children: cmds }] : cmds;\n  }\n  return [{ kind: 'group', transform: viewToMat3(view), ...(effects ? { effects } : {}), children: cmds }];\n}\n\n/**\n * One layer's own commands, from cache when its deps are unchanged.\n *\n * What is cached is the layer's raw output, before the space wrap above. The\n * wrap is a function of `view`, and a layer whose content does not depend on\n * the camera is entitled to leave `view` out of its deps — caching the wrapped\n * group would then serve a stale transform the moment the camera moved.\n */\nfunction layerCommands<TData>(\n  layer: RenderLayer<TData>,\n  data: TData,\n  view: View,\n  dims: Dims,\n  cache: LayerCommandCache | undefined,\n): DrawCommand[] {\n  if (!cache || !layer.deps) return layer.draw(data, view, dims);\n\n  const deps = layer.deps(data, view, dims);\n  const entry = cache.get(layer.id);\n  if (entry && depsUnchanged(entry.deps, deps)) return entry.cmds;\n\n  const cmds = layer.draw(data, view, dims);\n  cache.set(layer.id, { deps, cmds });\n  return cmds;\n}\n\n/** Whether `b` matches `a` entry for entry under `Object.is` — how\n *  `RenderLayer.deps` is compared, and any cache keyed the same way. */\nexport function depsUnchanged(a: readonly unknown[], b: readonly unknown[]): boolean {\n  if (a.length !== b.length) return false;\n  for (let i = 0; i < a.length; i++) {\n    if (!Object.is(a[i], b[i])) return false;\n  }\n  return true;\n}\n"],"mappings":"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"}

package/dist/core/markerInset.js

@@ -0,0 +1,24 @@
+import { getMarker as e } from "./strokeMarkers.js";
+import { resolveScreenLength as t } from "@weasel-js/paint";
+//#region src/core/markerInset.ts
+function n(e, n, r = 1) {
+	return typeof e == "string" || e.size === void 0 ? n : t(e.size, r);
+}
+function r(e) {
+	return typeof e == "string" ? e : e.key;
+}
+function i(t, i, a = 1) {
+	if (t === void 0) return 0;
+	let o = e(r(t));
+	return o === void 0 ? 0 : (o.inset ?? 0) * n(t, i, a);
+}
+function a(e, t) {
+	return {
+		start: i(e.markerStart, t),
+		end: i(e.markerEnd, t)
+	};
+}
+//#endregion
+export { i as markerInset, r as markerKeyOf, n as resolveMarkerSize, a as strokeInsets };
+
+//# sourceMappingURL=markerInset.js.map

package/dist/core/markerInset.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"markerInset.js","names":["resolveMarkerSize","ref","strokeWidth","resolveScreenLength","scale","markerKeyOf","markerInset","entry","getMarker","strokeInsets","stroke"],"sources":["../../src/core/markerInset.ts"],"sourcesContent":["/**\n * Resolving a `MarkerRef` to the distance the ribbon must stop short.\n *\n * The tessellation layer takes these as plain numbers and knows nothing about\n * the registry — keeping that layer free of upward dependencies is deliberate.\n * The ribbon cache, the SVG serializer and `inkReach` all resolve through here,\n * so the ribbon, the export and the hit region cannot disagree about where the\n * line ends.\n */\n\nimport { resolveScreenLength, type MarkerRef, type Stroke } from '@weasel-js/paint';\nimport { getMarker } from './strokeMarkers';\n\n/** The size of one marker unit, in the same world units as `strokeWidth`.\n *  `scale` is the view scale a `{ px }` size resolves against, as a `{ px }`\n *  stroke width does. */\nexport function resolveMarkerSize(ref: MarkerRef, strokeWidth: number, scale = 1): number {\n  if (typeof ref === 'string' || ref.size === undefined) return strokeWidth;\n  return resolveScreenLength(ref.size, scale);\n}\n\n/** The registry key a `MarkerRef` names, whether given bare or with a size. */\nexport function markerKeyOf(ref: MarkerRef): string {\n  return typeof ref === 'string' ? ref : ref.key;\n}\n\n/**\n * How far back the ribbon stops for `ref`, in world units. Zero for an absent\n * marker, an unregistered key, or an open head — never throws, because an\n * unknown key is a data problem and dropping the head is the graceful answer.\n */\nexport function markerInset(ref: MarkerRef | undefined, strokeWidth: number, scale = 1): number {\n  if (ref === undefined) return 0;\n  const entry = getMarker(markerKeyOf(ref));\n  if (entry === undefined) return 0;\n  return (entry.inset ?? 0) * resolveMarkerSize(ref, strokeWidth, scale);\n}\n\n/** The start and end insets a stroke asks for. `markerMid` never insets —\n *  trimming at an interior vertex would cut the line in two. */\nexport function strokeInsets(stroke: Stroke, strokeWidth: number): { start: number; end: number } {\n  return {\n    start: markerInset(stroke.markerStart, strokeWidth),\n    end: markerInset(stroke.markerEnd, strokeWidth),\n  };\n}\n"],"mappings":";;;AAgBA,SAAgBA,EAAkB,GAAgB,GAAqB,IAAQ,GAAW;CAExF,OADI,OAAOC,KAAQ,YAAYA,EAAI,SAAS,KAAA,IAAkBC,IACvDC,EAAoBF,EAAI,MAAMG,CAAK;AAC5C;AAGA,SAAgBC,EAAY,GAAwB;CAClD,OAAO,OAAOJ,KAAQ,WAAWA,IAAMA,EAAI;AAC7C;AAOA,SAAgBK,EAAY,GAA4B,GAAqB,IAAQ,GAAW;CAC9F,IAAIL,MAAQ,KAAA,GAAW,OAAO;CAC9B,IAAMM,IAAQC,EAAUH,EAAYJ,CAAG,CAAC;CAExC,OADIM,MAAU,KAAA,IAAkB,KACxBA,EAAM,SAAS,KAAKP,EAAkBC,GAAKC,GAAaE,CAAK;AACvE;AAIA,SAAgBK,EAAa,GAAgB,GAAqD;CAChG,OAAO;EACL,OAAOH,EAAYI,EAAO,aAAaR,CAAW;EAClD,KAAKI,EAAYI,EAAO,WAAWR,CAAW;CAChD;AACF"}

package/dist/core/mixed.js

@@ -0,0 +1,6 @@
+//#region src/core/mixed.ts
+var e = Symbol("weasel:mixed");
+//#endregion
+export { e as MIXED };
+
+//# sourceMappingURL=mixed.js.map

package/dist/core/mixed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mixed.js","names":["MIXED"],"sources":["../../src/core/mixed.ts"],"sourcesContent":["/**\n * The kit-wide \"these values disagree\" sentinel. Used wherever a value is\n * aggregated across more than one source and the sources don't agree — e.g.\n * a UI panel aggregating a property across a multi-node selection, or text\n * styling aggregated across the runs in a character range. One symbol, one\n * `isMixed` check, regardless of what's being aggregated.\n */\nexport const MIXED: unique symbol = Symbol('weasel:mixed');\n/** The type of {@link MIXED}. Property panels use it to say \"the selection\n *  does not agree on this value\" without colliding with any real value. */\nexport type Mixed = typeof MIXED;\n"],"mappings":";AAOA,IAAaA,IAAuB,OAAO,cAAc"}

package/dist/core/ops/arrange.js

@@ -0,0 +1,31 @@
+import { registerOpFactory as e } from "./registry.js";
+//#region src/core/ops/arrange.ts
+function t(e, n, r) {
+	let i = { ...e.placed ? { placed: e.placed } : {} };
+	return {
+		name: "arrange",
+		args: i,
+		label: "Arrange",
+		get coalesceKey() {
+			return i.placed === void 0 ? void 0 : `arrange:${i.placed.map((e) => e.id).sort().join(",")}`;
+		},
+		apply(e) {
+			i.placed === void 0 && (i.placed = n?.() ?? []);
+			let t = r ?? ((t, n) => e.setPose(t, n));
+			for (let e of i.placed) t(e.id, e.to);
+			return i.placed.length > 0 ? void 0 : "noop";
+		},
+		invert() {
+			return t({ placed: [...i.placed ?? []].reverse().map((e) => ({
+				id: e.id,
+				from: e.to,
+				to: e.from
+			})) }, void 0, r);
+		}
+	};
+}
+e("arrange", (e) => t(e));
+//#endregion
+export { t as createArrangeOp };
+
+//# sourceMappingURL=arrange.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"arrange.js","names":["createArrangeOp","self","args","p","compute","set","write","adapter","id","pose","registerOpFactory"],"sources":["../../../src/core/ops/arrange.ts"],"sourcesContent":["import type { Op } from './types';\nimport { registerOpFactory } from './registry';\n\ninterface ArrangeAdapter {\n  setPose(id: string, pose: unknown): void;\n}\n\n/** One pose write an {@link createArrangeOp} made. */\nexport interface ArrangedPose {\n  id: string;\n  from: unknown;\n  to: unknown;\n}\n\n/** Arguments to {@link createArrangeOp}. */\nexport interface ArrangeArgs {\n  /** The writes to make. Absent until a computed arrangement has run once. */\n  placed?: ArrangedPose[];\n}\n\n/**\n * Op: write a set of poses decided when the op first applies, not when it is\n * built. The scene appends one to an edit that moves nodes into a container,\n * and `compute` asks the container what to do with them after the rest of\n * the edit has landed. Every later apply — redo, or a rebuild from a\n * serialized history — replays the writes it recorded, so the arrangement is\n * decided once. `write` replaces the adapter's `setPose` for this op and its\n * inverses — the scene passes its own, since not every adapter an edit is\n * applied through can write poses.\n */\nexport function createArrangeOp(\n  args: ArrangeArgs,\n  compute?: () => ArrangedPose[],\n  write?: (id: string, pose: unknown) => void,\n): Op {\n  const self: ArrangeArgs = { ...(args.placed ? { placed: args.placed } : {}) };\n  return {\n    name: 'arrange',\n    args: self,\n    label: 'Arrange',\n    // Names what it moved, so a coalesced entry never undoes to a pose only\n    // a later push wrote.\n    get coalesceKey() {\n      return self.placed === undefined ? undefined : `arrange:${self.placed.map((p) => p.id).sort().join(',')}`;\n    },\n    apply(adapter) {\n      if (self.placed === undefined) self.placed = compute?.() ?? [];\n      const set = write ?? ((id: string, pose: unknown) => (adapter as ArrangeAdapter).setPose(id, pose));\n      for (const p of self.placed) set(p.id, p.to);\n      return self.placed.length > 0 ? undefined : 'noop';\n    },\n    invert() {\n      const placed = self.placed ?? [];\n      return createArrangeOp({\n        placed: [...placed].reverse().map((p) => ({ id: p.id, from: p.to, to: p.from })),\n      }, undefined, write);\n    },\n  };\n}\n\nregisterOpFactory<ArrangeArgs>('arrange', (args) => createArrangeOp(args));\n"],"mappings":";;AA8BA,SAAgBA,EACd,GACA,GACA,GACI;CACJ,IAAMC,IAAoB,EAAE,GAAIC,EAAK,SAAS,EAAE,QAAQA,EAAK,OAAO,IAAI,CAAC,EAAG;CAC5E,OAAO;EACL,MAAM;EACN,MAAMD;EACN,OAAO;EAGP,IAAI,cAAc;GAChB,OAAOA,EAAK,WAAW,KAAA,IAAY,KAAA,IAAY,WAAWA,EAAK,OAAO,KAAK,MAAME,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,GAAG;EACxG;EACA,MAAM,GAAS;GACb,AAAIF,EAAK,WAAW,KAAA,MAAW,EAAK,SAASG,IAAU,KAAK,CAAC;GAC7D,IAAMC,IAAMC,OAAW,GAAY,MAAmBC,EAA2B,QAAQC,GAAIC,CAAI;GACjG,KAAK,IAAMN,KAAKF,EAAK,QAAQ,EAAIE,EAAE,IAAIA,EAAE,EAAE;GAC3C,OAAOF,EAAK,OAAO,SAAS,IAAI,KAAA,IAAY;EAC9C;EACA,SAAS;GAEP,OAAOD,EAAgB,EACrB,QAAQ,CAAC,GAFIC,EAAK,UAAU,CAAC,CAEX,CAAC,CAAC,QAAQ,CAAC,CAAC,KAAK,OAAO;IAAE,IAAIE,EAAE;IAAI,MAAMA,EAAE;IAAI,IAAIA,EAAE;GAAK,EAAE,EACjF,GAAG,KAAA,GAAWG,CAAK;EACrB;CACF;AACF;AAEAI,EAA+B,YAAY,MAASV,EAAgBE,CAAI,CAAC"}

package/dist/core/ops/create.js

@@ -0,0 +1,32 @@
+import { registerOpFactory as e } from "./registry.js";
+import { parentOf as t, resolveSlot as n, slotFromIndex as r } from "./slot.js";
+import { createDeleteOp as i } from "./delete.js";
+//#region src/core/ops/create.ts
+function a(e) {
+	let { node: a, label: o } = e, s = e.slot ?? r(e.index);
+	return {
+		name: "insert",
+		args: {
+			node: a,
+			label: o,
+			slot: s
+		},
+		label: o,
+		apply(e) {
+			let r = e, i = t(a);
+			r.insertNode(a, n(r.getChildren?.(i), s));
+		},
+		invert() {
+			return i({
+				node: a,
+				label: o,
+				slot: s
+			});
+		}
+	};
+}
+e("insert", (e) => a(e));
+//#endregion
+export { a as createInsertOp };
+
+//# sourceMappingURL=create.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create.js","names":["createInsertOp","args","slot","slotFromIndex","a","adapter","parentId","parentOf","node","resolveSlot","createDeleteOp","registerOpFactory"],"sources":["../../../src/core/ops/create.ts"],"sourcesContent":["import type { Op } from './types';\nimport { createDeleteOp } from './delete';\nimport { registerOpFactory } from './registry';\nimport { parentOf, resolveSlot, slotFromIndex, type OrderedReader, type SiblingSlot } from './slot';\n\ninterface InsertAdapter<TNode> extends OrderedReader {\n  /** When `index` is supplied, insert at that position; adapters that ignore\n   *  the second arg (or don't expose it) fall back to their default\n   *  placement (typically append-to-end). */\n  insertNode(node: TNode, index?: number): void;\n}\n\n/** Type alias for ops produced by `createInsertOp`. Carries no extra type info today;\n *  exists so consumers can name the op type when needed. */\nexport type InsertOp = Op;\n\n/** Arguments to {@link createInsertOp}: the node to insert and where among its siblings. */\nexport interface InsertArgs<TNode extends { id: string }> {\n  node: TNode;\n  label?: string;\n  /** Sibling ordinal to insert at. Sugar for `slot: { index }` — the weaker\n   *  of the two forms, and all a fresh-insert callsite can know. */\n  index?: number;\n  /** Full slot, anchor included. Produced only by `captureSlot` (via a\n   *  delete op's `invert`), and supersedes `index` when present. */\n  slot?: SiblingSlot;\n}\n\n/** Op: insert `node` into the scene; inverts to a delete of the same id. */\nexport function createInsertOp<TNode extends { id: string }>(args: InsertArgs<TNode>): InsertOp {\n  const { node, label } = args;\n  const slot: SiblingSlot = args.slot ?? slotFromIndex(args.index);\n  return {\n    name: 'insert',\n    args: { node, label, slot },\n    label,\n    apply(adapter) {\n      const a = adapter as InsertAdapter<TNode>;\n      const parentId = parentOf(node);\n      a.insertNode(node, resolveSlot(a.getChildren?.(parentId), slot));\n    },\n    invert() {\n      return createDeleteOp({ node, label, slot });\n    },\n  };\n}\n\nregisterOpFactory<InsertArgs<{ id: string }>>('insert', (args) => createInsertOp(args));\n"],"mappings":";;;;AA6BA,SAAgBA,EAA6C,GAAmC;CAC9F,IAAM,EAAE,SAAM,aAAUC,GAClBC,IAAoBD,EAAK,QAAQE,EAAcF,EAAK,KAAK;CAC/D,OAAO;EACL,MAAM;EACN,MAAM;GAAE;GAAM;GAAO;EAAK;EAC1B;EACA,MAAM,GAAS;GACb,IAAMG,IAAIC,GACJC,IAAWC,EAASC,CAAI;GAC9B,EAAE,WAAWA,GAAMC,EAAYL,EAAE,cAAcE,CAAQ,GAAGJ,CAAI,CAAC;EACjE;EACA,SAAS;GACP,OAAOQ,EAAe;IAAE;IAAM;IAAO;GAAK,CAAC;EAC7C;CACF;AACF;AAEAC,EAA8C,WAAW,MAASX,EAAeC,CAAI,CAAC"}

package/dist/core/ops/createHistory.js

@@ -0,0 +1,20 @@
+import { rebuildOp as e } from "./registry.js";
+import { dlog as t, dwarn as n } from "../../debug/flag.js";
+import { createHistory as r } from "@weasel-js/history";
+//#region src/core/ops/createHistory.ts
+var i = {
+	log: (e) => t("history", e),
+	warn: (e) => n("history", e)
+};
+function a(t, n = {}) {
+	let a = n.rebuildOp;
+	return r(t, {
+		debug: i,
+		...n,
+		rebuildOp: (t, n) => a?.(t, n) ?? e(t, n)
+	});
+}
+//#endregion
+export { a as createHistory };
+
+//# sourceMappingURL=createHistory.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createHistory.js","names":["createHistory","createHistoryEngine","kitLogger","dlog","message","dwarn","createHistory$1","custom","options","createHistory","adapter","name","args","rebuildOp"],"sources":["../../../src/core/ops/createHistory.ts"],"sourcesContent":["import {\n  createHistory as createHistoryEngine,\n  type History,\n  type CreateHistoryOptions,\n  type HistoryLogger,\n} from '@weasel-js/history';\nimport { rebuildOp } from './registry';\nimport { dlog, dwarn } from '../../debug/flag';\n\n/** Routes the engine's diagnostics into the kit's `history` debug namespace,\n *  so `localStorage.setItem('weasel.debug', '1')` still surfaces them. */\nconst kitLogger: HistoryLogger = {\n  log: (message) => dlog('history', message),\n  warn: (message) => dwarn('history', message),\n};\n\n/**\n * Build an op-batched undo/redo `History`, defaulting restore-time op\n * hydration to core's global op-factory registry and its diagnostics to the\n * kit's debug namespace.\n *\n * The engine in `@weasel-js/history` is registry-agnostic: it can only rebuild\n * a serialized `(name, args)` pair through the `rebuildOp` hook it is handed,\n * which is what lets that package build without depending on core. Core owns\n * the registry, so this wrapper supplies it — meaning `createHistory(adapter)`\n * with no options still restores kit-emitted ops, exactly as before.\n *\n * A caller-supplied `rebuildOp` wins; return `null` from it to fall through to\n * the registry.\n */\nexport function createHistory(adapter: unknown, options: CreateHistoryOptions = {}): History {\n  const custom = options.rebuildOp;\n  return createHistoryEngine(adapter, {\n    debug: kitLogger,\n    ...options,\n    rebuildOp: (name, args) => custom?.(name, args) ?? rebuildOp(name, args),\n  });\n}\n"],"mappings":";;;;AAWA,IAAME,IAA2B;CAC/B,MAAM,MAAYC,EAAK,WAAWC,CAAO;CACzC,OAAO,MAAYC,EAAM,WAAWD,CAAO;AAC7C;AAgBA,SAAgBJ,EAAc,GAAkB,IAAgC,CAAC,GAAY;CAC3F,IAAMO,IAASC,EAAQ;CACvB,OAAOP,EAAoBS,GAAS;EAClC,OAAOR;EACP,GAAGM;EACH,YAAY,GAAM,MAASD,IAASI,GAAMC,CAAI,KAAKC,EAAUF,GAAMC,CAAI;CACzE,CAAC;AACH"}

package/dist/core/ops/delete.js

@@ -0,0 +1,89 @@
+import { registerOpFactory as e } from "./registry.js";
+import { captureSlot as t, parentOf as n, slotFromIndex as r } from "./slot.js";
+import { createInsertOp as i } from "./create.js";
+//#region src/core/ops/delete.ts
+function a(e, t, n) {
+	return e.getChildren?.(t)?.indexOf(n) ?? -1;
+}
+function o(e, t) {
+	let { getChildren: r, getNode: i } = e;
+	if (!r || !i) return null;
+	let o = e.getRemovalClosure?.([t]), s = /* @__PURE__ */ new Map();
+	if (o) for (let t of o) {
+		let n = i.call(e, t);
+		n && s.set(t, n);
+	}
+	else {
+		let n = (t) => {
+			let a = i.call(e, t);
+			if (a) {
+				s.set(t, a);
+				for (let i of r.call(e, t)) n(i);
+			}
+		};
+		n(t);
+	}
+	let c = [...s.values()].filter((e) => {
+		let t = n(e);
+		return t === null || !s.has(t);
+	}).map((t) => ({
+		node: t,
+		index: a(e, n(t), t.id)
+	})).sort((e, t) => e.index - t.index), l = [], u = (t) => {
+		l.push(t);
+		let n = r.call(e, t.node.id);
+		for (let e = 0; e < n.length; e++) {
+			let t = s.get(n[e]);
+			t && u({
+				node: t,
+				index: e
+			});
+		}
+	};
+	for (let e of c) u(e);
+	return l;
+}
+function s(e) {
+	let { node: a, label: c } = e, l = e.slot ?? r(e.index), u = {
+		node: a,
+		label: c,
+		slot: l,
+		cascaded: e.cascaded
+	}, d = e.cascaded ?? [];
+	return {
+		name: "delete",
+		args: u,
+		label: c,
+		apply(e) {
+			let r = e, i = t(r, n(a), a.id);
+			i && (l = i, u.slot = i);
+			let s = o(r, a.id);
+			s && (d = s, u.cascaded = s), r.removeNode(a.id);
+		},
+		invert() {
+			let e = d, t = l, n = i({
+				node: a,
+				label: c,
+				slot: t
+			});
+			return e.length === 0 ? n : {
+				label: c,
+				apply(t) {
+					let r = t;
+					for (let i of e) r.getNode?.(i.node.id) || (i.node.id === a.id ? n.apply(t) : r.insertNode(i.node, i.index));
+				},
+				invert: () => s({
+					node: a,
+					label: c,
+					slot: t,
+					cascaded: e
+				})
+			};
+		}
+	};
+}
+e("delete", (e) => s(e));
+//#endregion
+export { s as createDeleteOp };
+
+//# sourceMappingURL=delete.js.map