incanto 0.43.0 → 0.45.0

package/dist/{environment-presets-Ds5kXLoF.js → environment-presets-2GgTlPt1.js}

@@ -5958,6 +5958,96 @@ function boneSubtree(root) {
 	return out;
 }
 //#endregion
+//#region src/3d/animation/retarget-rig.ts
+/**
+* Play someone else's animation without becoming someone else.
+*
+* A Mixamo clip is not a list of rotations. It carries a POSITION and a SCALE
+* track for every bone — 195 tracks for 65 bones on the stock character — and
+* three's mixer applies all of them. Bind a clip like that to a character by
+* node name and the clip does not animate the character: it REPLACES the
+* character's skeleton with the one the clip was authored on. A stocky
+* four-heads-tall model quietly becomes eight heads tall the moment it idles,
+* and there is nothing in the scene JSON that says so.
+*
+* That is backwards. The model owns its proportions; the animation is the thing
+* that has to adapt. So only the rotations cross over — they mean the same
+* thing on any skeleton — and of the translations only the hips survive, scaled
+* by the ratio of hip heights. That one exception matters: hip travel is in the
+* SOURCE rig's units, so handing a short character a tall rig's stride slides
+* its feet and overshoots its jumps.
+*
+* Same algorithm the VRM path has always used (`retarget-vrm.ts`), which until
+* now was the only path that had it.
+*/
+/** Mixamo exports this bone as `mixamorigHips` or `mixamorig:Hips`. */
+function findHips(root) {
+	let found = null;
+	root.traverse((o) => {
+		if (found) return;
+		if (/^mixamorig[:_]?hips$/i.test(o.name) || /^hips$/i.test(o.name)) found = o;
+	});
+	return found;
+}
+/** How high the hips sit above the rig's own root, in that rig's own units. */
+function hipHeight(root, hips) {
+	root.updateMatrixWorld(true);
+	const inRoot = hips.matrixWorld.clone().premultiply(root.matrixWorld.clone().invert());
+	return Math.abs(inRoot.elements[13] ?? 0);
+}
+const boneOf = (trackName) => trackName.split(".")[0] ?? "";
+const propertyOf = (trackName) => trackName.split(".").pop() ?? "";
+/**
+* A copy of `clip` that animates `targetRoot` without re-proportioning it.
+*
+* Passes the clip through untouched when it cannot do better — a clip whose
+* bones the target does not have would be stripped to nothing, and a silent
+* empty animation is worse than a wrong-sized one.
+*/
+function retargetClipToRig(clip, sourceScene, targetRoot) {
+	const targetBones = /* @__PURE__ */ new Set();
+	targetRoot.traverse((o) => targetBones.add(o.name));
+	if (clip.tracks.filter((t) => propertyOf(t.name) === "quaternion" && targetBones.has(boneOf(t.name))).length === 0) return {
+		clip,
+		droppedTracks: 0,
+		hipsScale: 1,
+		passthrough: true,
+		reason: "no bone in this clip matches the model — played as authored"
+	};
+	const sourceHips = findHips(sourceScene);
+	const targetHips = findHips(targetRoot);
+	const sourceHeight = sourceHips ? hipHeight(sourceScene, sourceHips) : 0;
+	const targetHeight = targetHips ? hipHeight(targetRoot, targetHips) : 0;
+	const hipsScale = sourceHeight > 1e-6 && targetHeight > 1e-6 ? targetHeight / sourceHeight : 1;
+	const hipsName = targetHips?.name ?? "";
+	const tracks = [];
+	let dropped = 0;
+	for (const track of clip.tracks) {
+		const bone = boneOf(track.name);
+		const property = propertyOf(track.name);
+		if (!targetBones.has(bone)) {
+			dropped += 1;
+			continue;
+		}
+		if (property === "quaternion") {
+			tracks.push(track);
+			continue;
+		}
+		if (property === "position" && bone === hipsName) {
+			const values = Array.from(track.values, (v) => v * hipsScale);
+			tracks.push(new VectorKeyframeTrack(track.name, Array.from(track.times), values));
+			continue;
+		}
+		dropped += 1;
+	}
+	return {
+		clip: new AnimationClip(`${clip.name} (retargeted)`, clip.duration, tracks),
+		droppedTracks: dropped,
+		hipsScale,
+		passthrough: false
+	};
+}
+//#endregion
 //#region src/3d/animation/rigmap.ts
 /**
 * Mixamo rig name → VRM humanoid bone name (the vibe-starter-3d /
@@ -6190,6 +6280,8 @@ var ModelInstance3D = class extends Node3D {
 	entry = null;
 	mountedRef = "";
 	fittedHeight = -1;
+	/** A skinned model waiting for a posed skeleton it can be measured against. */
+	fitPending = false;
 	fitGroup = null;
 	/**
 	* @internal The mounted model, or null while the asset is still loading.
@@ -6340,18 +6432,15 @@ var ModelInstance3D = class extends Node3D {
 				});
 			});
 		}
-		if (this.fitGroup && this.fittedHeight !== this.targetHeight) {
-			this.fittedHeight = this.targetHeight;
-			if (this.targetHeight > 0) {
-				const prev = this.fitGroup.scale.x;
-				this.fitGroup.scale.setScalar(1);
-				const size = skinnedAwareBox(this.fitGroup).getSize(new Vector3());
-				const scale = size.y > 0 ? this.targetHeight / size.y : prev;
-				if (scale < .05 || scale > 20) {
+		if (this.fitGroup) {
+			if (this.fittedHeight !== this.targetHeight) {
+				this.fittedHeight = this.targetHeight;
+				if (this.targetHeight <= 0) {
 					this.fitGroup.scale.setScalar(1);
-					this.diagnose("warn", `[incanto] ModelInstance3D '${this.name}': targetHeight fit measured an implausible scale (${scale.toFixed(2)}x) — skinned rigs defeat bounding-box measurement. Rendering at the model's authored scale instead.`);
-				} else this.fitGroup.scale.setScalar(scale);
-			} else this.fitGroup.scale.setScalar(1);
+					this.fitPending = false;
+				} else if (hasSkinning(this.fitGroup)) this.fitPending = true;
+				else this.applyFit();
+			}
 		}
 		if (this.fitGroup) this.fitGroup.traverse((obj) => {
 			const mesh = obj;
@@ -6365,6 +6454,30 @@ var ModelInstance3D = class extends Node3D {
 		this.syncAnimation(assets);
 		this.syncUpperAnimation(assets);
 	}
+	/**
+	* Scale the model so it stands `targetHeight` tall, measured ONCE.
+	*
+	* Once, deliberately: the measurement reflects the pose the model happens to
+	* be in, and re-running it every frame would let a walk cycle resize the
+	* character mid-stride. In practice the pose barely matters — across a whole
+	* idle clip this rig's height moves 0.5% — but "barely" is not "never", and
+	* a size that breathes is worse than one that is half a percent off.
+	*/
+	applyFit() {
+		const fit = this.fitGroup;
+		if (!fit) return;
+		this.fitPending = false;
+		const previous = fit.scale.x;
+		fit.scale.setScalar(1);
+		const height = renderedBox(fit).getSize(new Vector3()).y;
+		const scale = height > 0 ? this.targetHeight / height : previous;
+		if (scale < .05 || scale > 20) {
+			fit.scale.setScalar(1);
+			this.diagnose("warn", `[incanto] ModelInstance3D '${this.name}': targetHeight fit measured an implausible scale (${scale.toFixed(2)}x) — the model may have no geometry. Rendering at the model's authored scale instead.`);
+			return;
+		}
+		fit.scale.setScalar(scale);
+	}
 	/** Apply per-instance material mods — `tint` (multiplied into colour) and the
 	*  `metalness`/`roughness` overrides — by cloning the captured originals
 	*  (never mutates the shared source), disposing prior clones on change. */
