@weasel-js/core 1.11.1 → 1.13.0-rc.0

package/dist/core/scene/pathEffects/textAlong.js

@@ -0,0 +1,95 @@
+import { boundsOfPath, multiply, pathShape, placeAlongRun, rotate, runLength, trackRun, transformPath, translate } from "@weasel-js/geom";
+
+//#region src/core/scene/pathEffects/textAlong.ts
+/**
+* Text along a path: a source's items — a text node's grapheme clusters, or a
+* whole shape as one item — laid end to end along a path, each turned to it.
+*/
+var LEAD = {
+	start: 0,
+	center: .5,
+	end: 1
+};
+/** The parts `items` paint laid along `path` as `effect` says; `[]` when there is nothing to lay or nowhere to lay it. */
+function textAlongParts(effect, items, path) {
+	const shape = pathShape(path);
+	if (shape === null || !(shape.length > 0) || items.length === 0) return [];
+	const L = shape.length;
+	const closed = shape.closed;
+	const lengths = items.map((it) => it.length);
+	const k = LEAD[effect.align ?? "start"];
+	const at = clamp01(effect.start ?? 0) * L;
+	const gap = effect.overflow === "fit" ? fitGap(lengths, roomAt(at, L, k, closed)) : 0;
+	const total = runLength(lengths, gap);
+	const c = at + (.5 - k) * total;
+	const about = closed ? (c / L % 1 + 1) % 1 : clamp01(c / L);
+	const run = trackRun(shape, 0, 1, {
+		side: effect.side ?? "auto",
+		about
+	});
+	const places = placeAlongRun(run, lengths, {
+		gap,
+		align: "center",
+		at: run.reversed ? L - c : c,
+		shift: finiteOr(effect.shift, 0),
+		wrap: closed
+	});
+	const center = effect.anchor === "center";
+	const out = [];
+	const firstStart = places[0].center - lengths[0] / 2;
+	places.forEach((place, i) => {
+		if (dropped(place, closed ? firstStart : null, L)) return;
+		const item = items[i];
+		const m = itemFrame(place, item.length, center ? item.middle : 0);
+		for (const part of item.parts) out.push({
+			...part,
+			path: transformPath(part.path, m)
+		});
+	});
+	return out;
+}
+/** `source`'s whole outline as one item: its bounds' left at x = 0 and their vertical middle on the anchor line. */
+function wholeItem(source) {
+	const b = boundsOfPath(source.world);
+	return {
+		length: b.width,
+		middle: 0,
+		parts: [{
+			path: transformPath(source.world, translate(-b.x, -(b.y + b.height / 2))),
+			fill: source.fill,
+			stroke: source.stroke
+		}]
+	};
+}
+/** SVG `textPath`'s rule: an item is not drawn once its middle is past an open path's ends, or on a closed path a whole
+*  lap or more on from the first item's start. Judged within a hair of rounding. */
+function dropped(place, firstStart, L) {
+	const hair = 1e-9 * Math.max(1, L);
+	if (firstStart !== null) return place.center - firstStart >= L - hair;
+	return place.center < -hair || place.center > L + hair;
+}
+/** How much path the text has before it runs off, from `at`, with `k` of it laid back behind `at`. */
+function roomAt(at, L, k, closed) {
+	if (closed) return L;
+	return k === 0 ? L - at : k === 1 ? at : 2 * Math.min(at, L - at);
+}
+/** The gap that makes `lengths` fill `room`, or 0 when they fit already. Never so negative that an item's step back
+*  from the one before it (its length plus the gap) goes below zero, so items keep their order in too short a room. */
+function fitGap(lengths, room) {
+	const total = runLength(lengths, 0);
+	if (!(total > room) || lengths.length < 2) return 0;
+	let floor = -Infinity;
+	for (let i = 1; i < lengths.length; i++) floor = Math.max(floor, -(lengths[i - 1] + lengths[i]) / 2);
+	return Math.max((room - total) / (lengths.length - 1), floor);
+}
+/** Item frame to world: its middle on `place`, turned to it, its anchor line `lift` above y = 0 brought onto the path. */
+function itemFrame(place, length, lift) {
+	const turn = multiply(rotate(place.angle * Math.PI / 180), translate(-length / 2, lift));
+	return multiply(translate(place.point.x, place.point.y), turn);
+}
+var clamp01 = (v) => v > 1 ? 1 : v > 0 ? v : 0;
+var finiteOr = (v, d) => v !== void 0 && Number.isFinite(v) ? v : d;
+
+//#endregion
+export { textAlongParts, wholeItem };
+//# sourceMappingURL=textAlong.js.map

package/dist/core/scene/pathEffects/textAlong.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"textAlong.js","names":[],"sources":["../../../../src/core/scene/pathEffects/textAlong.ts"],"sourcesContent":["/**\n * Text along a path: a source's items — a text node's grapheme clusters, or a\n * whole shape as one item — laid end to end along a path, each turned to it.\n */\nimport {\n  boundsOfPath, multiply, pathShape, placeAlongRun, rotate, runLength, trackRun, transformPath, translate,\n  type Affine, type Path, type RunAlign, type RunPlace, type TrackSide,\n} from '@weasel-js/geom';\nimport type { DerivedPart } from '../derivedParts';\nimport type { EffectItem, EffectSource, PathEffectOptions } from './source';\n\n/**\n * Text (or any shape) laid along a path, item by item. Its sources are `[text, path]`. Only the text's first laid line\n * follows the path; a color glyph keeps its advance and paints nothing; underlines and other decorations are not drawn.\n * On an open path an item whose middle falls past either end is not drawn; on a closed one the text wraps past the\n * seam, and an item a whole lap on from the first item's start is not drawn.\n */\nexport interface TextAlongEffect extends PathEffectOptions {\n  kind: 'textAlong';\n  /** Which part of the text sits at `start`. Default `'start'`. */\n  align?: RunAlign;\n  /** Where the text sits, as a fraction 0..1 of the path's length from its first point. Default 0. */\n  start?: number;\n  /** How far the anchor line sits off the path, toward the glyphs' up, in world units. Default 0. */\n  shift?: number;\n  /** What sits on the path: the glyphs' baseline, or (`'center'`) their x-height middle. Default `'baseline'`. */\n  anchor?: 'baseline' | 'center';\n  /** Text longer than its room is cut at the path's end (`'clip'`), or has the gaps between items squeezed until it\n   *  fits (`'fit'`). Default `'clip'`. */\n  overflow?: 'clip' | 'fit';\n  /** Which side of the path the glyphs stand on; see `TrackSide`. Default `'auto'`, whichever reads upright. Turned over,\n   *  the text keeps the stretch of path it had, and on an open path drops whichever letters fall off it. */\n  side?: TrackSide;\n}\n\nconst LEAD: Record<RunAlign, number> = { start: 0, center: 0.5, end: 1 };\n\n/** The parts `items` paint laid along `path` as `effect` says; `[]` when there is nothing to lay or nowhere to lay it. */\nexport function textAlongParts(effect: TextAlongEffect, items: readonly EffectItem[], path: Path): DerivedPart[] {\n  const shape = pathShape(path);\n  if (shape === null || !(shape.length > 0) || items.length === 0) return [];\n  const L = shape.length;\n  const closed = shape.closed;\n  const lengths = items.map((it) => it.length);\n  const k = LEAD[effect.align ?? 'start'];\n  const at = clamp01(effect.start ?? 0) * L;\n  const gap = effect.overflow === 'fit' ? fitGap(lengths, roomAt(at, L, k, closed)) : 0;\n  const total = runLength(lengths, gap);\n  const c = at + (0.5 - k) * total;\n  const about = closed ? ((c / L) % 1 + 1) % 1 : clamp01(c / L);\n  const run = trackRun(shape, 0, 1, { side: effect.side ?? 'auto', about });\n  const places = placeAlongRun(run, lengths, {\n    gap, align: 'center', at: run.reversed ? L - c : c, shift: finiteOr(effect.shift, 0), wrap: closed,\n  });\n  const center = effect.anchor === 'center';\n  const out: DerivedPart[] = [];\n  const firstStart = places[0]!.center - lengths[0]! / 2;\n  places.forEach((place, i) => {\n    // By center (SVG textPath's rule), not by RunPlace.clipped, which judges by extent.\n    if (dropped(place, closed ? firstStart : null, L)) return;\n    const item = items[i]!;\n    const m = itemFrame(place, item.length, center ? item.middle : 0);\n    for (const part of item.parts) out.push({ ...part, path: transformPath(part.path, m) });\n  });\n  return out;\n}\n\n/** `source`'s whole outline as one item: its bounds' left at x = 0 and their vertical middle on the anchor line. */\nexport function wholeItem(source: EffectSource): EffectItem {\n  const b = boundsOfPath(source.world);\n  return {\n    length: b.width,\n    middle: 0,\n    parts: [{\n      path: transformPath(source.world, translate(-b.x, -(b.y + b.height / 2))),\n      fill: source.fill,\n      stroke: source.stroke,\n    }],\n  };\n}\n\n/** SVG `textPath`'s rule: an item is not drawn once its middle is past an open path's ends, or on a closed path a whole\n *  lap or more on from the first item's start. Judged within a hair of rounding. */\nfunction dropped(place: RunPlace, firstStart: number | null, L: number): boolean {\n  const hair = 1e-9 * Math.max(1, L);\n  if (firstStart !== null) return place.center - firstStart >= L - hair;\n  return place.center < -hair || place.center > L + hair;\n}\n\n/** How much path the text has before it runs off, from `at`, with `k` of it laid back behind `at`. */\nfunction roomAt(at: number, L: number, k: number, closed: boolean): number {\n  if (closed) return L;\n  return k === 0 ? L - at : k === 1 ? at : 2 * Math.min(at, L - at);\n}\n\n/** The gap that makes `lengths` fill `room`, or 0 when they fit already. Never so negative that an item's step back\n *  from the one before it (its length plus the gap) goes below zero, so items keep their order in too short a room. */\nfunction fitGap(lengths: readonly number[], room: number): number {\n  const total = runLength(lengths, 0);\n  if (!(total > room) || lengths.length < 2) return 0;\n  let floor = -Infinity;\n  for (let i = 1; i < lengths.length; i++) floor = Math.max(floor, -(lengths[i - 1]! + lengths[i]!) / 2);\n  return Math.max((room - total) / (lengths.length - 1), floor);\n}\n\n/** Item frame to world: its middle on `place`, turned to it, its anchor line `lift` above y = 0 brought onto the path. */\nfunction itemFrame(place: RunPlace, length: number, lift: number): Affine {\n  const turn = multiply(rotate((place.angle * Math.PI) / 180), translate(-length / 2, lift));\n  return multiply(translate(place.point.x, place.point.y), turn);\n}\n\nconst clamp01 = (v: number): number => (v > 1 ? 1 : v > 0 ? v : 0);\nconst finiteOr = (v: number | undefined, d: number): number => (v !== undefined && Number.isFinite(v) ? v : d);\n"],"mappings":"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"}

