incanto 0.53.0 → 0.55.0

package/dist/{create-game-CDJ1lVqK.js → create-game-CzK9_pzg.js}

@@ -1,15 +1,15 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
 import { A as registerBehavior, C as diagnose, n as loadScene } from "./loader-BTkHYrQn.js";
-import { C as qualityCaps, T as qualityRendering, b as AudioPlayer, x as Engine } from "./register-BTomIiYG.js";
+import { C as qualityCaps, T as qualityRendering, b as AudioPlayer, x as Engine } from "./register-p48lHE2o.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { r as parseDrive, t as logReport } from "./log-report-CPFm4OXf.js";
 import { i as resolveRendering, n as attachTouchControls } from "./touch-BnMyy9tr.js";
-import { a as openBundledEditor, c as audioErrors, i as devServerLibrary, n as pauseWhenHidden, o as poseFromRenderer, r as crossFade, s as claimCanvasGestures, t as teardown } from "./teardown-Bw2aeyGI.js";
-import { I as PhysicsBody3D, V as createCausticsQuad, n as registerGameplayBehaviors, z as Node3D } from "./gameplay-CRYw_Q-T.js";
+import { a as openBundledEditor, c as audioErrors, i as devServerLibrary, n as pauseWhenHidden, o as poseFromRenderer, r as crossFade, s as claimCanvasGestures, t as teardown } from "./teardown-C7uVSJvx.js";
+import { I as PhysicsBody3D, V as createCausticsQuad, n as registerGameplayBehaviors, z as Node3D } from "./gameplay-CZ2yq37J.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-SkGanr2s.js";
+import { E as Camera3D, U as TextureCache3D, g as ModelInstance3D, n as registerNodes3D, t as resolveEnvironmentHdri, v as DirectionalLight3D } from "./environment-presets-DAbEdEwh.js";
 import { a as frameSignature, i as frameImage, o as frameStats } from "./frame-report-njybhZon.js";
-import { n as enablePhysics3D } from "./physics-3d-DmyO2oaN.js";
+import { n as enablePhysics3D } from "./physics-3d-C_ZJ6f_d.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";
@@ -1670,7 +1670,11 @@ var Renderer3D = class {
 		this.selectionLines.renderOrder = 1e4;
 		this.selectionLines.visible = false;
 		this.threeScene.add(this.selectionLines);
-		this.disconnect = this.engine.updated.connect(() => this.render());
+		this.disconnect = this.engine.updated.connect(() => {
+			const started = performance.now();
+			this.render();
+			this.engine.noteRenderMs(performance.now() - started);
+		});
 	}
 	/** The pixel ratio the scene ASKED for — the governor scales this, never replaces it. */
 	basePixelRatio;

package/dist/debug.d.ts

@@ -1,4 +1,4 @@
-import { T as RendererStats, b as Engine, jt as LogLevel } from "./behavior-Do0Da56m.js";
+import { Pt as LogLevel, T as RendererStats, b as Engine } from "./behavior-CyQoSu4n.js";
 
 //#region src/debug/panel.d.ts
 /** Minimal document surface the overlay needs (injectable for tests). */

package/dist/debug.js

@@ -1164,7 +1164,9 @@ var DebugOverlay = class {
 			...gpu.triangles !== void 0 ? [`tris ${compactCount(gpu.triangles)}`] : [],
 			...gpu.drawCalls !== void 0 ? [`calls ${gpu.drawCalls}`] : []
 		].join(" · ");