@@ -6427,7 +6540,12 @@ var ModelInstance3D = class extends Node3D {
 			this.entry.retargeted.set(ref, result.clip);
 			return result.clip;
 		}
-		return source;
+		const cached = this.entry.retargeted.get(ref);
+		if (cached) return cached;
+		const rig = retargetClipToRig(source, anim.scene, this.fitGroup ?? this._ensureObject3D());
+		if (rig.passthrough) this.diagnose("warn", `incanto: animation '${ref}' — ${rig.reason}`);
+		this.entry.retargeted.set(ref, rig.clip);
+		return rig.clip;
 	}
 	/** Masked upper/lower variants of a clip for two-layer playback (cached). */
 	layerVariants(clip) {
@@ -6536,6 +6654,7 @@ var ModelInstance3D = class extends Node3D {
 		}
 		this.mixer?.update(dt);
 		if (this.entry?.isVrm && this.entry.claimedBy === this) this.entry.vrm?.update(dt);
+		if (this.fitPending) this.applyFit();
 	}
 	onExitTree() {
 		this.unmount(this._ensureObject3D());
@@ -6560,39 +6679,57 @@ var ModelInstance3D = class extends Node3D {
 		this.fittedHeight = -1;
 	}
 };
+/** Does anything under here reach the screen through a skeleton? */
+function hasSkinning(root) {
+	let found = false;
+	root.traverse((o) => {
+		if (o.isSkinnedMesh) found = true;
+	});
+	return found;
+}
 /**
-* Height measurement SkinnedMesh can't lie about. Static bounding boxes fail
-* twice on mixamo-style rigs (0.01 armature scale hides the true size, and
-* the current animation pose skews any vertex-based box), so skinned meshes
-* measure their BONE BIND positions — skeleton.boneInverses inverted gives
-* each bone's rest position in mesh space, pose-independent and exact.
-* Plain meshes keep the geometry-box route.
+* How big the model will actually BE on screen, in the fit group's own space.
+*
+* A skinned vertex does not reach the screen through `matrixWorld`. three puts
+* it through the whole skinning chain
+*
+*     world = matrixWorld · bindMatrixInverse · boneMatrix · bindMatrix · v
+*
+* and on a mixamo rig those terms are not decoration: the armature carries a
+* 0.01 node scale that lives in one of them and the 100 cancelling it lives in
+* another. Measuring the geometry box through `matrixWorld` alone — the obvious
+* thing, and what this did for four releases — reported the character a HUNDRED
+* times too small, tripped the plausibility guard, and silently threw away
+* `targetHeight` on every skinned character in four shipped templates.
+*
+* Every cheaper proxy is wrong too, and by enough to see: on the same character
+* the joint positions measure 1.49 and the bind-pose geometry box 1.50 where
+* the renderer draws 1.66. So skinned meshes are measured the way three itself
+* measures them — `getVertexPosition`, which walks each vertex through its bone
+* transforms. Fitting to that gave 1.7000 for a `targetHeight` of 1.7 and
+* 2.5001 for 2.5.
+*
+* Rigid meshes keep their bounding box: it is exact for them and free.
 */