package/dist/core/scene/plyStacks.js

@@ -0,0 +1,89 @@
+import { carryBoxPath } from "./depFrame.js";
+
+//#region src/core/scene/plyStacks.ts
+/** Empty stacks. */
+function createPlyStacks() {
+	const plies = /* @__PURE__ */ new Map();
+	/** Each entry's claim, in claiming order; outlives a full drop, so a reinstall goes back in place. */
+	const claims = /* @__PURE__ */ new WeakMap();
+	let claimed = 0;
+	/** How many nodes hold each number of plies. */
+	const sizes = [];
+	let deepest = 0;
+	const resized = (from, to) => {
+		if (from > 0) sizes[from]--;
+		if (to > 0) sizes[to] = (sizes[to] ?? 0) + 1;
+		if (to > deepest) deepest = to;
+		while (deepest > 0 && (sizes[deepest] ?? 0) === 0) deepest--;
+	};
+	return {
+		plies,
+		claim(id, entry) {
+			let stack = plies.get(id);
+			if (stack === void 0) plies.set(id, stack = []);
+			const at = stack.indexOf(entry);
+			if (at >= 0) stack.splice(at, 1);
+			let claim = at >= 0 ? void 0 : claims.get(entry);
+			if (claim === void 0) claims.set(entry, claim = ++claimed);
+			let i = stack.length;
+			while (i > 0 && claims.get(stack[i - 1]) > claim) i--;
+			stack.splice(i, 0, entry);
+			if (at < 0) resized(stack.length - 1, stack.length);
+		},
+		release(id, entry) {
+			claims.delete(entry);
+			const stack = plies.get(id);
+			const at = stack?.indexOf(entry) ?? -1;
+			if (stack === void 0 || at < 0) return false;
+			stack.splice(at, 1);
+			resized(stack.length + 1, stack.length);
+			if (stack.length === 0) plies.delete(id);
+			return true;
+		},
+		drop(id) {
+			const stack = plies.get(id);
+			if (stack === void 0) return false;
+			plies.delete(id);
+			resized(stack.length, 0);
+			return true;
+		},
+		dropAll() {
+			plies.clear();
+			sizes.length = 0;
+			deepest = 0;
+		},
+		depth: () => Math.max(deepest, 1)
+	};
+}
+var boxOf = (pose) => {
+	const p = pose;
+	return p !== null && typeof p === "object" && typeof p.x === "number" && typeof p.y === "number" && typeof p.width === "number" && typeof p.height === "number" ? p : null;
+};
+var sameBox = (a, b) => a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
+/**
+* The path `stack` shows, folded to `pose`: the topmost ply's path, in the box of the pose
+* that ply gives beside it, carried to `pose` where a ply above gives another. A path given
+* with no pose of its own is drawn where it is. `held` keeps the last carry.
+*/
+function plyPath(stack, pose, held) {
+	for (let k = stack.length - 1; k >= 0; k--) {
+		const ply = stack[k];
+		if (ply.path === void 0) continue;
+		const from = boxOf(ply.pose);
+		const to = boxOf(pose);
+		if (from === null || to === null || sameBox(from, to)) return ply.path;
+		const last = held.carried;
+		if (last !== void 0 && last.source === ply.path && sameBox(last.from, from) && sameBox(last.to, to)) return last.path;
+		held.carried = {
+			source: ply.path,
+			from: { ...from },
+			to: { ...to },
+			path: carryBoxPath(ply.path, from, to)
+		};
+		return held.carried.path;
+	}
+}
+
+//#endregion
+export { createPlyStacks, plyPath };
+//# sourceMappingURL=plyStacks.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"plyStacks.js","names":[],"sources":["../../../src/core/scene/plyStacks.ts"],"sourcesContent":["/**\n * Each node's plies of overrides, kept in the order their writers claimed\n * the node, and the path a stack shows.\n */\nimport type { Path } from '@weasel-js/geom';\nimport { carryBoxPath } from './depFrame';\nimport type { NodeId, PoseOverride } from './types';\n\n/** {@link createPlyStacks}'s handle. */\nexport interface PlyStacks<Entry> {\n  /** Per node, its plies bottom first. */\n  readonly plies: ReadonlyMap<NodeId, readonly Entry[]>;\n  /** Install `entry` on `id`: on top, or where it stood when a full drop took it off. An\n   *  installed entry moves to the top. */\n  claim(id: NodeId, entry: Entry): void;\n  /** Take `entry` off `id` and forget where it stood. Whether it was installed. */\n  release(id: NodeId, entry: Entry): boolean;\n  /** Take every ply off `id`, each keeping its place for when its writer reinstalls it.\n   *  Whether the node had any. */\n  drop(id: NodeId): boolean;\n  /** {@link PlyStacks.drop} for every node. */\n  dropAll(): void;\n  /** The deepest stack, and at least 1. */\n  depth(): number;\n}\n\n/** Empty stacks. */\nexport function createPlyStacks<Entry extends object>(): PlyStacks<Entry> {\n  const plies = new Map<NodeId, Entry[]>();\n  /** Each entry's claim, in claiming order; outlives a full drop, so a reinstall goes back in place. */\n  const claims = new WeakMap<Entry, number>();\n  let claimed = 0;\n  /** How many nodes hold each number of plies. */\n  const sizes: number[] = [];\n  let deepest = 0;\n\n  const resized = (from: number, to: number): void => {\n    if (from > 0) sizes[from]!--;\n    if (to > 0) sizes[to] = (sizes[to] ?? 0) + 1;\n    if (to > deepest) deepest = to;\n    while (deepest > 0 && (sizes[deepest] ?? 0) === 0) deepest--;\n  };\n\n  return {\n    plies,\n    claim(id, entry) {\n      let stack = plies.get(id);\n      if (stack === undefined) plies.set(id, stack = []);\n      const at = stack.indexOf(entry);\n      if (at >= 0) stack.splice(at, 1);\n      let claim = at >= 0 ? undefined : claims.get(entry);\n      if (claim === undefined) claims.set(entry, claim = ++claimed);\n      let i = stack.length;\n      while (i > 0 && claims.get(stack[i - 1]!)! > claim) i--;\n      stack.splice(i, 0, entry);\n      if (at < 0) resized(stack.length - 1, stack.length);\n    },\n    release(id, entry) {\n      claims.delete(entry);\n      const stack = plies.get(id);\n      const at = stack?.indexOf(entry) ?? -1;\n      if (stack === undefined || at < 0) return false;\n      stack.splice(at, 1);\n      resized(stack.length + 1, stack.length);\n      if (stack.length === 0) plies.delete(id);\n      return true;\n    },\n    drop(id) {\n      const stack = plies.get(id);\n      if (stack === undefined) return false;\n      plies.delete(id);\n      resized(stack.length, 0);\n      return true;\n    },\n    dropAll() {\n      plies.clear();\n      sizes.length = 0;\n      deepest = 0;\n    },\n    depth: () => Math.max(deepest, 1),\n  };\n}\n\ntype Box = { x: number; y: number; width: number; height: number };\n\nconst boxOf = (pose: unknown): Box | null => {\n  const p = pose as Partial<Box> | null;\n  return p !== null && typeof p === 'object' && typeof p.x === 'number' && typeof p.y === 'number'\n    && typeof p.width === 'number' && typeof p.height === 'number'\n    ? p as Box : null;\n};\n\nconst sameBox = (a: Box, b: Box): boolean => a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;\n\n/** A carried path and what it was carried from and to, so a stack whose poses hold still shows one path. */\nexport interface CarriedPath {\n  source: Path;\n  from: Box;\n  to: Box;\n  path: Path;\n}\n\n/**\n * The path `stack` shows, folded to `pose`: the topmost ply's path, in the box of the pose\n * that ply gives beside it, carried to `pose` where a ply above gives another. A path given\n * with no pose of its own is drawn where it is. `held` keeps the last carry.\n */\nexport function plyPath<TPose, TData>(\n  stack: readonly PoseOverride<TPose, TData>[],\n  pose: TPose | undefined,\n  held: { carried?: CarriedPath },\n): Path | undefined {\n  for (let k = stack.length - 1; k >= 0; k--) {\n    const ply = stack[k]!;\n    if (ply.path === undefined) continue;\n    const from = boxOf(ply.pose);\n    const to = boxOf(pose);\n    if (from === null || to === null || sameBox(from, to)) return ply.path;\n    const last = held.carried;\n    if (last !== undefined && last.source === ply.path && sameBox(last.from, from) && sameBox(last.to, to)) return last.path;\n    held.carried = { source: ply.path, from: { ...from }, to: { ...to }, path: carryBoxPath(ply.path, from, to) };\n    return held.carried.path;\n  }\n  return undefined;\n}\n"],"mappings":"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"}

