incanto 0.44.0 → 0.45.1

package/dist/3d.d.ts

@@ -1796,6 +1796,8 @@ declare class ModelInstance3D extends Node3D {
   private entry;
   private mountedRef;
   private fittedHeight;
+  /** A skinned model waiting for a posed skeleton it can be measured against. */
+  private fitPending;
   private fitGroup;
   /**
   * @internal The mounted model, or null while the asset is still loading.
@@ -1855,6 +1857,16 @@ declare class ModelInstance3D extends Node3D {
   availableAnimations(): string[];
   /** Called by the 3D sync pass with the renderer's asset store. */
   _syncModel(assets: AssetStore3D): void;
+  /**
+  * 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.
+  */
+  private applyFit;
   /** 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. */

package/dist/3d.js

@@ -1,9 +1,9 @@
 import { A as Water3D, F as PhysicsBody3D, I as RigidBody3D, L as StaticBody3D, M as WaterCutout3D, N as Area3D, P as CharacterBody3D, R as Node3D, V as WATER_MAX_RIPPLES, j as WATER_CUTOUT_MAX } from "./gameplay-BQOeAid6.js";
-import { A as Terrain3D, B as keyboardIntensity, C as resolveFlowerDensity, D as BoneLookAt3D, E as Camera3D, F as InstancedMesh3D, G as acquireTexture, H as rigPose, I as MeshInstance3D, M as TERRAIN_THEMES, N as terrainThemeLayers, O as BoneAttachment3D, P as Joint3D, R as QUARTER_PITCH, S as Flowers3D, T as CharacterController3D, U as TextureCache3D, V as movementState, W as acquireOwnTexture, _ as LoftMesh3D, a as Tree3D, b as Foliage3D, c as buildRiverRings, d as riverCarveChannels, f as riverStepFor, g as ModelInstance3D, h as Particles3D, i as VoxelGrid3D, j as DEFAULT_TERRAIN_TEXTURE_BASE, k as Billboard3D, l as findRiverCoverageGaps, m as traceDownhillPath, n as registerNodes3D, o as Trail3D, p as smoothCourse, r as VOXEL_PALETTE, s as River3D, u as projectToRiver, v as DirectionalLight3D, w as FLOWER_VARIETIES, x as DENSITY_PRESETS, y as OmniLight3D, z as cameraRelative } from "./environment-presets-Ds5kXLoF.js";
-import { a as Environment3D, c as parseEnvironment3D, d as AssetStore3D, i as syncTree, l as sunDirectionFromElevationAzimuth, o as setEnvironment3D, r as Renderer3D, s as horizonColorFromSky, t as createGame3D, u as sunDirectionFromSky } from "./create-game-D90pyPMx.js";
+import { A as Terrain3D, B as keyboardIntensity, C as resolveFlowerDensity, D as BoneLookAt3D, E as Camera3D, F as InstancedMesh3D, G as acquireTexture, H as rigPose, I as MeshInstance3D, M as TERRAIN_THEMES, N as terrainThemeLayers, O as BoneAttachment3D, P as Joint3D, R as QUARTER_PITCH, S as Flowers3D, T as CharacterController3D, U as TextureCache3D, V as movementState, W as acquireOwnTexture, _ as LoftMesh3D, a as Tree3D, b as Foliage3D, c as buildRiverRings, d as riverCarveChannels, f as riverStepFor, g as ModelInstance3D, h as Particles3D, i as VoxelGrid3D, j as DEFAULT_TERRAIN_TEXTURE_BASE, k as Billboard3D, l as findRiverCoverageGaps, m as traceDownhillPath, n as registerNodes3D, o as Trail3D, p as smoothCourse, r as VOXEL_PALETTE, s as River3D, u as projectToRiver, v as DirectionalLight3D, w as FLOWER_VARIETIES, x as DENSITY_PRESETS, y as OmniLight3D, z as cameraRelative } from "./environment-presets-DUsBqvtk.js";
+import { a as Environment3D, c as parseEnvironment3D, d as AssetStore3D, i as syncTree, l as sunDirectionFromElevationAzimuth, o as setEnvironment3D, r as Renderer3D, s as horizonColorFromSky, t as createGame3D, u as sunDirectionFromSky } from "./create-game-Gifrjhnz.js";
 import { a as frameStats, i as frameSignature, n as diffSignatures, o as frameText, r as diffText, t as SIGNATURE_GRID } from "./frame-report-Lr3VO24R.js";
 import { n as splatWeights, t as buildHeightmap } from "./heightmap-CRK0M4jT.js";
-import { n as enablePhysics3D, t as Physics3D } from "./physics-3d-CLPFv99o.js";
+import { n as enablePhysics3D, t as Physics3D } from "./physics-3d-DFqMtBUD.js";
 //#region src/3d/terrain-nav.ts
 function buildTerrainNav(terrain, opts) {
 	const cellSize = opts?.cellSize ?? 2;

package/dist/{create-game-D90pyPMx.js → create-game-Gifrjhnz.js}

@@ -6,9 +6,9 @@ import { i as resolveRendering, n as attachTouchControls } from "./touch-BoNg_Mn
 import { a as openBundledEditor, i as devServerLibrary, n as pauseWhenHidden, o as poseFromRenderer, r as crossFade, t as teardown } from "./teardown-yePMOE1K.js";
 import { B as createCausticsQuad, F as PhysicsBody3D, R as Node3D, n as registerGameplayBehaviors } from "./gameplay-BQOeAid6.js";
 import { t as debugSources } from "./debug-draw-BM3DsvtT.js";
-import { E as Camera3D, U as TextureCache3D, g as ModelInstance3D, n as registerNodes3D, t as resolveEnvironmentHdri, v as DirectionalLight3D } from "./environment-presets-Ds5kXLoF.js";
+import { E as Camera3D, U as TextureCache3D, g as ModelInstance3D, n as registerNodes3D, t as resolveEnvironmentHdri, v as DirectionalLight3D } from "./environment-presets-DUsBqvtk.js";
 import { a as frameStats, i as frameSignature } from "./frame-report-Lr3VO24R.js";
-import { n as enablePhysics3D } from "./physics-3d-CLPFv99o.js";
+import { n as enablePhysics3D } from "./physics-3d-DFqMtBUD.js";
 import { ACESFilmicToneMapping, AmbientLight, Box3, BufferAttribute, BufferGeometry, Color, DepthTexture, EquirectangularReflectionMapping, FloatType, Fog, HalfFloatType, LineBasicMaterial, LineSegments, Matrix4, Mesh, PCFShadowMap, PMREMGenerator, PerspectiveCamera, PlaneGeometry, Quaternion, Raycaster, Scene, ShaderMaterial, Vector2, Vector3, WebGLRenderTarget, WebGLRenderer } from "three";
 import { VRMLoaderPlugin, VRMUtils } from "@pixiv/three-vrm";
 import { GLTFLoader } from "three/addons/loaders/GLTFLoader.js";

package/dist/debug.d.ts

@@ -71,6 +71,9 @@ declare class DebugOverlay {
   private readonly cleanups;
   private readonly menuButton;
   private dropdown;
+  private dismissDropdown;
+  /** Where the ☰ button sits, in container CSS px. Drag moves it; see bindMenuDrag. */
+  private menuPos;
   private selected;
   /** Explorer subtrees the user collapsed (nodes keep identity across frames). */
   private readonly collapsedFlags;
@@ -121,6 +124,18 @@ declare class DebugOverlay {
   dispose(): void;
   /** `✓ Colliders · selected` — check for on, suffix for the collider mode. */
   private menuLabel;
+  /**
+  * The ☰ button is draggable, because top-left is exactly where a game puts
+  * its own menu and a debug chip pinned on top of it is a debug chip you
+  * cannot use.
+  *
+  * Drag and click share one pointer, so they are told apart by distance: under
+  * the threshold the press was a click and the menu opens, over it the press
+  * was a grab and the menu must NOT open under the finger that just let go.
+  */
+  private bindMenuDrag;
+  private moveMenuButton;
+  private closeDropdown;
   private toggleDropdown;
   private openStatsChip;
   private renderStats;

package/dist/debug.js

@@ -193,6 +193,59 @@ function clampPanelRect(x, y, w, h, viewW, viewH, minW = 180, minH = 120) {
 		h: ch
 	};
 }
+/**
+* Where a dropdown goes relative to the thing that opened it.
+*
+* Left-aligned under the anchor, flipped above it when there is no room below,
+* and never off the side — a menu that opens past the edge of the window is a
+* menu with items nobody can reach. The anchor moves (the ☰ button is
+* draggable), so this cannot be the constant it used to be.
+*/
+function anchorDropdown(anchor, menuW, menuH, viewW, viewH, gap = 4) {
+	const x = Math.min(Math.max(0, anchor.x), Math.max(0, viewW - menuW));
+	const below = anchor.y + anchor.h + gap;
+	const above = anchor.y - menuH - gap;
+	if (below + menuH <= viewH) return {
+		x,
+		y: below
+	};
+	if (above >= 0) return {
+		x,
+		y: above
+	};
+	return {
+		x,
+		y: Math.min(Math.max(0, below), Math.max(0, viewH - menuH))
+	};
+}
+/**
+* Make a transient thing dismissible: Esc, or a press anywhere outside it.
+*
+* Returns the disposer. Attaching this is how "you can always get out of it"
+* stops being something each caller has to remember — the overlay had a
+* dismissible capture layer and a dropdown you could only close by choosing
+* something from it.
+*/
+function dismissOn(doc, inside, close) {
+	const onKey = (event) => {
+		if (event.key === "Escape") close();
+	};
+	const onDown = (event) => {
+		const target = event.target;
+		if (!target) return;
+		for (const el of inside) {
+			if (!el) continue;
+			if (el === target || el.contains?.(target)) return;
+		}
+		close();
+	};
+	doc.addEventListener?.("keydown", onKey);
+	doc.addEventListener?.("pointerdown", onDown);
+	return () => {
+		doc.removeEventListener?.("keydown", onKey);
+		doc.removeEventListener?.("pointerdown", onDown);
+	};
+}
 function applyStyle(el, rules) {
 	for (const [key, value] of Object.entries(rules)) el.style[key] = value;
 }
@@ -658,6 +711,8 @@ function isPlainObject(value) {
 /** The slider's ceiling. Beyond this the number box is the tool — a 0..8 slider
 *  makes the 0.1-to-1 range, where slow-motion debugging actually lives, unusable. */
 const TIME_SLIDER_MAX = 2;
+/** Under this much movement the press was a click, not a grab. */
+const MENU_DRAG_THRESHOLD = 4;
 /** Attach the overlay; null when no DOM is available (headless). */
 function attachDebugOverlay(engine, opts = {}) {
 	const doc = opts.doc ?? (typeof document !== "undefined" ? document : null);
@@ -685,6 +740,12 @@ var DebugOverlay = class {
 	cleanups = [];
 	menuButton;
 	dropdown = null;
+	dismissDropdown = null;
+	/** Where the ☰ button sits, in container CSS px. Drag moves it; see bindMenuDrag. */
+	menuPos = {
+		x: 8,
+		y: 8
+	};
 	selected = null;
 	/** Explorer subtrees the user collapsed (nodes keep identity across frames). */
 	collapsedFlags = /* @__PURE__ */ new Map();
@@ -737,7 +798,7 @@ var DebugOverlay = class {
 			zIndex: "50",
 			pointerEvents: "auto"
 		});
-		this.menuButton.addEventListener("click", () => this.toggleDropdown());
+		this.bindMenuDrag();
 		if (!container.style.position) container.style.position = "relative";
 		container.appendChild(this.menuButton);
 		this.cleanups.push(engine.log.added.connect((entry) => {
@@ -921,8 +982,7 @@ var DebugOverlay = class {
 		for (const cleanup of this.cleanups) cleanup();
 		for (const id of [...this.panels.keys()]) this.close(id);
 		this.close("stats");
-		this.dropdown?.remove();
-		this.dropdown = null;
+		this.closeDropdown();
 		this.menuButton.remove();
 	}
 	/** `✓ Colliders · selected` — check for on, suffix for the collider mode. */
@@ -930,17 +990,79 @@ var DebugOverlay = class {
 		const suffix = id === "colliders" && this.colliderMode !== "off" ? ` · ${this.colliderMode}` : "";
 		return `${this.isOpen(id) ? "✓ " : ""}${label}${suffix}`;
 	}
+	/**
+	* The ☰ button is draggable, because top-left is exactly where a game puts
+	* its own menu and a debug chip pinned on top of it is a debug chip you
+	* cannot use.
+	*
+	* Drag and click share one pointer, so they are told apart by distance: under
+	* the threshold the press was a click and the menu opens, over it the press
+	* was a grab and the menu must NOT open under the finger that just let go.
+	*/
+	bindMenuDrag() {
+		let start = null;
+		let dragged = false;
+		this.menuButton.addEventListener("pointerdown", (event) => {
+			const e = event;
+			start = {
+				x: e.clientX ?? 0,
+				y: e.clientY ?? 0,
+				bx: this.menuPos.x,
+				by: this.menuPos.y
+			};
+			dragged = false;
+			if (e.pointerId !== void 0) this.menuButton.setPointerCapture?.(e.pointerId);
+		});
+		this.menuButton.addEventListener("pointermove", (event) => {
+			if (!start) return;
+			const e = event;
+			const dx = (e.clientX ?? 0) - start.x;
+			const dy = (e.clientY ?? 0) - start.y;
+			if (!dragged && Math.hypot(dx, dy) < MENU_DRAG_THRESHOLD) return;
+			if (!dragged) {
+				dragged = true;
+				this.closeDropdown();
+				applyStyle(this.menuButton, { cursor: "grabbing" });
+			}
+			this.moveMenuButton(start.bx + dx, start.by + dy);
+		});
+		const release = () => {
+			if (!start) return;
+			const wasDrag = dragged;
+			start = null;
+			dragged = false;
+			applyStyle(this.menuButton, { cursor: "pointer" });
+			if (!wasDrag) this.toggleDropdown();
+		};
+		this.menuButton.addEventListener("pointerup", release);
+		this.menuButton.addEventListener("pointercancel", release);
+	}
+	moveMenuButton(x, y) {
+		const el = this.menuButton;
+		const box = clampPanelRect(x, y, el.offsetWidth ?? 0, el.offsetHeight ?? 0, this.container.clientWidth || 0, this.container.clientHeight || 0, 0, 0);
+		this.menuPos = {
+			x: box.x,
+			y: box.y
+		};
+		applyStyle(this.menuButton, {
+			left: `${box.x}px`,
+			top: `${box.y}px`
+		});
+	}
+	closeDropdown() {
+		this.dismissDropdown?.();
+		this.dismissDropdown = null;
+		this.dropdown?.remove();
+		this.dropdown = null;
+	}
 	toggleDropdown() {
 		if (this.dropdown) {
-			this.dropdown.remove();
-			this.dropdown = null;
+			this.closeDropdown();
 			return;
 		}
 		const menu = this.doc.createElement("div");
 		applyStyle(menu, {
 			position: "absolute",
-			top: "34px",
-			left: "8px",
 			background: "rgba(18,20,26,0.95)",
 			border: "1px solid rgba(255,255,255,0.18)",
 			borderRadius: "6px",
@@ -973,8 +1095,7 @@ var DebugOverlay = class {
 					item.textContent = this.menuLabel(id, label);
 					return;
 				}
-				this.dropdown?.remove();
-				this.dropdown = null;
+				this.closeDropdown();
 			});
 			menu.appendChild(item);
 		}
@@ -989,14 +1110,26 @@ var DebugOverlay = class {
 				color: "rgba(158,232,220,0.95)"
 			});
 			item.addEventListener("click", () => {
-				this.dropdown?.remove();
-				this.dropdown = null;
+				this.closeDropdown();
 				action.run();
 			});
 			menu.appendChild(item);
 		}
 		this.container.appendChild(menu);
 		this.dropdown = menu;
+		const el = menu;
+		const btn = this.menuButton;
+		const at = anchorDropdown({
+			x: this.menuPos.x,
+			y: this.menuPos.y,
+			w: btn.offsetWidth ?? 0,
+			h: btn.offsetHeight ?? 26
+		}, el.offsetWidth ?? 0, el.offsetHeight ?? 0, this.container.clientWidth || 0, this.container.clientHeight || 0);
+		applyStyle(menu, {
+			left: `${at.x}px`,
+			top: `${at.y}px`
+		});
+		this.dismissDropdown = dismissOn(this.doc, [menu, this.menuButton], () => this.closeDropdown());
 	}
 	openStatsChip() {
 		if (this.statsChip) return;

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

@@ -2797,8 +2797,12 @@ var CharacterController3D = class extends Node3D {
 		if (!input) return;
 		if (this.mouseLook) {
 			const d = input.pointerDelta();
-			this.yaw -= d.x * LOOK_SPEED;
-			this.pitch = clamp(this.pitch + d.y * LOOK_SPEED, -this.pitchMax, -this.pitchMin);
+			const settings = this.tree?.engine?.settings;
+			const sensitivity = settings?.get("sensitivity") ?? 1;
+			const invertY = settings?.get("invertY") ?? false;
+			const speed = LOOK_SPEED * (typeof sensitivity === "number" && sensitivity > 0 ? sensitivity : 1);
+			this.yaw -= d.x * speed;
+			this.pitch = clamp(this.pitch + (invertY === true ? -d.y : d.y) * speed, -this.pitchMax, -this.pitchMin);
 			const wheel = input.wheelDelta();
 			if (wheel !== 0 && this.zoomMax > this.zoomMin) this.camDistance = clamp(this.camDistance + wheel * LOOK_SPEED, this.zoomMin, this.zoomMax);
 		}
@@ -5958,6 +5962,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 +6284,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 +6436,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 +6458,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 +6544,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 +6658,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 +6683,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/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-B3n06SsL.js";
+import { a as findPath, i as preloadUrls, n as newUid, o as gridFromRows, r as assetUrls, t as VERSION } from "./src-DUxGnvq3.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-DFqMtBUD.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-DUsBqvtk.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-D90pyPMx.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-Gifrjhnz.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-B3n06SsL.js → src-DUxGnvq3.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.44.0";
+const VERSION = "0.45.1";
 //#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-DD5scWfm.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-DUsBqvtk.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-DFqMtBUD.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-DFqMtBUD.js").then((n) => n.r);
 		await enablePhysics3D(engine);
 	}
 	const stepMs = 1e3 / (opts.fixedHz ?? 60);