-function skinnedAwareBox(root) {
-	root.updateWorldMatrix(true, true);
+function renderedBox(root) {
+	root.updateMatrixWorld(true);
 	const box = new Box3();
 	const tmp = new Box3();
-	const invRoot = root.matrixWorld.clone().invert();
-	const m4 = new Matrix4();
 	const v = new Vector3();
+	const invRoot = root.matrixWorld.clone().invert();
 	root.traverse((o) => {
-		const skinned = o;
-		if (skinned.isSkinnedMesh && skinned.skeleton) {
-			for (const inverse of skinned.skeleton.boneInverses) {
-				m4.copy(inverse).invert().premultiply(skinned.matrixWorld).premultiply(invRoot);
-				v.setFromMatrixPosition(m4);
-				box.expandByPoint(v);
-			}
-			return;
-		}
 		const mesh = o;
-		if (mesh.isMesh && mesh.geometry) {
-			mesh.geometry.computeBoundingBox();
-			if (mesh.geometry.boundingBox) {
-				tmp.copy(mesh.geometry.boundingBox).applyMatrix4(mesh.matrixWorld).applyMatrix4(invRoot);
-				box.union(tmp);
+		if (!mesh.isMesh || !mesh.geometry) return;
+		const position = mesh.geometry.getAttribute("position");
+		if (mesh.isSkinnedMesh && typeof mesh.getVertexPosition === "function" && position && mesh.geometry.getAttribute("skinIndex") && mesh.geometry.getAttribute("skinWeight") && position) {
+			for (let i = 0; i < position.count; i++) {
+				mesh.getVertexPosition?.(i, v);
+				box.expandByPoint(v.applyMatrix4(mesh.matrixWorld).applyMatrix4(invRoot));
 			}
+			return;
 		}
+		mesh.geometry.computeBoundingBox();
+		if (mesh.geometry.boundingBox) box.union(tmp.copy(mesh.geometry.boundingBox).applyMatrix4(mesh.matrixWorld).applyMatrix4(invRoot));
 	});
 	return box;
 }

package/dist/frame-report-Ct8XgsmV.d.ts

@@ -0,0 +1,80 @@
+//#region src/3d/frame-report.d.ts
+/**
+* What the frame looks like, as something worth saying.
+*
+* The pixels are not the deliverable. A 1280x720 frame is 2.8 million numbers:
+* unreadable by a person, unaffordable for a model (roughly a thousand tokens
+* as an image, roughly a million as text). The deliverable is the JUDGEMENT —
+* black screen, one flat colour, washed out — and the numbers behind it, small
+* enough to print and compare.
+*
+* Same principle as `framing`'s "lit by: NOTHING": a report is a sentence
+* before it is a number, because a number needs a reader who already knows what
+* to compare it against.
+*
+* Pure arithmetic over an RGBA buffer — no three, no DOM, no GPU. Whoever has
+* the pixels calls this; in practice that is the browser holding the canvas.
+*/
+/** Per-cell mean colour, `[r, g, b]` 0..255. */
+type GridCell = [number, number, number];
+interface FrameStats {
+  width: number;
+  height: number;
+  /** Every pixel below the black threshold — the render produced nothing. */
+  black: boolean;
+  /** One colour everywhere: a clear-colour fill, or a camera inside geometry. */
+  uniform: boolean;
+  /** 0..1 mean relative luminance. */
+  meanLuma: number;
+  /** Coarse mean colour per cell, rows top to bottom. */
+  grid: GridCell[][];
+}
+interface FrameStatsOptions {
+  /** Cells across and down. Default 16x9 — 144 cells, printable. */
+  grid?: [number, number];
+}
+declare function frameStats(pixels: Uint8Array | Uint8ClampedArray, width: number, height: number, opts?: FrameStatsOptions): FrameStats;
+/** The report a person or an agent reads. Verdict first, numbers after. */
+declare function frameText(stats: FrameStats): string;
+/**
+* Comparison resolution. Fine enough that a one-pixel line moves a cell by
+* several levels at 720p, small enough (6912 bytes) to hold and to send.
+*/
+declare const SIGNATURE_GRID: readonly [number, number];
+interface FrameSignature {
+  /** The frame this was made from — a different size is not comparable. */
+  width: number;
+  height: number;
+  cols: number;
+  rows: number;
+  /** base64 of `cols * rows * 3` bytes: cell means, rows top to bottom. */
+  data: string;
+}
+interface FrameDiff {
+  /** False when the two cannot be subtracted at all; see `reason`. */
+  comparable: boolean;
+  reason?: string;
+  /** 0..1 fraction of cells that moved past the threshold. */
+  changed: number;
+  /** Largest single-channel move, 0..255. */
+  maxDelta: number;
+  /** Mean single-channel move across the frame, 0..255. */
+  meanDelta: number;
+  /** Where the change is, in pixels of the compared frame. */
+  box: {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+  } | null;
+  /** A thin full-length band is worth naming: that is what a seam looks like. */
+  shape: "vertical band" | "horizontal band" | null;
+}
+declare function frameSignature(pixels: Uint8Array | Uint8ClampedArray, width: number, height: number, grid?: readonly [number, number]): FrameSignature;
+declare function diffSignatures(before: FrameSignature, after: FrameSignature, opts?: {
+  threshold?: number;
+}): FrameDiff;
+/** The comparison a person or an agent reads. */
+declare function diffText(diff: FrameDiff): string;
+//#endregion
+export { GridCell as a, diffText as c, frameText as d, FrameStatsOptions as i, frameSignature as l, FrameSignature as n, SIGNATURE_GRID as o, FrameStats as r, diffSignatures as s, FrameDiff as t, frameStats as u };

package/dist/frame-report-Lr3VO24R.js

@@ -0,0 +1,197 @@
+//#region src/3d/frame-report.ts
+/** Rec. 709 relative luminance of an 8-bit triple, 0..1. */
+function luma(r, g, b) {
+	return (.2126 * r + .7152 * g + .0722 * b) / 255;
+}
+/**
+* A pixel this dark is indistinguishable from "nothing was drawn". Not zero:
+* a real render of a night scene still lands a few levels above black, and
+* calling that a failure would make the check useless where it matters most.
+*/
+const BLACK_LEVEL = .012;
+/** Cell-to-cell luminance range below this: the frame is one flat colour. */
+const UNIFORM_EPSILON = .004;
+/**
+* Mean colour of every cell of a `cols` x `rows` box filter, as a flat
+* `cols * rows * 3` byte array, rows top to bottom.
+*
+* The one place a frame is reduced. Both the printable report and the
+* comparison signature are this at different resolutions, so a boundary that
+* moves moves for both.
+*/
+function cellMeans(pixels, width, height, cols, rows) {
+	const out = new Uint8Array(cols * rows * 3);
+	for (let row = 0; row < rows; row++) for (let col = 0; col < cols; col++) {
+		const x0 = Math.floor(col * width / cols);
+		const x1 = Math.max(x0 + 1, Math.floor((col + 1) * width / cols));
+		const y0 = Math.floor(row * height / rows);
+		const y1 = Math.max(y0 + 1, Math.floor((row + 1) * height / rows));
+		let r = 0;
+		let g = 0;
+		let b = 0;
+		let n = 0;
+		for (let y = y0; y < y1; y++) for (let x = x0; x < x1; x++) {
+			const i = (y * width + x) * 4;
+			r += pixels[i] ?? 0;
+			g += pixels[i + 1] ?? 0;
+			b += pixels[i + 2] ?? 0;
+			n += 1;
+		}
+		const o = (row * cols + col) * 3;
+		out[o] = Math.round(r / n);
+		out[o + 1] = Math.round(g / n);
+		out[o + 2] = Math.round(b / n);
+	}
+	return out;
+}
+function frameStats(pixels, width, height, opts = {}) {
+	const [cols, rows] = opts.grid ?? [16, 9];
+	const means = cellMeans(pixels, width, height, cols, rows);
+	const grid = [];
+	let total = 0;
+	let maxLuma = 0;
+	let minLuma = 1;
+	for (let row = 0; row < rows; row++) {
+		const line = [];
+		for (let col = 0; col < cols; col++) {
+			const o = (row * cols + col) * 3;
+			const cell = [
+				means[o],
+				means[o + 1],
+				means[o + 2]
+			];
+			const cellLuma = luma(cell[0], cell[1], cell[2]);
+			total += cellLuma;
+			maxLuma = Math.max(maxLuma, cellLuma);
+			minLuma = Math.min(minLuma, cellLuma);
+			line.push(cell);
+		}
+		grid.push(line);
+	}
+	const cells = cols * rows;
+	const meanLuma = total / cells;
+	return {
+		width,
+		height,
+		black: maxLuma <= BLACK_LEVEL,
+		uniform: maxLuma - minLuma < UNIFORM_EPSILON,
+		meanLuma: Math.round(meanLuma * 1e3) / 1e3,
+		grid
+	};
+}
+/** The report a person or an agent reads. Verdict first, numbers after. */
+function frameText(stats) {
+	const lines = [];
+	if (stats.black) lines.push("BLACK SCREEN — nothing was drawn (no light, no camera, or nothing in view)");
+	else if (stats.uniform) lines.push("one flat colour — the camera may be inside geometry, or only the sky is drawn");
+	lines.push(`frame ${stats.width}×${stats.height} · luminance ${stats.meanLuma.toFixed(2)}`);
+	return lines.join("\n");
+}
+/**
+* Comparison resolution. Fine enough that a one-pixel line moves a cell by
+* several levels at 720p, small enough (6912 bytes) to hold and to send.
+*/
+const SIGNATURE_GRID = [64, 36];
+/**
+* Below this, a cell has not changed. Compression, dithering and the last bit
+* of a tonemap all wander by a level or two between two captures of the same
+* still frame; calling that a change would bury the real one.
+*/
+const DIFF_THRESHOLD = 3;
+function frameSignature(pixels, width, height, grid = SIGNATURE_GRID) {
+	const [cols, rows] = grid;
+	return {
+		width,
+		height,
+		cols,
+		rows,
+		data: toBase64(cellMeans(pixels, width, height, cols, rows))
+	};
+}
+function diffSignatures(before, after, opts = {}) {
+	const none = {
+		changed: 0,
+		maxDelta: 0,
+		meanDelta: 0,
+		box: null,
+		shape: null
+	};
+	if (before.width !== after.width || before.height !== after.height) return {
+		comparable: false,
+		reason: `frame size changed: ${before.width}×${before.height} → ${after.width}×${after.height}`,
+		...none
+	};
+	if (before.cols !== after.cols || before.rows !== after.rows) return {
+		comparable: false,
+		reason: "signature grid changed",
+		...none
+	};
+	const threshold = opts.threshold ?? DIFF_THRESHOLD;
+	const a = fromBase64(before.data);
+	const b = fromBase64(after.data);
+	const { cols, rows } = after;
+	let changedCells = 0;
+	let maxDelta = 0;
+	let totalDelta = 0;
+	let minCol = cols;
+	let maxCol = -1;
+	let minRow = rows;
+	let maxRow = -1;
+	for (let row = 0; row < rows; row++) for (let col = 0; col < cols; col++) {
+		const o = (row * cols + col) * 3;
+		const delta = Math.max(Math.abs((a[o] ?? 0) - (b[o] ?? 0)), Math.abs((a[o + 1] ?? 0) - (b[o + 1] ?? 0)), Math.abs((a[o + 2] ?? 0) - (b[o + 2] ?? 0)));
+		totalDelta += delta;
+		maxDelta = Math.max(maxDelta, delta);
+		if (delta >= threshold) {
+			changedCells += 1;
+			minCol = Math.min(minCol, col);
+			maxCol = Math.max(maxCol, col);
+			minRow = Math.min(minRow, row);
+			maxRow = Math.max(maxRow, row);
+		}
+	}
+	const cells = cols * rows;
+	const box = maxCol < 0 ? null : {
+		x: Math.floor(minCol * after.width / cols),
+		y: Math.floor(minRow * after.height / rows),
+		w: Math.ceil((maxCol + 1 - minCol) * after.width / cols),
+		h: Math.ceil((maxRow + 1 - minRow) * after.height / rows)
+	};
+	const spanCols = maxCol < 0 ? 0 : maxCol + 1 - minCol;
+	const spanRows = maxRow < 0 ? 0 : maxRow + 1 - minRow;
+	return {
+		comparable: true,
+		changed: changedCells / cells,
+		maxDelta,
+		meanDelta: Math.round(totalDelta / cells * 10) / 10,
+		box,
+		shape: spanCols > 0 && spanCols <= 2 && spanRows >= rows / 2 ? "vertical band" : spanRows > 0 && spanRows <= 2 && spanCols >= cols / 2 ? "horizontal band" : null
+	};
+}
+/** The comparison a person or an agent reads. */
+function diffText(diff) {
+	if (!diff.comparable) return `cannot compare — ${diff.reason ?? "unknown reason"}`;
+	if (diff.changed === 0) return `identical — nothing moved (largest cell shift ${diff.maxDelta}/255)`;
+	const lines = [`changed ${(diff.changed * 100).toFixed(1)}% of the frame · largest shift ${diff.maxDelta}/255, mean ${diff.meanDelta}`];
+	if (diff.box) {
+		const { x, y, w, h } = diff.box;
+		lines.push(`region x ${x}..${x + w}, y ${y}..${y + h}${diff.shape ? ` — a ${diff.shape}` : ""}`);
+	}
+	if (diff.changed > .9) lines.push("the whole frame moved — if the scene is animating, pause it first (debug ☰ → Time → Pause) so the comparison is of your change, not of time passing");
+	return lines.join("\n");
+}
+/** Portable in a browser and in node; both have had `btoa`/`atob` for years. */
+function toBase64(bytes) {
+	let binary = "";
+	const CHUNK = 32768;
+	for (let i = 0; i < bytes.length; i += CHUNK) binary += String.fromCharCode(...bytes.subarray(i, i + CHUNK));
+	return btoa(binary);
+}
+function fromBase64(text) {
+	const binary = atob(text);
+	const out = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) out[i] = binary.charCodeAt(i);
+	return out;
+}
+//#endregion
+export { frameStats as a, frameSignature as i, diffSignatures as n, frameText as o, diffText as r, SIGNATURE_GRID as t };

package/dist/index.js

@@ -7,7 +7,7 @@ import { n as jsonEquals, r as jsonKind, t as jsonClone } from "./json-BLk7H2Qa.
 import { a as getNodeSignals, c as mergeStaticSignals, i as getNodeSchema, l as registerNode, n as clearRegistry, o as getNodeType, r as createNode, u as registeredTypes } from "./registry-IyWCGe4q.js";
 import { t as createNoise2D } from "./noise-CGUMx44x.js";
 import { i as applyParticlePreset, n as PARTICLE_PRESETS, r as PARTICLE_PRESET_NAMES, t as ParticleSim } from "./particle-sim-Bw7hB93B.js";
-import { a as findPath, i as preloadUrls, n as newUid, o as gridFromRows, r as assetUrls, t as VERSION } from "./src-CwYxzZKl.js";
+import { a as findPath, i as preloadUrls, n as newUid, o as gridFromRows, r as assetUrls, t as VERSION } from "./src-CV_uN7j4.js";
 import { i as resolveRendering, n as attachTouchControls, r as joystickVector, t as TouchControls } from "./touch-BoNg_MnF.js";
 import { t as duplicateNode } from "./duplicate-CRtihGmC.js";
 export { AudioBuses, AudioPlayer, BASE_LOCALE, Behavior, CONST_REF_KEY, Engine, HudLayer, IncantoError, InputMap, Localization, LogManager, MusicManager, Node, ORDER_GROUP_BASE, PARTICLE_PRESETS, PARTICLE_PRESET_NAMES, ParticleSim, ROLLOFF_MODELS, Rng, SCENE_FORMAT, SFX_PRESETS, SFX_PRESET_NAMES, SaveSlots, Scene, SceneTree, Settings, SfxEngine, Signal, T_PREFIX, Timer, TouchControls, UiBanner, UiBar, UiButton, UiDialogue, UiImage, UiPanel, UiSelect, UiSlider, UiText, UiToggle, VERSION, WebAudioMusicBackend, applyParticlePreset, assetUrls, attachTouchControls, auditScene, behaviorSchema, behaviorSignals, behaviorsWithoutSave, captureBehaviors, clearBehaviors, clearRegistry, computeViewport, createNode, createNoise2D, createSaveStore, crossfadeGains, duplicateNode, effectiveOrder, fadeGain, findPath, getBehavior, getNodeSchema, getNodeSignals, getNodeType, gridFromRows, isAudioContextAvailable, isConstRef, joystickVector, jsonClone, jsonEquals, jsonKind, loadScene, mergeStaticSignals, newUid, parseNodePath, preloadUrls, qualityEnvironment, readDeviceHints, registerBehavior, registerCoreNodes, registerNode, registeredBehaviors, registeredTypes, replay, resolveConstants, resolveOrderGroups, resolveRendering, resolveViewport, restoreBehaviors, serializeNode, spatialGain, spatialPan, startRecording, suggestLocale, suggestQuality, synthSfx, translationKey };

package/dist/{physics-3d-CLPFv99o.js → physics-3d-nLI_8bUR.js}

@@ -3,7 +3,7 @@ import { v as diagnose } from "./loader-r49nDwB4.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { F as PhysicsBody3D, I as RigidBody3D, N as Area3D, P as CharacterBody3D, R as Node3D, z as validateCollider3D } from "./gameplay-BQOeAid6.js";
 import { n as registerDebugSource } from "./debug-draw-BM3DsvtT.js";
-import { A as Terrain3D, F as InstancedMesh3D, L as buildMeshGeometry, P as Joint3D } from "./environment-presets-Ds5kXLoF.js";
+import { A as Terrain3D, F as InstancedMesh3D, L as buildMeshGeometry, P as Joint3D } from "./environment-presets-2GgTlPt1.js";
 import { Euler, Matrix4, Quaternion, Vector3 } from "three";
 //#region src/3d/physics/collider-lines.ts
 /**

package/dist/react.js

@@ -156,7 +156,7 @@ function IncantoCanvas(props) {
 				pointer: latest.pointer,
 				...keyboard !== void 0 ? { keyboard } : {}
 			};
-			const next = await (_gameFactory ?? (mode === "3d" ? async (o) => (await import("./create-game-B3vBWgVD.js").then((n) => n.n)).createGame3D(o) : async (o) => (await import("./create-game-DFRbG0Bj.js").then((n) => n.n)).createGame2D(o)))(opts);
+			const next = await (_gameFactory ?? (mode === "3d" ? async (o) => (await import("./create-game-CCFUOWfb.js").then((n) => n.n)).createGame3D(o) : async (o) => (await import("./create-game-DFRbG0Bj.js").then((n) => n.n)).createGame2D(o)))(opts);
 			if (disposed) {
 				next.dispose();
 				return;

package/dist/{src-CwYxzZKl.js → src-CV_uN7j4.js}

@@ -161,6 +161,6 @@ function newUid() {
 //#endregion
 //#region src/index.ts
 /** Engine version. Kept in sync with package.json by the release pipeline. */
-const VERSION = "0.43.0";
+const VERSION = "0.45.0";
 //#endregion
 export { findPath as a, preloadUrls as i, newUid as n, gridFromRows as o, assetUrls as r, VERSION as t };

package/dist/{test-BMgiiD5i.js → test-R8JCuDlv.js}

@@ -6,7 +6,7 @@ import { n as jsonEquals, t as jsonClone } from "./json-BLk7H2Qa.js";
 import { i as getNodeSchema, s as mergeStaticProps } from "./registry-IyWCGe4q.js";
 import { n as registerGameplayBehaviors } from "./gameplay-BQOeAid6.js";
 import { t as registerNodes2D } from "./register-R2JTnIMw.js";
-import { n as registerNodes3D, t as resolveEnvironmentHdri } from "./environment-presets-Ds5kXLoF.js";
+import { n as registerNodes3D, t as resolveEnvironmentHdri } from "./environment-presets-2GgTlPt1.js";
 import { t as registerNodesNet } from "./register-D651it1J.js";
 import { Box3, Euler, Matrix4, PerspectiveCamera, Quaternion, Vector3 } from "three";
 //#region src/test/framing.ts
@@ -1370,7 +1370,7 @@ async function runScript(json, opts) {
 		const { enablePhysics2D } = await import("./physics-2d-BmgXBNDB.js").then((n) => n.r);
 		await enablePhysics2D(engine);
 	} else if (physics === "3d" || physics === "auto" && scene.dimension === "3d") {
-		const { enablePhysics3D } = await import("./physics-3d-CLPFv99o.js").then((n) => n.r);
+		const { enablePhysics3D } = await import("./physics-3d-nLI_8bUR.js").then((n) => n.r);
 		await enablePhysics3D(engine);
 	}
 	const failures = [];
@@ -1486,7 +1486,7 @@ async function createPlaySession(json, opts = {}) {
 		const { enablePhysics2D } = await import("./physics-2d-BmgXBNDB.js").then((n) => n.r);
 		await enablePhysics2D(engine);
 	} else if (physics === "3d" || physics === "auto" && scene.dimension === "3d") {
-		const { enablePhysics3D } = await import("./physics-3d-CLPFv99o.js").then((n) => n.r);
+		const { enablePhysics3D } = await import("./physics-3d-nLI_8bUR.js").then((n) => n.r);
 		await enablePhysics3D(engine);
 	}
 	const stepMs = 1e3 / (opts.fixedHz ?? 60);

package/dist/test.js

@@ -1,3 +1,3 @@
 import { r as auditScene } from "./replay-DilbZgQI.js";
-import { _ as framingText, a as registerAllNodes, c as feelReport, d as facingText, f as failingReplays, g as describeFraming, h as playtestText, i as findFloatingProps, l as feelText, m as playtest, n as createPlaySession, o as runScript, p as findPlayer, r as describeCapture, s as validateScene, t as captureScene, u as facingReport } from "./test-BMgiiD5i.js";
+import { _ as framingText, a as registerAllNodes, c as feelReport, d as facingText, f as failingReplays, g as describeFraming, h as playtestText, i as findFloatingProps, l as feelText, m as playtest, n as createPlaySession, o as runScript, p as findPlayer, r as describeCapture, s as validateScene, t as captureScene, u as facingReport } from "./test-R8JCuDlv.js";
 export { auditScene, captureScene, createPlaySession, describeCapture, describeFraming, facingReport, facingText, failingReplays, feelReport, feelText, findFloatingProps, findPlayer, framingText, playtest, playtestText, registerAllNodes, runScript, validateScene };

package/dist/vite.d.ts

@@ -1,3 +1,5 @@
+import { n as FrameSignature } from "./frame-report-Ct8XgsmV.js";
+
 //#region src/vite/discover.d.ts
 /**
 * The listening TCP ports in `/proc/net/tcp` (and `tcp6`) format.
@@ -25,7 +27,7 @@ interface FrameHost {
     root?: string;
   };
   middlewares: {
-    use(path: string, handler: (req: unknown, res: FrameRes) => void): void;
+    use(path: string, handler: (req: FrameReq, res: FrameRes) => void): void;
   };
   /** Vite's HMR channel. `ws` on v5, `hot` on v6+ — both are accepted. */
   ws?: FrameChannel;
@@ -44,10 +46,22 @@ interface FrameRes {
   setHeader(name: string, value: string): void;
   end(body?: string): void;
 }
+/** Connect strips the mount path off `url`; `originalUrl` keeps the query. */
+interface FrameReq {
+  url?: string;
+  originalUrl?: string;
+}
 interface FrameEndpointOptions {
   /** Overridden in tests; defaults to the real clock. */
   now?: () => number;
   timeoutMs?: number;
+  /**
+  * Remembered frames, by label. Lives in the dev server's MEMORY on purpose:
+  * a baseline is only valid for the browser and the window that made it, so it
+  * should die with the server rather than linger in the project as a file
+  * nobody asked for.
+  */
+  store?: Map<string, FrameSignature>;
 }
 /**
 * Wire `/__incanto/ping` and `/__incanto/frame` onto a dev server.