package/dist/core/scene/poseHold.js

@@ -1,47 +1,65 @@
 //#region src/core/scene/poseHold.ts
-/** Build the {@link PoseHold} a table hands out from `hold()`. */
-function createPoseHold(table) {
+/** Build the {@link PoseHold} a table hands out from `hold()`. `pliesOf`
+*  answers a node's plies, bottom first. */
+function createPoseHold(table, pliesOf) {
 	/** The entry published per id, held by reference so a frame mutates it in place. */
 	const held = /* @__PURE__ */ new Map();
 	const seen = /* @__PURE__ */ new Set();
+	const publish = (frame) => {
+		seen.clear();
+		for (const [id, shown] of frame) {
+			seen.add(id);
+			const existing = held.get(id);
+			if (existing) {
+				existing.pose = shown.pose;
+				existing.data = shown.data;
+				if (!table.has(id, existing)) table.set(id, existing);
+				continue;
+			}
+			const entry = {
+				pose: shown.pose,
+				data: shown.data
+			};
+			held.set(id, entry);
+			table.set(id, entry);
+		}
+		for (const [id, entry] of held) {
+			if (seen.has(id)) continue;
+			held.delete(id);
+			table.clear(id, entry);
+		}
+		table.commit();
+	};
 	return {
 		set(poses) {
-			seen.clear();
-			for (const [id, pose] of poses) {
-				seen.add(id);
-				const existing = held.get(id);
-				if (existing) {
-					existing.pose = pose;
-					continue;
-				}
-				const entry = { pose };
-				held.set(id, entry);
-				table.set(id, entry);
-			}
-			for (const [id, entry] of held) {
-				if (seen.has(id)) continue;
-				held.delete(id);
-				if (table.get(id) === entry) table.clear(id);
-			}
-			table.commit();
+			publish(mapped(poses));
 		},
+		show: publish,
 		others() {
 			const out = /* @__PURE__ */ new Map();
 			for (const id of table.ids()) {
-				const entry = table.get(id);
-				if (entry === void 0 || entry === held.get(id) || entry.pose === void 0) continue;
-				out.set(id, entry.pose);
+				const stack = pliesOf(id) ?? [];
+				const mine = held.get(id);
+				for (let k = stack.length - 1; k >= 0; k--) {
+					const entry = stack[k];
+					if (entry === mine || entry.pose === void 0) continue;
+					out.set(id, entry.pose);
+					break;
+				}
 			}
 			return out;
 		},
 		drop() {
 			if (held.size === 0) return;
-			for (const [id, entry] of held) if (table.get(id) === entry) table.clear(id);
+			for (const [id, entry] of held) table.clear(id, entry);
 			held.clear();
 			table.commit();
 		}
 	};
 }
+function* mapped(poses) {
+	for (const [id, pose] of poses) yield [id, { pose }];
+}
 
 //#endregion
 export { createPoseHold };

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

@@ -1 +1 @@
-{"version":3,"file":"poseHold.js","names":[],"sources":["../../../src/core/scene/poseHold.ts"],"sourcesContent":["import type { NodeId, PoseHold, PoseOverride, PoseOverrides } from './types';\n\n/** The table methods a hold writes through. */\ntype HoldTable<TPose> = Pick<PoseOverrides<TPose>, 'set' | 'get' | 'ids' | 'clear' | 'commit'>;\n\n/** Build the {@link PoseHold} a table hands out from `hold()`. */\nexport function createPoseHold<TPose>(table: HoldTable<TPose>): PoseHold<TPose> {\n  /** The entry published per id, held by reference so a frame mutates it in place. */\n  const held = new Map<NodeId, PoseOverride<TPose>>();\n  const seen = new Set<NodeId>();\n\n  return {\n    set(poses) {\n      seen.clear();\n      for (const [id, pose] of poses) {\n        seen.add(id);\n        const existing = held.get(id);\n        if (existing) {\n          existing.pose = pose;\n          continue;\n        }\n        const entry: PoseOverride<TPose> = { pose };\n        held.set(id, entry);\n        // `table.set` notifies per call, so an id is set once and mutated after.\n        table.set(id, entry);\n      }\n      for (const [id, entry] of held) {\n        if (seen.has(id)) continue;\n        held.delete(id);\n        if (table.get(id) === entry) table.clear(id);\n      }\n      table.commit();\n    },\n    others() {\n      const out = new Map<NodeId, TPose>();\n      for (const id of table.ids()) {\n        const entry = table.get(id);\n        if (entry === undefined || entry === held.get(id) || entry.pose === undefined) continue;\n        out.set(id, entry.pose);\n      }\n      return out;\n    },\n    drop() {\n      if (held.size === 0) return;\n      for (const [id, entry] of held) {\n        if (table.get(id) === entry) table.clear(id);\n      }\n      held.clear();\n      table.commit();\n    },\n  };\n}\n"],"mappings":";;AAMA,SAAgB,eAAsB,OAA0C;;CAE9E,MAAM,uBAAO,IAAI,IAAiC;CAClD,MAAM,uBAAO,IAAI,IAAY;CAE7B,OAAO;EACL,IAAI,OAAO;GACT,KAAK,MAAM;GACX,KAAK,MAAM,CAAC,IAAI,SAAS,OAAO;IAC9B,KAAK,IAAI,EAAE;IACX,MAAM,WAAW,KAAK,IAAI,EAAE;IAC5B,IAAI,UAAU;KACZ,SAAS,OAAO;KAChB;IACF;IACA,MAAM,QAA6B,EAAE,KAAK;IAC1C,KAAK,IAAI,IAAI,KAAK;IAElB,MAAM,IAAI,IAAI,KAAK;GACrB;GACA,KAAK,MAAM,CAAC,IAAI,UAAU,MAAM;IAC9B,IAAI,KAAK,IAAI,EAAE,GAAG;IAClB,KAAK,OAAO,EAAE;IACd,IAAI,MAAM,IAAI,EAAE,MAAM,OAAO,MAAM,MAAM,EAAE;GAC7C;GACA,MAAM,OAAO;EACf;EACA,SAAS;GACP,MAAM,sBAAM,IAAI,IAAmB;GACnC,KAAK,MAAM,MAAM,MAAM,IAAI,GAAG;IAC5B,MAAM,QAAQ,MAAM,IAAI,EAAE;IAC1B,IAAI,UAAU,UAAa,UAAU,KAAK,IAAI,EAAE,KAAK,MAAM,SAAS,QAAW;IAC/E,IAAI,IAAI,IAAI,MAAM,IAAI;GACxB;GACA,OAAO;EACT;EACA,OAAO;GACL,IAAI,KAAK,SAAS,GAAG;GACrB,KAAK,MAAM,CAAC,IAAI,UAAU,MACxB,IAAI,MAAM,IAAI,EAAE,MAAM,OAAO,MAAM,MAAM,EAAE;GAE7C,KAAK,MAAM;GACX,MAAM,OAAO;EACf;CACF;AACF"}
+{"version":3,"file":"poseHold.js","names":[],"sources":["../../../src/core/scene/poseHold.ts"],"sourcesContent":["import type { NodeId, PoseHold, PoseOverride, PoseOverrides, ShownOverride } from './types';\n\n/** The table methods a hold writes through. */\ntype HoldTable<TPose, TData> = Pick<PoseOverrides<TPose, TData>, 'set' | 'has' | 'ids' | 'clear' | 'commit'>;\n\n/** Build the {@link PoseHold} a table hands out from `hold()`. `pliesOf`\n *  answers a node's plies, bottom first. */\nexport function createPoseHold<TPose, TData = unknown>(\n  table: HoldTable<TPose, TData>,\n  pliesOf: (id: NodeId) => readonly PoseOverride<TPose, TData>[] | undefined,\n): PoseHold<TPose, TData> {\n  /** The entry published per id, held by reference so a frame mutates it in place. */\n  const held = new Map<NodeId, PoseOverride<TPose, TData>>();\n  const seen = new Set<NodeId>();\n\n  const publish = (frame: Iterable<readonly [NodeId, ShownOverride<TPose, TData>]>): void => {\n    seen.clear();\n    for (const [id, shown] of frame) {\n      seen.add(id);\n      const existing = held.get(id);\n      if (existing) {\n        existing.pose = shown.pose;\n        existing.data = shown.data;\n        // The table drops a node's plies on its own when the node goes; put back the node, and the frame goes back too.\n        if (!table.has(id, existing)) table.set(id, existing);\n        continue;\n      }\n      const entry: PoseOverride<TPose, TData> = { pose: shown.pose, data: shown.data };\n      held.set(id, entry);\n      // `table.set` notifies per call, so an id is set once and mutated after.\n      table.set(id, entry);\n    }\n    for (const [id, entry] of held) {\n      if (seen.has(id)) continue;\n      held.delete(id);\n      table.clear(id, entry);\n    }\n    table.commit();\n  };\n\n  return {\n    set(poses) {\n      publish(mapped(poses));\n    },\n    show: publish,\n    others() {\n      const out = new Map<NodeId, TPose>();\n      for (const id of table.ids()) {\n        const stack = pliesOf(id) ?? [];\n        const mine = held.get(id);\n        for (let k = stack.length - 1; k >= 0; k--) {\n          const entry = stack[k]!;\n          if (entry === mine || entry.pose === undefined) continue;\n          out.set(id, entry.pose);\n          break;\n        }\n      }\n      return out;\n    },\n    drop() {\n      if (held.size === 0) return;\n      for (const [id, entry] of held) table.clear(id, entry);\n      held.clear();\n      table.commit();\n    },\n  };\n}\n\nfunction* mapped<TPose, TData>(poses: Iterable<readonly [NodeId, TPose]>): Iterable<readonly [NodeId, ShownOverride<TPose, TData>]> {\n  for (const [id, pose] of poses) yield [id, { pose }];\n}\n"],"mappings":";;;AAOA,SAAgB,eACd,OACA,SACwB;;CAExB,MAAM,uBAAO,IAAI,IAAwC;CACzD,MAAM,uBAAO,IAAI,IAAY;CAE7B,MAAM,WAAW,UAA0E;EACzF,KAAK,MAAM;EACX,KAAK,MAAM,CAAC,IAAI,UAAU,OAAO;GAC/B,KAAK,IAAI,EAAE;GACX,MAAM,WAAW,KAAK,IAAI,EAAE;GAC5B,IAAI,UAAU;IACZ,SAAS,OAAO,MAAM;IACtB,SAAS,OAAO,MAAM;IAEtB,IAAI,CAAC,MAAM,IAAI,IAAI,QAAQ,GAAG,MAAM,IAAI,IAAI,QAAQ;IACpD;GACF;GACA,MAAM,QAAoC;IAAE,MAAM,MAAM;IAAM,MAAM,MAAM;GAAK;GAC/E,KAAK,IAAI,IAAI,KAAK;GAElB,MAAM,IAAI,IAAI,KAAK;EACrB;EACA,KAAK,MAAM,CAAC,IAAI,UAAU,MAAM;GAC9B,IAAI,KAAK,IAAI,EAAE,GAAG;GAClB,KAAK,OAAO,EAAE;GACd,MAAM,MAAM,IAAI,KAAK;EACvB;EACA,MAAM,OAAO;CACf;CAEA,OAAO;EACL,IAAI,OAAO;GACT,QAAQ,OAAO,KAAK,CAAC;EACvB;EACA,MAAM;EACN,SAAS;GACP,MAAM,sBAAM,IAAI,IAAmB;GACnC,KAAK,MAAM,MAAM,MAAM,IAAI,GAAG;IAC5B,MAAM,QAAQ,QAAQ,EAAE,KAAK,CAAC;IAC9B,MAAM,OAAO,KAAK,IAAI,EAAE;IACxB,KAAK,IAAI,IAAI,MAAM,SAAS,GAAG,KAAK,GAAG,KAAK;KAC1C,MAAM,QAAQ,MAAM;KACpB,IAAI,UAAU,QAAQ,MAAM,SAAS,QAAW;KAChD,IAAI,IAAI,IAAI,MAAM,IAAI;KACtB;IACF;GACF;GACA,OAAO;EACT;EACA,OAAO;GACL,IAAI,KAAK,SAAS,GAAG;GACrB,KAAK,MAAM,CAAC,IAAI,UAAU,MAAM,MAAM,MAAM,IAAI,KAAK;GACrD,KAAK,MAAM;GACX,MAAM,OAAO;EACf;CACF;AACF;AAEA,UAAU,OAAqB,OAAqG;CAClI,KAAK,MAAM,CAAC,IAAI,SAAS,OAAO,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC;AACrD"}

package/dist/core/scene/poseOverrides.js

@@ -1,11 +1,11 @@
 import { dropPoseKeyedMemoSlots } from "./nodeMemo.js";
+import { shownCopyOf } from "./nodeAsShown.js";
 import { createPoseHold } from "./poseHold.js";
+import { foldPlies } from "./posePlies.js";
+import { createPlyStacks, plyPath } from "./plyStacks.js";
 import { createEmitter } from "@weasel-js/registry";
-import { kit, last, mix, mul, patch } from "@msb235/blits";
 
 //#region src/core/scene/poseOverrides.ts
-/** What the table's voice says about a node it holds no entry for. */
-var NOTHING = Object.freeze({});
 /**
 * Build a {@link PoseOverrides} map.
 *
@@ -13,53 +13,48 @@ var NOTHING = Object.freeze({});
 * `onInvalidate` lets the scene invalidate derived nodes from the same
 * chokepoint.
 *
-* What `read` answers is a blits mix folded per node. The entries a writer
-* `set`s are one voice on it, and a node holding no entry is never probed.
+* What `read` answers is folded from the node's plies by `foldPlies`, its
+* path by `plyPath`; a node holding no entry is never probed.
 */
 function createPoseOverrides(getNode, onInvalidate) {
-	const entries = /* @__PURE__ */ new Map();
+	const stacks = createPlyStacks();
+	const { plies } = stacks;
+	const fold = foldPlies(plies);
 	const listeners = createEmitter();
 	let generation = 0;
-	const folded = mix(kit({
-		pose: last(),
-		alpha: mul(),
-		path: last()
-	}));
-	folded.cue({ patch: patch(0, (_phase, id) => entries.get(id) ?? NOTHING, { writes: [
-		"pose",
-		"alpha",
-		"path"
-	] }) });
-	let clock = 0;
-	folded.sync(clock);
-	/** Per node: the object `read` folds into and returns, and the generation
-	*  it was last folded at. */
+	/** Per node: the object `read` folds into and returns, the generation it
+	*  was last folded at, and the last path it carried. */
 	const reads = /* @__PURE__ */ new Map();
 	function invalidate(id) {
 		const node = getNode(id);
-		if (node) dropPoseKeyedMemoSlots(node);
+		if (node) {
+			dropPoseKeyedMemoSlots(node);
+			const shown = shownCopyOf(node);
+			if (shown) dropPoseKeyedMemoSlots(shown);
+		}
 		onInvalidate?.(id);
 	}
 	function published() {
 		generation++;
-		folded.sync(++clock);
+		fold.publish(stacks.depth());
 		listeners.emit();
 	}
 	function forget(id) {
 		reads.delete(id);
-		folded.drop(id);
+		fold.drop(id);
 	}
 	const table = {
 		set(id, entry) {
-			entries.set(id, entry);
+			stacks.claim(id, entry);
 			invalidate(id);
 			published();
 		},
 		get(id) {
-			return entries.get(id);
+			return plies.get(id)?.at(-1);
 		},
 		read(id) {
-			if (!entries.has(id)) return void 0;
+			const stack = plies.get(id);
+			if (stack === void 0) return void 0;
 			let held = reads.get(id);
 			if (held === void 0) {
 				held = {
@@ -69,41 +64,43 @@ function createPoseOverrides(getNode, onInvalidate) {
 				reads.set(id, held);
 			}
 			if (held.at !== generation) {
-				folded.probe(id, held.out);
+				fold.probe(id, held.out);
+				held.out.path = plyPath(stack, held.out.pose, held);
 				held.at = generation;
 			}
 			return held.out;
 		},
-		has(id) {
-			return entries.has(id);
+		has(id, entry) {
+			const stack = plies.get(id);
+			return stack !== void 0 && (entry === void 0 || stack.includes(entry));
 		},
 		ids() {
-			return [...entries.keys()];
+			return [...plies.keys()];
 		},
-		clear(id) {
-			if (!entries.delete(id)) return;
-			forget(id);
+		clear(id, entry) {
+			if (!(entry === void 0 ? stacks.drop(id) : stacks.release(id, entry))) return;
+			if (!plies.has(id)) forget(id);
 			invalidate(id);
 			published();
 		},
 		clearAll() {
-			if (entries.size === 0) return;
-			for (const id of entries.keys()) {
+			if (plies.size === 0) return;
+			for (const id of plies.keys()) {
 				forget(id);
 				invalidate(id);
 			}
-			entries.clear();
+			stacks.dropAll();
 			published();
 		},
 		commit() {
-			for (const id of entries.keys()) invalidate(id);
+			for (const id of plies.keys()) invalidate(id);
 			published();
 		},
 		subscribe: listeners.subscribe,
 		getGeneration() {
 			return generation;
 		},
-		hold: () => createPoseHold(table)
+		hold: () => createPoseHold(table, (id) => plies.get(id))
 	};
 	return table;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"poseOverrides.js","names":[],"sources":["../../../src/core/scene/poseOverrides.ts"],"sourcesContent":["import type { Path } from '@weasel-js/geom';\nimport { createEmitter } from '@weasel-js/registry';\nimport { kit, last, mix, mul, patch } from '@msb235/blits';\nimport { dropPoseKeyedMemoSlots } from './nodeMemo';\nimport { createPoseHold } from './poseHold';\nimport type { NodeId, PoseOverride, PoseOverrides } from './types';\n\n/** What the table's voice says about a node it holds no entry for. */\nconst NOTHING: PoseOverride<never> = Object.freeze({});\n\n/**\n * Build a {@link PoseOverrides} map.\n *\n * `getNode` resolves an id to the node object the painter memo is keyed on.\n * `onInvalidate` lets the scene invalidate derived nodes from the same\n * chokepoint.\n *\n * What `read` answers is a blits mix folded per node. The entries a writer\n * `set`s are one voice on it, and a node holding no entry is never probed.\n */\nexport function createPoseOverrides<TPose>(\n  getNode: (id: NodeId) => { data?: unknown } | undefined,\n  onInvalidate?: (id: NodeId) => void,\n): PoseOverrides<TPose> {\n  const entries = new Map<NodeId, PoseOverride<TPose>>();\n  const listeners = createEmitter();\n  let generation = 0;\n\n  const folded = mix<NodeId, PoseOverride<TPose>>(\n    kit<PoseOverride<TPose>>({ pose: last<NonNullable<TPose>>(), alpha: mul(), path: last<Path>() }),\n  );\n  folded.cue({\n    patch: patch<NodeId, PoseOverride<TPose>>(\n      0,\n      (_phase, id) => entries.get(id) ?? (NOTHING as PoseOverride<TPose>),\n      { writes: ['pose', 'alpha', 'path'] },\n    ),\n  });\n  // Mix time only has to move between publishes, so a probe after one never\n  // hands back the delta a probe before it cached.\n  let clock = 0;\n  folded.sync(clock);\n\n  /** Per node: the object `read` folds into and returns, and the generation\n   *  it was last folded at. */\n  const reads = new Map<NodeId, { out: PoseOverride<TPose>; at: number }>();\n\n  function invalidate(id: NodeId): void {\n    const node = getNode(id);\n    if (node) dropPoseKeyedMemoSlots(node);\n    onInvalidate?.(id);\n  }\n\n  function published(): void {\n    generation++;\n    folded.sync(++clock);\n    listeners.emit();\n  }\n\n  function forget(id: NodeId): void {\n    reads.delete(id);\n    folded.drop(id);\n  }\n\n  const table: PoseOverrides<TPose> = {\n    set(id, entry) {\n      entries.set(id, entry);\n      invalidate(id);\n      published();\n    },\n    get(id) {\n      return entries.get(id);\n    },\n    read(id) {\n      if (!entries.has(id)) return undefined;\n      let held = reads.get(id);\n      if (held === undefined) {\n        held = { out: {}, at: -1 };\n        reads.set(id, held);\n      }\n      if (held.at !== generation) {\n        folded.probe(id, held.out);\n        held.at = generation;\n      }\n      return held.out;\n    },\n    has(id) {\n      return entries.has(id);\n    },\n    ids() {\n      return [...entries.keys()];\n    },\n    clear(id) {\n      if (!entries.delete(id)) return;\n      forget(id);\n      invalidate(id);\n      published();\n    },\n    clearAll() {\n      if (entries.size === 0) return;\n      for (const id of entries.keys()) {\n        forget(id);\n        invalidate(id);\n      }\n      entries.clear();\n      published();\n    },\n    commit() {\n      for (const id of entries.keys()) invalidate(id);\n      published();\n    },\n    subscribe: listeners.subscribe,\n    getGeneration() {\n      return generation;\n    },\n    hold: () => createPoseHold(table),\n  };\n  return table;\n}\n"],"mappings":";;;;;;;AAQA,IAAM,UAA+B,OAAO,OAAO,CAAC,CAAC;;;;;;;;;;;AAYrD,SAAgB,oBACd,SACA,cACsB;CACtB,MAAM,0BAAU,IAAI,IAAiC;CACrD,MAAM,YAAY,cAAc;CAChC,IAAI,aAAa;CAEjB,MAAM,SAAS,IACb,IAAyB;EAAE,MAAM,KAAyB;EAAG,OAAO,IAAI;EAAG,MAAM,KAAW;CAAE,CAAC,CACjG;CACA,OAAO,IAAI,EACT,OAAO,MACL,IACC,QAAQ,OAAO,QAAQ,IAAI,EAAE,KAAM,SACpC,EAAE,QAAQ;EAAC;EAAQ;EAAS;CAAM,EAAE,CACtC,EACF,CAAC;CAGD,IAAI,QAAQ;CACZ,OAAO,KAAK,KAAK;;;CAIjB,MAAM,wBAAQ,IAAI,IAAsD;CAExE,SAAS,WAAW,IAAkB;EACpC,MAAM,OAAO,QAAQ,EAAE;EACvB,IAAI,MAAM,uBAAuB,IAAI;EACrC,eAAe,EAAE;CACnB;CAEA,SAAS,YAAkB;EACzB;EACA,OAAO,KAAK,EAAE,KAAK;EACnB,UAAU,KAAK;CACjB;CAEA,SAAS,OAAO,IAAkB;EAChC,MAAM,OAAO,EAAE;EACf,OAAO,KAAK,EAAE;CAChB;CAEA,MAAM,QAA8B;EAClC,IAAI,IAAI,OAAO;GACb,QAAQ,IAAI,IAAI,KAAK;GACrB,WAAW,EAAE;GACb,UAAU;EACZ;EACA,IAAI,IAAI;GACN,OAAO,QAAQ,IAAI,EAAE;EACvB;EACA,KAAK,IAAI;GACP,IAAI,CAAC,QAAQ,IAAI,EAAE,GAAG,OAAO;GAC7B,IAAI,OAAO,MAAM,IAAI,EAAE;GACvB,IAAI,SAAS,QAAW;IACtB,OAAO;KAAE,KAAK,CAAC;KAAG,IAAI;IAAG;IACzB,MAAM,IAAI,IAAI,IAAI;GACpB;GACA,IAAI,KAAK,OAAO,YAAY;IAC1B,OAAO,MAAM,IAAI,KAAK,GAAG;IACzB,KAAK,KAAK;GACZ;GACA,OAAO,KAAK;EACd;EACA,IAAI,IAAI;GACN,OAAO,QAAQ,IAAI,EAAE;EACvB;EACA,MAAM;GACJ,OAAO,CAAC,GAAG,QAAQ,KAAK,CAAC;EAC3B;EACA,MAAM,IAAI;GACR,IAAI,CAAC,QAAQ,OAAO,EAAE,GAAG;GACzB,OAAO,EAAE;GACT,WAAW,EAAE;GACb,UAAU;EACZ;EACA,WAAW;GACT,IAAI,QAAQ,SAAS,GAAG;GACxB,KAAK,MAAM,MAAM,QAAQ,KAAK,GAAG;IAC/B,OAAO,EAAE;IACT,WAAW,EAAE;GACf;GACA,QAAQ,MAAM;GACd,UAAU;EACZ;EACA,SAAS;GACP,KAAK,MAAM,MAAM,QAAQ,KAAK,GAAG,WAAW,EAAE;GAC9C,UAAU;EACZ;EACA,WAAW,UAAU;EACrB,gBAAgB;GACd,OAAO;EACT;EACA,YAAY,eAAe,KAAK;CAClC;CACA,OAAO;AACT"}
+{"version":3,"file":"poseOverrides.js","names":[],"sources":["../../../src/core/scene/poseOverrides.ts"],"sourcesContent":["import { createEmitter } from '@weasel-js/registry';\nimport { dropPoseKeyedMemoSlots } from './nodeMemo';\nimport { shownCopyOf } from './nodeAsShown';\nimport { createPoseHold } from './poseHold';\nimport { foldPlies } from './posePlies';\nimport { createPlyStacks, plyPath, type CarriedPath } from './plyStacks';\nimport type { NodeId, PoseOverride, PoseOverrides } from './types';\n\n/**\n * Build a {@link PoseOverrides} map.\n *\n * `getNode` resolves an id to the node object the painter memo is keyed on.\n * `onInvalidate` lets the scene invalidate derived nodes from the same\n * chokepoint.\n *\n * What `read` answers is folded from the node's plies by `foldPlies`, its\n * path by `plyPath`; a node holding no entry is never probed.\n */\nexport function createPoseOverrides<TPose, TData = unknown>(\n  getNode: (id: NodeId) => { data?: unknown } | undefined,\n  onInvalidate?: (id: NodeId) => void,\n): PoseOverrides<TPose, TData> {\n  type Entry = PoseOverride<TPose, TData>;\n  const stacks = createPlyStacks<Entry>();\n  const { plies } = stacks;\n  const fold = foldPlies(plies);\n  const listeners = createEmitter();\n  let generation = 0;\n\n  /** Per node: the object `read` folds into and returns, the generation it\n   *  was last folded at, and the last path it carried. */\n  const reads = new Map<NodeId, { out: Entry; at: number; carried?: CarriedPath }>();\n\n  function invalidate(id: NodeId): void {\n    const node = getNode(id);\n    if (node) {\n      dropPoseKeyedMemoSlots(node);\n      // A painter handed the node as it shows memoized against that copy.\n      const shown = shownCopyOf(node);\n      if (shown) dropPoseKeyedMemoSlots(shown);\n    }\n    onInvalidate?.(id);\n  }\n\n  function published(): void {\n    generation++;\n    fold.publish(stacks.depth());\n    listeners.emit();\n  }\n\n  function forget(id: NodeId): void {\n    reads.delete(id);\n    fold.drop(id);\n  }\n\n  const table: PoseOverrides<TPose, TData> = {\n    set(id, entry) {\n      stacks.claim(id, entry);\n      invalidate(id);\n      published();\n    },\n    get(id) {\n      return plies.get(id)?.at(-1);\n    },\n    read(id) {\n      const stack = plies.get(id);\n      if (stack === undefined) return undefined;\n      let held = reads.get(id);\n      if (held === undefined) {\n        held = { out: {}, at: -1 };\n        reads.set(id, held);\n      }\n      if (held.at !== generation) {\n        fold.probe(id, held.out);\n        held.out.path = plyPath(stack, held.out.pose, held);\n        held.at = generation;\n      }\n      return held.out;\n    },\n    has(id, entry) {\n      const stack = plies.get(id);\n      return stack !== undefined && (entry === undefined || stack.includes(entry));\n    },\n    ids() {\n      return [...plies.keys()];\n    },\n    clear(id, entry) {\n      if (!(entry === undefined ? stacks.drop(id) : stacks.release(id, entry))) return;\n      if (!plies.has(id)) forget(id);\n      invalidate(id);\n      published();\n    },\n    clearAll() {\n      if (plies.size === 0) return;\n      for (const id of plies.keys()) {\n        forget(id);\n        invalidate(id);\n      }\n      stacks.dropAll();\n      published();\n    },\n    commit() {\n      for (const id of plies.keys()) invalidate(id);\n      published();\n    },\n    subscribe: listeners.subscribe,\n    getGeneration() {\n      return generation;\n    },\n    hold: () => createPoseHold(table, (id) => plies.get(id)),\n  };\n  return table;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAkBA,SAAgB,oBACd,SACA,cAC6B;CAE7B,MAAM,SAAS,gBAAuB;CACtC,MAAM,EAAE,UAAU;CAClB,MAAM,OAAO,UAAU,KAAK;CAC5B,MAAM,YAAY,cAAc;CAChC,IAAI,aAAa;;;CAIjB,MAAM,wBAAQ,IAAI,IAA+D;CAEjF,SAAS,WAAW,IAAkB;EACpC,MAAM,OAAO,QAAQ,EAAE;EACvB,IAAI,MAAM;GACR,uBAAuB,IAAI;GAE3B,MAAM,QAAQ,YAAY,IAAI;GAC9B,IAAI,OAAO,uBAAuB,KAAK;EACzC;EACA,eAAe,EAAE;CACnB;CAEA,SAAS,YAAkB;EACzB;EACA,KAAK,QAAQ,OAAO,MAAM,CAAC;EAC3B,UAAU,KAAK;CACjB;CAEA,SAAS,OAAO,IAAkB;EAChC,MAAM,OAAO,EAAE;EACf,KAAK,KAAK,EAAE;CACd;CAEA,MAAM,QAAqC;EACzC,IAAI,IAAI,OAAO;GACb,OAAO,MAAM,IAAI,KAAK;GACtB,WAAW,EAAE;GACb,UAAU;EACZ;EACA,IAAI,IAAI;GACN,OAAO,MAAM,IAAI,EAAE,CAAC,EAAE,GAAG,EAAE;EAC7B;EACA,KAAK,IAAI;GACP,MAAM,QAAQ,MAAM,IAAI,EAAE;GAC1B,IAAI,UAAU,QAAW,OAAO;GAChC,IAAI,OAAO,MAAM,IAAI,EAAE;GACvB,IAAI,SAAS,QAAW;IACtB,OAAO;KAAE,KAAK,CAAC;KAAG,IAAI;IAAG;IACzB,MAAM,IAAI,IAAI,IAAI;GACpB;GACA,IAAI,KAAK,OAAO,YAAY;IAC1B,KAAK,MAAM,IAAI,KAAK,GAAG;IACvB,KAAK,IAAI,OAAO,QAAQ,OAAO,KAAK,IAAI,MAAM,IAAI;IAClD,KAAK,KAAK;GACZ;GACA,OAAO,KAAK;EACd;EACA,IAAI,IAAI,OAAO;GACb,MAAM,QAAQ,MAAM,IAAI,EAAE;GAC1B,OAAO,UAAU,WAAc,UAAU,UAAa,MAAM,SAAS,KAAK;EAC5E;EACA,MAAM;GACJ,OAAO,CAAC,GAAG,MAAM,KAAK,CAAC;EACzB;EACA,MAAM,IAAI,OAAO;GACf,IAAI,EAAE,UAAU,SAAY,OAAO,KAAK,EAAE,IAAI,OAAO,QAAQ,IAAI,KAAK,IAAI;GAC1E,IAAI,CAAC,MAAM,IAAI,EAAE,GAAG,OAAO,EAAE;GAC7B,WAAW,EAAE;GACb,UAAU;EACZ;EACA,WAAW;GACT,IAAI,MAAM,SAAS,GAAG;GACtB,KAAK,MAAM,MAAM,MAAM,KAAK,GAAG;IAC7B,OAAO,EAAE;IACT,WAAW,EAAE;GACf;GACA,OAAO,QAAQ;GACf,UAAU;EACZ;EACA,SAAS;GACP,KAAK,MAAM,MAAM,MAAM,KAAK,GAAG,WAAW,EAAE;GAC5C,UAAU;EACZ;EACA,WAAW,UAAU;EACrB,gBAAgB;GACd,OAAO;EACT;EACA,YAAY,eAAe,QAAQ,OAAO,MAAM,IAAI,EAAE,CAAC;CACzD;CACA,OAAO;AACT"}

package/dist/core/scene/posePlies.js

@@ -0,0 +1,59 @@
+import { kit, last, mix, mul, patch } from "@msb235/blits";
+
+//#region src/core/scene/posePlies.ts
+/** What a ply says about a node with fewer plies than its depth. */
+var NOTHING = Object.freeze({});
+/** Per lower function, per upper one, the two run in turn: kept, so a node
+*  shows one function while neither ply replaces its own. */
+var composed = /* @__PURE__ */ new WeakMap();
+function after(lower, upper) {
+	let byUpper = composed.get(lower);
+	if (byUpper === void 0) composed.set(lower, byUpper = /* @__PURE__ */ new WeakMap());
+	let both = byUpper.get(upper);
+	if (both === void 0) byUpper.set(upper, both = (stored) => upper(lower(stored)));
+	return both;
+}
+/** A later ply's data runs on what the plies under it show. */
+var DATA = {
+	merge: after,
+	lerp: (a, b, u) => u < .5 ? a : b
+};
+/** A fold over `plies`, each node's entries bottom first. */
+function foldPlies(plies) {
+	const folded = mix(kit({
+		pose: last(),
+		alpha: mul(),
+		path: last(),
+		data: DATA
+	}));
+	/** One voice per depth, bottom first; only ever cut from the top, so cue order stays depth order. */
+	const voices = [];
+	let clock = 0;
+	const publish = (depth) => {
+		while (voices.length > depth) voices.pop().fade({ over: 0 });
+		while (voices.length < depth) {
+			const k = voices.length;
+			voices.push(folded.cue({ patch: patch(0, (_phase, id) => plies.get(id)?.[k] ?? NOTHING, { writes: [
+				"pose",
+				"alpha",
+				"path",
+				"data"
+			] }) }));
+		}
+		folded.sync(clock++);
+	};
+	publish(1);
+	return {
+		probe: (id, out) => {
+			folded.probe(id, out);
+		},
+		publish,
+		drop: (id) => {
+			folded.drop(id);
+		}
+	};
+}
+
+//#endregion
+export { foldPlies };
+//# sourceMappingURL=posePlies.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"posePlies.js","names":[],"sources":["../../../src/core/scene/posePlies.ts"],"sourcesContent":["/**\n * The fold behind `PoseOverrides.read`: a blits mix over each node's plies of\n * overrides, one voice per depth, cued bottom first, so a later ply folds\n * over an earlier one.\n */\nimport type { Path } from '@weasel-js/geom';\nimport { kit, last, mix, mul, patch, type Channel, type Handle } from '@msb235/blits';\nimport type { NodeId, PoseOverride } from './types';\n\n/** What a ply says about a node with fewer plies than its depth. */\nconst NOTHING: PoseOverride<never> = Object.freeze({});\n\ntype ShowData = (stored: never) => unknown;\n\n/** Per lower function, per upper one, the two run in turn: kept, so a node\n *  shows one function while neither ply replaces its own. */\nconst composed = new WeakMap<ShowData, WeakMap<ShowData, ShowData>>();\n\nfunction after(lower: ShowData, upper: ShowData): ShowData {\n  let byUpper = composed.get(lower);\n  if (byUpper === undefined) composed.set(lower, byUpper = new WeakMap());\n  let both = byUpper.get(upper);\n  if (both === undefined) byUpper.set(upper, both = (stored) => upper(lower(stored) as never));\n  return both;\n}\n\n/** A later ply's data runs on what the plies under it show. */\nconst DATA: Channel<ShowData> = { merge: after, lerp: (a, b, u) => (u < 0.5 ? a : b) };\n\n/** {@link foldPlies}'s handle. */\nexport interface PlyFold<Entry> {\n  /** Fold `id`'s plies into `out`, as of the last `publish`. */\n  probe(id: NodeId, out: Entry): void;\n  /** Make the next probe of every node fold afresh, `depth` plies deep. */\n  publish(depth: number): void;\n  /** Forget what the fold keeps for `id`. */\n  drop(id: NodeId): void;\n}\n\n/** A fold over `plies`, each node's entries bottom first. */\nexport function foldPlies<TPose, TData>(\n  plies: ReadonlyMap<NodeId, readonly PoseOverride<TPose, TData>[]>,\n): PlyFold<PoseOverride<TPose, TData>> {\n  type Entry = PoseOverride<TPose, TData>;\n  const folded = mix<NodeId, Entry>(\n    kit<Entry>({\n      pose: last<NonNullable<TPose>>(),\n      alpha: mul(),\n      path: last<Path>(),\n      data: DATA as unknown as Channel<NonNullable<Entry['data']>>,\n    }),\n  );\n  /** One voice per depth, bottom first; only ever cut from the top, so cue order stays depth order. */\n  const voices: Handle<NodeId>[] = [];\n  // Mix time only has to move between publishes, so a probe after one never\n  // hands back the delta a probe before it cached.\n  let clock = 0;\n  const publish = (depth: number): void => {\n    while (voices.length > depth) voices.pop()!.fade({ over: 0 });\n    while (voices.length < depth) {\n      const k = voices.length;\n      voices.push(folded.cue({\n        patch: patch<NodeId, Entry>(\n          0,\n          (_phase, id) => plies.get(id)?.[k] ?? (NOTHING as Entry),\n          { writes: ['pose', 'alpha', 'path', 'data'] },\n        ),\n      }));\n    }\n    folded.sync(clock++);\n  };\n  publish(1);\n  return {\n    probe: (id, out) => { folded.probe(id, out); },\n    publish,\n    drop: (id) => { folded.drop(id); },\n  };\n}\n"],"mappings":";;;;AAUA,IAAM,UAA+B,OAAO,OAAO,CAAC,CAAC;;;AAMrD,IAAM,2BAAW,IAAI,QAA+C;AAEpE,SAAS,MAAM,OAAiB,OAA2B;CACzD,IAAI,UAAU,SAAS,IAAI,KAAK;CAChC,IAAI,YAAY,QAAW,SAAS,IAAI,OAAO,0BAAU,IAAI,QAAQ,CAAC;CACtE,IAAI,OAAO,QAAQ,IAAI,KAAK;CAC5B,IAAI,SAAS,QAAW,QAAQ,IAAI,OAAO,QAAQ,WAAW,MAAM,MAAM,MAAM,CAAU,CAAC;CAC3F,OAAO;AACT;;AAGA,IAAM,OAA0B;CAAE,OAAO;CAAO,OAAO,GAAG,GAAG,MAAO,IAAI,KAAM,IAAI;AAAG;;AAarF,SAAgB,UACd,OACqC;CAErC,MAAM,SAAS,IACb,IAAW;EACT,MAAM,KAAyB;EAC/B,OAAO,IAAI;EACX,MAAM,KAAW;EACjB,MAAM;CACR,CAAC,CACH;;CAEA,MAAM,SAA2B,CAAC;CAGlC,IAAI,QAAQ;CACZ,MAAM,WAAW,UAAwB;EACvC,OAAO,OAAO,SAAS,OAAO,OAAO,IAAI,CAAC,CAAE,KAAK,EAAE,MAAM,EAAE,CAAC;EAC5D,OAAO,OAAO,SAAS,OAAO;GAC5B,MAAM,IAAI,OAAO;GACjB,OAAO,KAAK,OAAO,IAAI,EACrB,OAAO,MACL,IACC,QAAQ,OAAO,MAAM,IAAI,EAAE,CAAC,GAAG,MAAO,SACvC,EAAE,QAAQ;IAAC;IAAQ;IAAS;IAAQ;GAAM,EAAE,CAC9C,EACF,CAAC,CAAC;EACJ;EACA,OAAO,KAAK,OAAO;CACrB;CACA,QAAQ,CAAC;CACT,OAAO;EACL,QAAQ,IAAI,QAAQ;GAAE,OAAO,MAAM,IAAI,GAAG;EAAG;EAC7C;EACA,OAAO,OAAO;GAAE,OAAO,KAAK,EAAE;EAAG;CACnC;AACF"}

package/dist/core/scene/reconcileSpecs.js

@@ -1,4 +1,4 @@
-import { isPlainObject } from "../isPlainObject.js";
+import { sameValue } from "./sameValue.js";
 
 //#region src/core/scene/reconcileSpecs.ts
 /**
@@ -39,10 +39,11 @@ function reconcileSpecs(scene, prev, next) {
 			const parent = spec.parent ?? null;
 			if (parent !== (before.parent ?? null)) scene.move(id, parent);
 			if (spec.layer !== before.layer) scene.setLayer(id, spec.layer);
-			if (!same(spec.data, before.data)) scene.update(id, { data: spec.data });
-			if (!same(spec.dependsOn, before.dependsOn)) scene.setDependsOn(id, spec.dependsOn);
-			if (spec.kind === "container" && !same(spec.units, before.units)) scene.setUnits(id, spec.units ?? null);
-			if (!same(spec.pose, before.pose)) scene.setPose(id, spec.pose);
+			if (!sameValue(spec.data, before.data)) scene.update(id, { data: spec.data });
+			if (!sameValue(spec.dependsOn, before.dependsOn)) scene.setDependsOn(id, spec.dependsOn);
+			if (!sameValue(spec.units, before.units)) scene.setUnits(id, spec.units ?? null);
+			if (spec.clip !== before.clip) scene.setClip(id, spec.clip ?? null);
+			if (!sameValue(spec.pose, before.pose)) scene.setPose(id, spec.pose);
 			if (spec.hidden === true !== (before.hidden === true)) scene.setHidden(id, spec.hidden === true);
 			if (spec.locked === true && before.locked !== true) scene.setLocked(id, true);
 		}
@@ -61,16 +62,6 @@ function byId(specs) {
 function needsReplace(a, b) {
 	return a.kind !== b.kind || a.pickable !== b.pickable || a.derivePath !== b.derivePath || a.derivePose !== b.derivePose || a.clipFromPose !== b.clipFromPose || a.copiesFromPose !== b.copiesFromPose || a.layout !== b.layout;
 }
-/** Structural equality over plain objects and arrays; anything else by identity. */
-function same(a, b) {
-	if (Object.is(a, b)) return true;
-	if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((v, i) => same(v, b[i]));
-	if (isPlainObject(a) && isPlainObject(b)) {
-		const ka = Object.keys(a);
-		return ka.length === Object.keys(b).length && ka.every((k) => k in b && same(a[k], b[k]));
-	}
-	return false;
-}
 
 //#endregion
 export { reconcileSpecs };