-		chip.textContent = `${Math.round(stats.fps)} fps · ${stats.frameMs.toFixed(1)} ms\n${line2}`;
+		const p = stats.phases;
+		const line3 = `\nphys ${p.fixedMs.toFixed(1)} · logic ${p.updateMs.toFixed(1)} · draw ${p.renderMs.toFixed(1)} · other ${p.otherMs.toFixed(1)}`;
+		chip.textContent = `${Math.round(stats.fps)} fps · ${stats.frameMs.toFixed(1)} ms\n${line2}${line3}`;
 	}
 	renderExplorer() {
 		const panel = this.panels.get("explorer");
@@ -1600,7 +1602,7 @@ var DebugOverlay = class {
 	*/
 	nextFrame() {
 		if (!this.paused) this.setPaused(true);
-		this.engine.step();
+		this.engine.step({ ignorePause: true });
 		this.syncTime();
 	}
 	/** Push the engine's current time state into the panel, without rebuilding it. */

package/dist/editor.js

@@ -1181,6 +1181,13 @@ var kt = {
 				en: "Options are the locales the scene declares in \"strings\", each labeled with its own endonym. Picking one switches the game live and persists it. English is the base: any key a locale omits falls back to it, on purpose.",
 				ko: "옵션은 씬의 \"strings\"가 선언한 로케일이며, 각 언어의 자기 이름으로 표시됩니다. 선택하면 즉시 바뀌고 저장됩니다. 영어가 기준이라 로케일이 빠뜨린 키는 의도적으로 영어로 표시됩니다."
 			}),
+			L("Label3D", {
+				en: "Text standing in the world — a nameplate, a sign, a damage number.",
+				ko: "월드에 서 있는 텍스트 — 이름표, 표지판, 데미지 숫자."
+			}, {
+				en: "height is the cap height in METRES and the quad follows what the text measures, so a sign is as wide as its words. Faces the camera by default (a damage number read from behind is a bug) and carries a dark outline so it stays readable over anything. Everything else a sprite knows — anchor, tint, opacity, renderOrder — it inherits. For a damage number: set text, then float it up and fade opacity to 0 and queueFree().",
+				ko: "height는 글자 높이(미터)이고 가로 폭은 텍스트 실측을 따라갑니다. 기본으로 카메라를 향하며(뒤에서 읽히는 데미지 숫자는 버그니까요) 어두운 외곽선이 있어 어떤 배경에서도 읽힙니다. 앵커·틴트·투명도·renderOrder 등 스프라이트의 나머지 기능은 그대로 상속합니다. 데미지 숫자는 text를 넣고 위로 띄우며 opacity를 0으로 보낸 뒤 queueFree() 하면 됩니다."
+			}),
 			L("UiVolumeSlider", {
 				en: "A volume slider, already wired to a bus.",
 				ko: "볼륨 슬라이더 — 버스에 이미 연결되어 있습니다."

package/dist/{environment-presets-SkGanr2s.js → environment-presets-DAbEdEwh.js}

@@ -1,10 +1,10 @@
-import { t as registerCoreNodes } from "./register-BTomIiYG.js";
+import { t as registerCoreNodes } from "./register-p48lHE2o.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { t as Rng } from "./rng-DP-SR7eg.js";
 import { i as getNodeSchema, l as registerNode } from "./registry-C7u42TID.js";
 import { t as createNoise2D } from "./noise-CGUMx44x.js";
-import { i as ParticleSim, n as resolveFrames, o as PARTICLE_PRESET_NAMES, r as validateAnimationAliases, s as applyParticlePreset, t as resolveAnimation } from "./sprite-animation-D_p28jwU.js";
-import { F as CharacterBody3D, I as PhysicsBody3D, L as RigidBody3D, N as WaterCutout3D, P as Area3D, R as StaticBody3D, U as colliderFootDrop, j as Water3D, z as Node3D } from "./gameplay-CRYw_Q-T.js";
+import { i as ParticleSim, n as resolveFrames, o as PARTICLE_PRESET_NAMES, r as validateAnimationAliases, s as applyParticlePreset, t as resolveAnimation } from "./sprite-animation-7qvUxF6Z.js";
+import { F as CharacterBody3D, I as PhysicsBody3D, L as RigidBody3D, N as WaterCutout3D, P as Area3D, R as StaticBody3D, U as colliderFootDrop, j as Water3D, z as Node3D } from "./gameplay-CZ2yq37J.js";
 import { n as splatWeights, t as buildHeightmap } from "./heightmap-CRK0M4jT.js";
 import { AdditiveBlending, AnimationClip, AnimationMixer, Box3, BoxGeometry, BufferAttribute, BufferGeometry, CanvasTexture, CapsuleGeometry, ClampToEdgeWrapping, Color, ConeGeometry, CylinderGeometry, DataTexture, DirectionalLight, DoubleSide, DynamicDrawUsage, Euler, Group, IcosahedronGeometry, ImageBitmapLoader, InstancedBufferAttribute, InstancedMesh, LinearFilter, LinearMipmapLinearFilter, LoopOnce, LoopRepeat, Matrix4, Mesh, MeshBasicMaterial, MeshDepthMaterial, MeshPhysicalMaterial, MeshStandardMaterial, NearestFilter, NoBlending, NoColorSpace, NormalBlending, PerspectiveCamera, PlaneGeometry, PointLight, Points, PointsMaterial, Quaternion, QuaternionKeyframeTrack, RGBADepthPacking, RGBAFormat, RepeatWrapping, SRGBColorSpace, ShaderChunk, ShaderMaterial, SphereGeometry, Texture, TextureLoader, UniformsLib, UniformsUtils, Vector3, Vector4, VectorKeyframeTrack } from "three";
 import { clone } from "three/addons/utils/SkeletonUtils.js";
@@ -104,6 +104,25 @@ var TextureCache3D = class {
 		return master ? master.clone() : null;
 	}
 	/**
+	* File a failure this store did not load itself.
+	*
+	* `Tree3D` keeps its own cache on purpose (it decodes off-thread and its
+	* page-session lifetime is load-bearing for the editor), which left its bark
+	* and leaf textures outside the one place `assetErrors()` reads. A 404'd leaf
+	* texture is a forest of bare branches and no message anywhere.
+	*/
+	noteError(url, error) {
+		const key = `external|${url}`;
+		if (this.entries.has(key)) return;
+		const message = error instanceof Error ? error.message : String(error);
+		this.entries.set(key, {
+			url,
+			texture: null,
+			error: message
+		});
+		this.diagnostics?.warn(`texture failed to load: ${url} — ${message}`);
+	}
+	/**
 	* What 404'd, by URL — reported raw, never by cache key, because an agent
 	* greps this against the URL it wrote.
 	*/
@@ -5666,6 +5685,109 @@ const colorScratchB$1 = new Color();
 const colorScratchC$1 = new Color();
 const tuftDryScratch = new Color();
 //#endregion
+//#region src/3d/nodes/label-3d.ts
+/**
+* Text standing in the world — a damage number, a nameplate, a sign.
+*
+* Every action game has these, and the answer used to be a sentence in the 3D
+* skill: *"There is no 3D text node — a nameplate or damage number is a
+* canvas-rendered texture on a child Sprite3D."* True, and a real afternoon of
+* work per game: measure the text, size the canvas, keep the device pixel ratio
+* honest, build the texture, work out the quad's aspect, re-rasterise when the
+* number changes, and dispose the old texture so a damage number does not leak
+* one per hit.
+*
+* It IS a canvas-rendered texture on a Sprite3D — which is exactly why it
+* should be a node. Everything a sprite already knows (billboarding, anchor,
+* tint, opacity, depth, render order) it inherits, so this only adds the text.
+*
+* ```json
+* { "name": "Name", "type": "Label3D",
+*   "props": { "text": "Goblin", "height": 0.25, "position": [0, 2, 0] } }
+* ```
+*
+* A damage number is this plus two lines of behavior: set `text`, then move it
+* up and fade `opacity` to 0 over ~0.6 s and `queueFree()`.
+*/
+var Label3D = class extends Sprite3D {
+	static typeName = "Label3D";
+	static props = {
+		...Sprite3D.props,
+		text: { default: "" },
+		/** Cap height of the text in METRES — the one number a sign is sized by. */
+		height: { default: .3 },
+		color: { default: "#ffffff" },
+		font: { default: "sans-serif" },
+		/** Outline colour; `""` turns it off. On by default: white text over a
+		*  bright wall is unreadable, and a damage number lands anywhere. */
+		outline: { default: "#000000" },
+		/** A damage number read from behind is a bug, so these face the camera. */
+		billboard: {
+			default: "full",
+			options: [
+				"y",
+				"full",
+				"none"
+			]
+		}
+	};
+	text = "";
+	height = .3;
+	color = "#ffffff";
+	font = "sans-serif";
+	outline = "#000000";
+	billboard = "full";
+	canvas = null;
+	/** The rasterised text. Named apart from Sprite3D's `texture` URL prop, which
+	*  this node ignores — the text IS the picture. */
+	canvasTexture = null;
+	lastKey = "";
+	resolveTexture(_assets) {
+		if (this.text === "" || typeof document === "undefined") return null;
+		const key = `${this.text}\0${this.height}\0${this.color}\0${this.font}\0${this.outline}`;
+		if (key !== this.lastKey) {
+			this.lastKey = key;
+			this.rasterize();
+		}
+		return this.canvasTexture;
+	}
+	/** Draw the text once, and size the quad to what it measured. */
+	rasterize() {
+		const fontPx = Math.max(8, Math.round(this.height * 256));
+		this.canvas ??= document.createElement("canvas");
+		const ctx = this.canvas.getContext("2d");
+		if (!ctx) return;
+		const stroke = Math.max(1, Math.round(fontPx * .14));
+		const fontSpec = `bold ${fontPx}px ${this.font}`;
+		ctx.font = fontSpec;
+		const width = Math.max(1, Math.ceil(ctx.measureText(this.text).width) + stroke * 2);
+		const lineHeight = Math.ceil(fontPx * 1.35) + stroke * 2;
+		this.canvas.width = width;
+		this.canvas.height = lineHeight;
+		ctx.font = fontSpec;
+		ctx.textBaseline = "middle";
+		ctx.textAlign = "center";
+		if (this.outline !== "") {
+			ctx.lineWidth = stroke;
+			ctx.lineJoin = "round";
+			ctx.strokeStyle = this.outline;
+			ctx.strokeText(this.text, width / 2, lineHeight / 2);
+		}
+		ctx.fillStyle = this.color;
+		ctx.fillText(this.text, width / 2, lineHeight / 2);
+		this.canvasTexture?.dispose();
+		const texture = new CanvasTexture(this.canvas);
+		texture.colorSpace = SRGBColorSpace;
+		this.canvasTexture = texture;
+		this.size = [width / lineHeight * this.height * 1.35, this.height * 1.35];
+	}
+	free() {
+		this.canvasTexture?.dispose();
+		this.canvasTexture = null;
+		super.free();
+	}
+};
+//#endregion
 //#region src/3d/nodes/lights-3d.ts
 /** Sun-style light. Direction comes from the node's rotation. */
 var DirectionalLight3D = class extends Node3D {
@@ -5806,6 +5928,25 @@ var LoftMesh3D = class extends Node3D {
 		m.castShadow = this.castShadow;
 		m.receiveShadow = this.receiveShadow;
 	}
+	/**
+	* Hand the GPU back.
+	*
+	* Every other node that builds geometry disposes it here; these four did not,
+	* so a scene swap left their buffers and materials resident and a game with
+	* level transitions climbed until the tab died — with `stats().geometries` the
+	* only witness, and only if someone was watching it.
+	*/
+	free() {
+		const object = this._builtObject3D;
+		if (object) object.traverse((child) => {
+			const mesh = child;
+			mesh.geometry?.dispose();
+			const material = mesh.material;
+			const list = Array.isArray(material) ? material : material ? [material] : [];
+			for (const m of list) m.dispose?.();
+		});
+		super.free();
+	}
 };
 function validateSections(sections, name) {
 	const fail = (message) => {
@@ -6764,6 +6905,8 @@ var Particles3D = class Particles3D extends Node3D {
 			options: ["custom", ...PARTICLE_PRESET_NAMES]
 		},
 		emitting: { default: true },
+		/** Particles keep the place they were born instead of following the node. */
+		worldSpace: { default: false },
 		rate: { default: 40 },
 		burst: { default: 0 },
 		lifetime: { default: [.6, 1.2] },
@@ -6789,6 +6932,18 @@ var Particles3D = class Particles3D extends Node3D {
 	};
 	preset = "custom";
 	emitting = true;
+	/**
+	* Where a particle LIVES once it is born.
+	*
+	* `false` (default) — the emitter's local space: the plume moves with the
+	* node, which is what a torch on a moving platform wants.
+	*
+	* `true` — the world: a particle keeps the place it was born, so dust is left
+	* BEHIND a running player instead of glued to it, and moving a one-shot to
+	* the next explosion (the documented `p.position = …; p.replay()` recipe)
+	* stops dragging the previous one across the level.
+	*/
+	worldSpace = false;
 	rate = 40;
 	burst = 0;
 	lifetime = [.6, 1.2];
@@ -6855,12 +7010,38 @@ var Particles3D = class Particles3D extends Node3D {
 		}
 		return this.sim;
 	}
+	/** Particles alive this frame — an emitter that is running, told from one
+	*  that is not. `framing()` says where it IS; this says whether it is going. */
+	get aliveCount() {
+		return this.sim?.count ?? 0;
+	}
+	/** A snapshot of the live particles — positions are in whichever space
+	*  `worldSpace` selects, relative to the emitter. */
+	particles() {
+		const out = [];
+		this.sim?.forEach((p) => {
+			out.push({ ...p });
+		});
+		return out;
+	}
+	/** The emitter's world position last frame, for world-space counter-motion. */
+	lastWorld = null;
+	/** Last frame's `emitting`, so turning one ON is a reportable event. */
+	wasEmitting = false;
 	update(dt) {
 		const sim = this._ensureSim();
+		this.holdWorldSpace(sim);
 		sim.setRate(this.emitting ? this.rate : 0);
-		if (this.burst > 0 && !this.bursted) {
+		if (this.burst > 0 && !this.bursted && (this.emitting || this.armedByReplay)) {
 			this.bursted = true;
+			this.armedByReplay = false;
 			sim.burst(this.burst);
+			this.report("burst", this.burst);
+		}
+		const on = this.emitting && this.rate > 0;
+		if (on !== this.wasEmitting) {
+			this.wasEmitting = on;
+			if (on) this.report("emit", this.rate);
 		}
 		sim.update(dt);
 		if ((!this.emitting || this.rate === 0) && this.bursted && sim.done && !this.finishedEmitted) {
@@ -6868,11 +7049,52 @@ var Particles3D = class Particles3D extends Node3D {
 			this.emit("finished");
 		}
 	}
+	/**
+	* Undo the emitter's own motion on everything already alive.
+	*
+	* Ancestor-summed like the physics helpers, so it follows a moving PARENT
+	* (dust under a player) as well as the node's own position.
+	*/
+	holdWorldSpace(sim) {
+		if (!this.worldSpace) {
+			this.lastWorld = null;
+			return;
+		}
+		let x = 0;
+		let y = 0;
+		let z = 0;
+		for (let n = this; n; n = n.parent) if (n instanceof Node3D) {
+			x += n.position[0] ?? 0;
+			y += n.position[1] ?? 0;
+			z += n.position[2] ?? 0;
+		}
+		const prev = this.lastWorld;
+		if (prev) sim.translateAll(prev[0] - x, prev[1] - y, prev[2] - z);
+		this.lastWorld = [
+			x,
+			y,
+			z
+		];
+	}
+	/** Tell the engine an effect fired — the visual half of the audio record. */
+	report(kind, amount) {
+		const engine = this.tree?.engine;
+		engine?.effects.record({
+			kind,
+			name: this.preset,
+			from: this.getPath(),
+			amount,
+			at: engine.time
+		});
+	}
 	/** Restart a one-shot (re-burst + allow finished to fire again). */
 	replay() {
 		this.bursted = false;
 		this.finishedEmitted = false;
+		this.armedByReplay = true;
 	}
+	/** `replay()` asked for this burst, so `emitting: false` does not hold it. */
+	armedByReplay = false;
 	points = null;
 	positions = null;
 	colors = null;
@@ -6958,6 +7180,25 @@ var Particles3D = class Particles3D extends Node3D {
 		geometry.getAttribute("position").needsUpdate = true;
 		geometry.getAttribute("color").needsUpdate = true;
 	}
+	/**
+	* Hand the GPU back.
+	*
+	* Every other node that builds geometry disposes it here; these four did not,
+	* so a scene swap left their buffers and materials resident and a game with
+	* level transitions climbed until the tab died — with `stats().geometries` the
+	* only witness, and only if someone was watching it.
+	*/
+	free() {
+		const object = this._builtObject3D;
+		if (object) object.traverse((child) => {
+			const mesh = child;
+			mesh.geometry?.dispose();
+			const material = mesh.material;
+			const list = Array.isArray(material) ? material : material ? [material] : [];
+			for (const m of list) m.dispose?.();
+		});
+		super.free();
+	}
 };
 const colorScratchA = new Color();
 const colorScratchB = new Color();
@@ -9008,8 +9249,21 @@ var Trail3D = class extends Node3D {
 		group.add(this.mesh);
 		return group;
 	}
+	/** Last frame's `emitting`, so laying ribbon is a reportable event. */
+	wasEmitting = false;
 	update(dt) {
 		this.clock += dt;
+		if (this.emitting !== this.wasEmitting) {
+			this.wasEmitting = this.emitting;
+			const engine = this.tree?.engine;
+			if (this.emitting && engine) engine.effects.record({
+				kind: "trail",
+				name: this.color,
+				from: this.getPath(),
+				amount: this.seconds,
+				at: engine.time
+			});
+		}
 		while (this.points.length > 0 && this.clock - this.points[0].t > this.seconds) this.points.shift();
 	}
 	_onRender3D(ctx) {
@@ -9066,10 +9320,38 @@ var Trail3D = class extends Node3D {
 		}
 		geometry.setDrawRange(0, (n - 1) * 6);
 	}
-	/** Test hook: recorded point count. */
+	/**
+	* How many points the ribbon is made of.
+	*
+	* ZERO with no renderer, and that is not a bug: the ribbon is laid in the
+	* render sync, because each point needs the node's real world transform (a
+	* sword arc is a ROTATING parent, which an ancestor position sum cannot see).
+	* Assert it from a browser check; read a headless 0 as "nothing rendered"
+	* rather than "my trail is broken", and use the `trail` effect record for the
+	* wiring question.
+	*/
 	get pointCount() {
 		return this.points.length;
 	}
+	/**
+	* Hand the GPU back.
+	*
+	* Every other node that builds geometry disposes it here; these four did not,
+	* so a scene swap left their buffers and materials resident and a game with
+	* level transitions climbed until the tab died — with `stats().geometries` the
+	* only witness, and only if someone was watching it.
+	*/
+	free() {
+		const object = this._builtObject3D;
+		if (object) object.traverse((child) => {
+			const mesh = child;
+			mesh.geometry?.dispose();
+			const material = mesh.material;
+			const list = Array.isArray(material) ? material : material ? [material] : [];
+			for (const m of list) m.dispose?.();
+		});
+		super.free();
+	}
 };
 const worldScratch = new Vector3();
 const dirScratch = new Vector3();
@@ -10863,10 +11145,23 @@ var Tree3D = class Tree3D extends Node3D {
 			this.leafFadeUniform.end.value = this.leafFadeEnd;
 		}
 	}
-	_syncObject3D() {
-		super._syncObject3D();
+	/** The scene's asset store, so a 404'd bark or leaf reaches assetErrors(). */
+	assets = null;
+	_syncObject3D(alpha = 1, assets = null) {
+		super._syncObject3D(alpha, assets);
+		this.assets = assets;
 		this.rebuildIfNeeded();
 	}
+	/**
+	* File a texture failure where the ladder reads it.
+	*
+	* This node keeps its own cache on purpose, and that left its textures
+	* outside the one place `assetErrors()` looks — so a leaf URL that 404s was a
+	* forest of bare branches with no message anywhere.
+	*/
+	noteTextureError = (url, error) => {
+		this.assets?.textures.noteError(url, error);
+	};
 	/** Re-grow only when a grove-shaping prop changed (the JSON IS the grove). */
 	rebuildIfNeeded() {
 		if (!this.grove) {
@@ -10975,7 +11270,7 @@ var Tree3D = class Tree3D extends Node3D {
 				if (loader) material.map = loadSharedTexture(loader, url, (texture) => {
 					texture.colorSpace = SRGBColorSpace;
 					texture.flipY = false;
-				}, (texture) => greenMatte(texture));
+				}, (texture) => greenMatte(texture), this.noteTextureError);
 				wireLeafWind(material, this.swayUniform, LEAF_ENV_CUT, this.leafFadeUniform ?? void 0);
 				leaves = new InstancedMesh(geometry.leaves, material, instances);
 				leaves.userData.incantoWaterPassSkip = true;
@@ -11040,7 +11335,7 @@ var Tree3D = class Tree3D extends Node3D {
 			texture.anisotropy = 4;
 			texture.flipY = false;
 			if (srgb) texture.colorSpace = SRGBColorSpace;
-		});
+		}, void 0, this.noteTextureError);
 	}
 	/** Per-instance placement + jitter — ONE rng draw order for both paths. */
 	scatter(rng, place) {
@@ -11098,7 +11393,7 @@ var Tree3D = class Tree3D extends Node3D {
 * grove color VARIATION lives on the material tint, not the shared map.)
 */
 const sharedTextures = /* @__PURE__ */ new Map();
-function loadSharedTexture(loader, url, configure, onReady) {
+function loadSharedTexture(loader, url, configure, onReady, onError) {
 	const cached = sharedTextures.get(url);
 	if (cached) return cached;
 	const texture = new Texture();
@@ -11107,7 +11402,7 @@ function loadSharedTexture(loader, url, configure, onReady) {
 		texture.image = bitmap;
 		if (onReady) onReady(texture);
 		else texture.needsUpdate = true;
-	});
+	}, void 0, (error) => onError?.(url, error));
 	sharedTextures.set(url, texture);
 	return texture;
 }
@@ -12169,6 +12464,25 @@ var VoxelGrid3D = class extends Node3D {
 		this.mesh.count = i;
 		this.mesh.instanceMatrix.needsUpdate = true;
 	}
+	/**
+	* Hand the GPU back.
+	*
+	* Every other node that builds geometry disposes it here; these four did not,
+	* so a scene swap left their buffers and materials resident and a game with
+	* level transitions climbed until the tab died — with `stats().geometries` the
+	* only witness, and only if someone was watching it.
+	*/
+	free() {
+		const object = this._builtObject3D;
+		if (object) object.traverse((child) => {
+			const mesh = child;
+			mesh.geometry?.dispose();
+			const material = mesh.material;
+			const list = Array.isArray(material) ? material : material ? [material] : [];
+			for (const m of list) m.dispose?.();
+		});
+		super.free();
+	}
 };
 const FACE_ATTRS = [
 	"colorFront",
@@ -12225,6 +12539,7 @@ function registerNodes3D() {
 	registerNode(MeshInstance3D);
 	registerNode(LoftMesh3D);
 	registerNode(Sprite3D);
+	registerNode(Label3D);
 	registerNode(AnimatedSprite3D);
 	registerNode(Billboard3D);
 	registerNode(CharacterController3D);

package/dist/{gameplay-CRYw_Q-T.js → gameplay-CZ2yq37J.js}

@@ -5242,6 +5242,16 @@ var Cooldown = class {
 	}
 };
 const SHAKE_FALLOFF_SECONDS = .28;
+/** File the effect with the engine, if this one is attached to a running game. */
+function recordEffect(engine, kind, name, from, amount) {
+	engine?.effects.record({
+		kind,
+		name,
+		from,
+		amount,
+		at: engine.time
+	});
+}
 /**
 * Camera shake as a standalone behavior for cameras WITHOUT another script.
 * (FollowCamera has this built in — one script per node.) Composes with any
@@ -5273,6 +5283,7 @@ var CameraShake = class extends Behavior {
 		if (this.engine?.settings.get("reduceMotion") === true) return;
 		this.magnitude = Math.max(this.magnitude, magnitude);
 		this.t = seconds ?? this.falloff;
+		recordEffect(this.engine, "shake", "", this.node?.getPath() ?? "engine", magnitude);
 	}
 	update(dt) {
 		const node = requirePosition(this);
@@ -5300,9 +5311,15 @@ var CameraShake = class extends Behavior {
 };
 /**
 * Full-screen color flash (damage red, pickup white). DOM overlay above
-* everything; headless no-op. Repeated calls restart the fade.
+* everything; headless it draws nothing but still REPORTS, so a damage flash
+* can be checked in a run with no screen (`engine.effects.countOf('#ff0000')`).
+*
+* The engine is the first argument because it is the only juice primitive that
+* did not take one — which is also why nothing in the repo called it, and why a
+* flash was the one piece of feedback no test could see.
 */
-function screenFlash(color = "#ffffff", opacity = .35, seconds = .25) {
+function screenFlash(engine, color = "#ffffff", opacity = .35, seconds = .25) {
+	recordEffect(engine, "flash", color, "engine", opacity);
 	if (typeof document === "undefined") return;
 	const id = "incanto-screen-flash";
 	let el = document.getElementById(id);
@@ -5327,36 +5344,28 @@ function screenFlash(color = "#ffffff", opacity = .35, seconds = .25) {
 * previous timeScale. Stacking calls extend the freeze instead of fighting.
 */
 function hitStop(engine, seconds = .08) {
+	recordEffect(engine, "hitstop", "", "engine", seconds);
 	const state = hitStops.get(engine);
 	if (state) {
-		state.until = Math.max(state.until, realNow() + seconds * 1e3);
+		state.until = Math.max(state.until, engine.unscaledTime + seconds);
 		return;
 	}
 	const restore = engine.timeScale;
 	const entry = {
-		until: realNow() + seconds * 1e3,
-		restore
+		until: engine.unscaledTime + seconds,
+		restore,
+		release: () => {}
 	};
 	hitStops.set(engine, entry);
 	engine.timeScale = 0;
-	const pump = () => {
-		if (realNow() >= entry.until) {
-			engine.timeScale = entry.restore;
-			hitStops.delete(engine);
-			return;
-		}
-		schedule(pump);
-	};
-	schedule(pump);
+	entry.release = engine.updated.connect(() => {
+		if (engine.unscaledTime < entry.until) return;
+		engine.timeScale = entry.restore;
+		entry.release();
+		hitStops.delete(engine);
+	});
 }
 const hitStops = /* @__PURE__ */ new Map();
-function realNow() {
-	return typeof performance !== "undefined" ? performance.now() : Date.now();
-}
-function schedule(fn) {
-	if (typeof requestAnimationFrame === "function") requestAnimationFrame(fn);
-	else setTimeout(fn, 16);
-}
 //#endregion
 //#region src/gameplay/lifetime.ts
 /**

package/dist/gameplay.d.ts

@@ -1,4 +1,4 @@
-import { Dt as Node, b as Engine, d as PropSchema, n as BehaviorCtor, t as Behavior } from "./behavior-Do0Da56m.js";
+import { At as Node, b as Engine, d as PropSchema, n as BehaviorCtor, t as Behavior } from "./behavior-CyQoSu4n.js";
 import { c as JsonValue, s as JsonObject } from "./schema-CFeioQRE.js";
 
 //#region src/gameplay/chase.d.ts
@@ -813,9 +813,14 @@ declare class CameraShake extends Behavior {
 }
 /**
 * Full-screen color flash (damage red, pickup white). DOM overlay above
-* everything; headless no-op. Repeated calls restart the fade.
+* everything; headless it draws nothing but still REPORTS, so a damage flash
+* can be checked in a run with no screen (`engine.effects.countOf('#ff0000')`).
+*
+* The engine is the first argument because it is the only juice primitive that
+* did not take one — which is also why nothing in the repo called it, and why a
+* flash was the one piece of feedback no test could see.
 */
-declare function screenFlash(color?: string, opacity?: number, seconds?: number): void;
+declare function screenFlash(engine: Engine, color?: string, opacity?: number, seconds?: number): void;
 /**
 * Hit-stop: freeze game time for `seconds` of REAL time, then restore the
 * previous timeScale. Stacking calls extend the freeze instead of fighting.

package/dist/gameplay.js

@@ -1,2 +1,2 @@
-import { A as Chase, C as restartScene, D as DamageOnContact, E as phaseOf, O as Health, S as goToScene, T as DayNight, _ as Cooldown, a as Wander, b as Interactable, c as SavePoint, d as Patrol, f as PathFollow, g as CameraShake, h as Lifetime, i as WaveSpawner, k as Collector, l as Projectile, m as MoveTo, n as registerGameplayBehaviors, o as Spawner, p as Oscillate, r as ZombieAI, s as ScoreKeeper, t as GAMEPLAY_BEHAVIORS, u as Pickup, v as hitStop, w as FollowCamera, x as GameFlow, y as screenFlash } from "./gameplay-CRYw_Q-T.js";
+import { A as Chase, C as restartScene, D as DamageOnContact, E as phaseOf, O as Health, S as goToScene, T as DayNight, _ as Cooldown, a as Wander, b as Interactable, c as SavePoint, d as Patrol, f as PathFollow, g as CameraShake, h as Lifetime, i as WaveSpawner, k as Collector, l as Projectile, m as MoveTo, n as registerGameplayBehaviors, o as Spawner, p as Oscillate, r as ZombieAI, s as ScoreKeeper, t as GAMEPLAY_BEHAVIORS, u as Pickup, v as hitStop, w as FollowCamera, x as GameFlow, y as screenFlash } from "./gameplay-CZ2yq37J.js";
 export { CameraShake, Chase, Collector, Cooldown, DamageOnContact, DayNight, FollowCamera, GAMEPLAY_BEHAVIORS, GameFlow, Health, Interactable, Lifetime, MoveTo, Oscillate, PathFollow, Patrol, Pickup, Projectile, SavePoint, ScoreKeeper, Spawner, Wander, WaveSpawner, ZombieAI, goToScene, hitStop, phaseOf, registerGameplayBehaviors, restartScene, screenFlash };