incanto 0.34.0 → 0.35.0

package/dist/env.d.ts

@@ -1,4 +1,4 @@
-import { a as Rng, i as SceneJson, n as NodeJson, s as JsonObject } from "./schema-CcoWb32N.js";
+import { a as Rng, i as SceneJson, n as NodeJson, s as JsonObject } from "./schema-3ywbdlrv.js";
 
 //#region src/env/arena.d.ts
 /** Valid `generateArena` themes — drives the catalog options AND validation. */

package/dist/{environment-presets-B6WiUsaO.js → environment-presets-TAGvmM3z.js}

@@ -1,13 +1,157 @@
-import { t as registerCoreNodes } from "./register-G3edsjJ2.js";
+import { t as registerCoreNodes } from "./register-BFLg0-_i.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-CJdGpT2V.js";
 import { t as createNoise2D } from "./noise-CGUMx44x.js";
 import { i as applyParticlePreset, r as PARTICLE_PRESET_NAMES, t as ParticleSim } from "./particle-sim-Bw7hB93B.js";
-import { A as Water3D, F as PhysicsBody3D, H as colliderFootDrop, I as RigidBody3D, L as StaticBody3D, M as WaterCutout3D, N as Area3D, P as CharacterBody3D, R as Node3D } from "./gameplay-BxFtmfSe.js";
+import { A as Water3D, F as PhysicsBody3D, H as colliderFootDrop, I as RigidBody3D, L as StaticBody3D, M as WaterCutout3D, N as Area3D, P as CharacterBody3D, R as Node3D } from "./gameplay-BvhcQbfJ.js";
 import { n as splatWeights, t as buildHeightmap } from "./heightmap-CRK0M4jT.js";
-import { AdditiveBlending, AnimationClip, AnimationMixer, Box3, BoxGeometry, BufferAttribute, BufferGeometry, CanvasTexture, CapsuleGeometry, Color, ConeGeometry, CylinderGeometry, DataTexture, DirectionalLight, DoubleSide, DynamicDrawUsage, Euler, Group, IcosahedronGeometry, ImageBitmapLoader, InstancedBufferAttribute, InstancedMesh, LinearFilter, LoopOnce, LoopRepeat, Matrix4, Mesh, MeshBasicMaterial, MeshDepthMaterial, MeshPhysicalMaterial, MeshStandardMaterial, NearestFilter, NoBlending, 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 { 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";
+//#region src/3d/textures.ts
+/**
+* One decode per image, however many nodes want it.
+*
+* Four places each built their own `new TextureLoader()` per node — `Sprite3D`,
+* `AnimatedSprite3D`, `MeshInstance3D`, `Terrain3D` — so a hundred sprite mobs
+* sharing one atlas meant a hundred fetches, a hundred decodes and a hundred GPU
+* uploads. `AssetStore3D` knew only `model` and `animation`; textures had no
+* owner at all. The 2D side has solved this since day one (`2d/assets.ts`).
+*
+* `tree-3d.ts` keeps its own map and is deliberately NOT folded in here: it
+* already dedupes, it decodes off-thread through `ImageBitmapLoader`, and its
+* page-session lifetime is load-bearing (the editor builds and disposes three
+* renderers, so store-scoping it would re-decode every bark and leaf on every
+* Play). Nothing to fix there.
+*
+* **`acquire` returns the SHARED texture.** That is the important default and it
+* is deliberately not a clone: `Texture.copy()` ends with `needsUpdate = true`,
+* which bumps `source.version`, which makes the next draw re-upload the whole
+* image. Cloning on every acquire would turn "spawn an enemy per frame" into
+* "re-upload the atlas per frame" — precisely the stall this file exists to
+* remove.
+*
+* `acquireOwn` is for the two nodes that genuinely hold per-node UV state:
+* `AnimatedSprite3D` (a frame window) and `MeshInstance3D` (`repeat`). A clone
+* shares `texture.source`, so three still fetches and decodes once and, when the
+* sampler parameters match, hands out one GL texture for all of them.
+*/
+const defaultLoad = (url, onError) => new TextureLoader().load(url, void 0, void 0, onError);
+function keyOf(url, spec) {
+	return [
+		url,
+		spec?.colorSpace ?? "srgb",
+		spec?.filter ?? "linear",
+		spec?.wrap ?? "clamp",
+		String(spec?.anisotropy ?? 1),
+		spec?.process?.id ?? ""
+	].join("|");
+}
+function dress(texture, spec) {
+	texture.colorSpace = (spec?.colorSpace ?? "srgb") === "srgb" ? SRGBColorSpace : NoColorSpace;
+	const nearest = spec?.filter === "nearest";
+	texture.magFilter = nearest ? NearestFilter : LinearFilter;
+	texture.generateMipmaps = !nearest;
+	texture.minFilter = nearest ? NearestFilter : LinearMipmapLinearFilter;
+	const wrap = spec?.wrap === "repeat" ? RepeatWrapping : ClampToEdgeWrapping;
+	texture.wrapS = wrap;
+	texture.wrapT = wrap;
+	if (spec?.anisotropy) texture.anisotropy = spec.anisotropy;
+}
+var TextureCache3D = class {
+	entries = /* @__PURE__ */ new Map();
+	load;
+	diagnostics;
+	constructor(opts) {
+		this.load = opts?.loader ?? defaultLoad;
+		this.diagnostics = opts?.diagnostics ?? null;
+	}
+	/**
+	* The SHARED texture for this url+spec, or null with no DOM to decode in.
+	*
+	* Callers must NOT mutate `offset`/`repeat`/`center`/`rotation` on it — that
+	* is what `acquireOwn` is for — and must not dispose it; the store owns it.
+	*/
+	acquire(url, spec) {
+		if (url === "") return null;
+		if (typeof document === "undefined" && this.load === defaultLoad) return null;
+		const key = keyOf(url, spec);
+		const found = this.entries.get(key);
+		if (found) return found.texture;
+		const entry = {
+			url,
+			texture: null,
+			error: null
+		};
+		entry.texture = this.load(url, (error) => {
+			entry.error = error instanceof Error ? error.message : String(error);
+			this.diagnostics?.warn(`texture failed to load: ${url} — ${entry.error}`);
+		});
+		dress(entry.texture, spec);
+		spec?.process?.run(entry.texture);
+		this.entries.set(key, entry);
+		return entry.texture;
+	}
+	/**
+	* A private CLONE, for a node that writes its own UV window.
+	*
+	* The caller owns it and disposes it in `free()`. That is safe: three
+	* refcounts the GPU texture per `source`, so disposing one clone does not
+	* pull the image out from under the others.
+	*/
+	acquireOwn(url, spec) {
+		const master = this.acquire(url, spec);
+		return master ? master.clone() : null;
+	}
+	/**
+	* What 404'd, by URL — reported raw, never by cache key, because an agent
+	* greps this against the URL it wrote.
+	*/
+	errors() {
+		const out = [];
+		for (const entry of this.entries.values()) if (entry.error !== null) out.push({
+			url: entry.url,
+			error: entry.error
+		});
+		return out;
+	}
+	/** How many distinct images this store has decoded — the point, measurable. */
+	size() {
+		return this.entries.size;
+	}
+	dispose() {
+		for (const entry of this.entries.values()) entry.texture.dispose();
+		this.entries.clear();
+	}
+};
+/**
+* The one call a node makes: shared texture through the store, or an uncached
+* load when there is no store (a detached probe, a headless test).
+*
+* The fallback is deliberately silent and deliberately uncached — a node that
+* renders outside a renderer walk is a legitimate case (`Tree3D._trunk()` builds
+* detached), and failing there would be worse than doing the work twice.
+*/
+function acquireTexture(assets, url, spec) {
+	if (assets) return assets.textures.acquire(url, spec);
+	return uncached().acquire(url, spec);
+}
+/** As `acquireTexture`, but a private clone for a node with its own UV window. */
+function acquireOwnTexture(assets, url, spec) {
+	if (assets) return assets.textures.acquireOwn(url, spec);
+	return uncached().acquireOwn(url, spec);
+}
+/**
+* A throwaway cache for the store-less path.
+*
+* Not a module-level shared instance: that is the module-level engine state the
+* repo bans, and it is what `tree-3d.ts` had. One decode per call here is the
+* honest cost of rendering outside a renderer.
+*/
+function uncached() {
+	return new TextureCache3D();
+}
+//#endregion
 //#region src/3d/camera-rig.ts
 const QUARTER_PITCH = Math.atan(1 / Math.SQRT2);
 function rigPose(view, player, eyeHeight, yaw, pitch, distance) {
@@ -227,8 +371,8 @@ var MeshInstance3D = class extends Node3D {
 	_createObject3D() {
 		return new Mesh(new BoxGeometry(1, 1, 1), new MeshPhysicalMaterial());
 	}
-	_syncObject3D() {
-		super._syncObject3D();
+	_syncObject3D(alpha = 1, assets = null) {
+		super._syncObject3D(alpha, assets);
 		const m = this._ensureObject3D();
 		const key = `${this.mesh}:${JSON.stringify(this.size)}`;
 		if (key !== this.geometryKey) {
@@ -238,14 +382,14 @@ var MeshInstance3D = class extends Node3D {
 		}
 		const mat = m.material;
 		applyMeshMaterial(mat, this.material);
-		this.syncTextures(mat);
+		this.syncTextures(mat, assets);
 		m.castShadow = this.castShadow;
 		m.receiveShadow = this.receiveShadow;
 	}
 	/** Lazy texture dressing — same headless guard as Tree3D bark: without a
 	* DOM there is no Image decode, so geometry/colors apply and the maps are
 	* skipped. Re-loads only when a texture-shaping key changes. */
-	syncTextures(mat) {
+	syncTextures(mat, assets) {
 		const key = JSON.stringify([
 			this.material.map ?? "",
 			this.material.normalMap ?? "",
@@ -258,25 +402,50 @@ var MeshInstance3D = class extends Node3D {
 		const hadMaps = mat.map !== null || mat.normalMap !== null;
 		mat.map = null;
 		mat.normalMap = null;
-		const loader = typeof document !== "undefined" ? new TextureLoader() : null;
-		if (loader && this.material.map) mat.map = this.loadTexture(loader, this.material.map, true);
-		if (loader && this.material.normalMap) mat.normalMap = this.loadTexture(loader, this.material.normalMap, false);
+		if (this.material.map) mat.map = this.loadTexture(assets, this.material.map, true);
+		if (this.material.normalMap) mat.normalMap = this.loadTexture(assets, this.material.normalMap, false);
 		if (hadMaps || mat.map || mat.normalMap) mat.needsUpdate = true;
 	}
-	loadTexture(loader, url, srgb) {
-		const texture = loader.load(url);
-		texture.wrapS = RepeatWrapping;
-		texture.wrapT = RepeatWrapping;
+	/**
+	* A private CLONE: `repeat` is per-node here (a 1x1 crate and a 8x8 floor
+	* share one tile image), and that is the one field a shared master cannot
+	* carry. The clone shares `texture.source`, so the fetch and the decode are
+	* still done once per url for the whole scene.
+	*/
+	loadTexture(assets, url, srgb) {
+		const texture = acquireOwnTexture(assets, url, {
+			wrap: "repeat",
+			anisotropy: 4,
+			colorSpace: srgb ? "srgb" : "linear"
+		});
+		if (!texture) return null;
 		const [u, v] = this.material.repeat ?? [1, 1];
 		texture.repeat.set(u, v);
-		texture.anisotropy = 4;
-		if (srgb) texture.colorSpace = SRGBColorSpace;
 		this.loadedTextures.push(texture);
 		return texture;
 	}
+	/**
+	* Give the GPU back everything this node OWNS.
+	*
+	* It used to dispose textures and nothing else, so every freed mesh leaked its
+	* geometry and its material — a wave spawner that kills and respawns fifty
+	* enemies a minute leaks fifty of each, forever, and nothing in the game says
+	* so. Both are built here (`_createObject3D` news them, `_syncObject3D`
+	* rebuilds the geometry on a shape change), so both are ours to release.
+	*
+	* The textures are NOT: since the shared texture cache they belong to the
+	* asset store, except the per-node clones this node asked for, which are what
+	* `loadedTextures` holds.
+	*/
 	free() {
 		for (const texture of this.loadedTextures) texture.dispose();
 		this.loadedTextures = [];
+		const mesh = this._builtObject3D;
+		if (mesh) {
+			mesh.geometry?.dispose();
+			const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
+			for (const material of materials) material?.dispose();
+		}
 		super.free();
 	}
 };
@@ -535,7 +704,10 @@ var Joint3D = class extends Node3D {
 				"spring"
 			]
 		},
-		target: { default: "" },
+		target: {
+			default: "",
+			nodePath: true
+		},
 		anchor: { default: [
 			0,
 			0,
@@ -1417,7 +1589,6 @@ var Terrain3D = class extends Node3D {
 	heightmap = null;
 	heightmapKey = "";
 	builtKey = "";
-	loadedTextures = [];
 	_createObject3D() {
 		const geometry = new BufferGeometry();
 		geometry.setAttribute("position", new BufferAttribute(new Float32Array(0), 3));
@@ -1516,9 +1687,9 @@ var Terrain3D = class extends Node3D {
 		if (this.theme === "custom") return this.layers;
 		return terrainThemeLayers(this.theme, this.textureBase);
 	}
-	_syncObject3D() {
-		super._syncObject3D();
-		this.rebuildIfNeeded();
+	_syncObject3D(alpha = 1, assets = null) {
+		super._syncObject3D(alpha, assets);
+		this.rebuildIfNeeded(assets);
 	}
 	effectiveIslandEdge() {
 		return this.islandEdge ?? this.theme === "island";
@@ -1527,7 +1698,7 @@ var Terrain3D = class extends Node3D {
 		return Math.max(2, Math.min(Math.floor(this.resolution), MAX_RESOLUTION));
 	}
 	/** Rebuild geometry+material only when a terrain-shaping prop changed. */
-	rebuildIfNeeded() {
+	rebuildIfNeeded(assets) {
 		const key = JSON.stringify([
 			this.size,
 			this.maxHeight,
@@ -1549,8 +1720,7 @@ var Terrain3D = class extends Node3D {
 		mesh.geometry.dispose();
 		mesh.geometry = this.buildGeometry();
 		mesh.material.dispose();
-		this.disposeTextures();
-		mesh.material = this.buildMaterial();
+		mesh.material = this.buildMaterial(assets);
 		mesh.receiveShadow = true;
 		mesh.castShadow = true;
 	}
@@ -1583,20 +1753,14 @@ var Terrain3D = class extends Node3D {
 		geometry.setAttribute("color", new BufferAttribute(colors, 3));
 		return geometry;
 	}
-	buildMaterial() {
+	buildMaterial(assets) {
 		const layers = this.resolvedLayers();
 		const material = new MeshStandardMaterial({ vertexColors: true });
-		const loader = typeof document !== "undefined" ? new TextureLoader() : null;
-		const load = (url, srgb) => {
-			if (!loader || !url) return null;
-			const tex = loader.load(url);
-			tex.wrapS = RepeatWrapping;
-			tex.wrapT = RepeatWrapping;
-			tex.anisotropy = 8;
-			if (srgb) tex.colorSpace = SRGBColorSpace;
-			this.loadedTextures.push(tex);
-			return tex;
-		};
+		const load = (url, srgb) => url ? acquireTexture(assets, url, {
+			wrap: "repeat",
+			anisotropy: 8,
+			colorSpace: srgb ? "srgb" : "linear"
+		}) : null;
 		const textures = layers.map((l) => load(l.texture, true));
 		const normalMaps = layers.map((l) => load(l.normalMap, false));
 		const hasNormalMaps = normalMaps.some((t) => t !== null);
@@ -1621,15 +1785,10 @@ var Terrain3D = class extends Node3D {
 		material.customProgramCacheKey = () => `incanto-terrain-splat:${hasNormalMaps ? 1 : 0}`;
 		return material;
 	}
-	disposeTextures() {
-		for (const tex of this.loadedTextures) tex.dispose();
-		this.loadedTextures = [];
-	}
 	free() {
 		const mesh = this._ensureObject3D();
 		mesh.geometry.dispose();
 		mesh.material.dispose();
-		this.disposeTextures();
 		this.heightmap = null;
 		super.free();
 	}
@@ -1776,25 +1935,16 @@ var Sprite3D = class extends Node3D {
 		return this.quadMesh;
 	}
 	/** Override point: AnimatedSprite3D substitutes its frame window here. */
-	resolveTexture() {
+	resolveTexture(assets) {
 		if (!this.texture) return null;
 		if (this.textureRef !== this.texture) {
-			this.loadedTexture?.dispose();
-			this.loadedTexture = null;
 			this.textureRef = this.texture;
-			if (typeof document !== "undefined") {
-				const tex = new TextureLoader().load(this.texture);
-				tex.colorSpace = SRGBColorSpace;
-				const filter = this.pixelArt ? NearestFilter : LinearFilter;
-				tex.magFilter = filter;
-				tex.minFilter = filter;
-				this.loadedTexture = tex;
-			}
+			this.loadedTexture = acquireTexture(assets, this.texture, { filter: this.pixelArt ? "nearest" : "linear" });
 		}
 		return this.loadedTexture;
 	}
-	_syncObject3D(alpha = 1) {
-		super._syncObject3D(alpha);
+	_syncObject3D(alpha = 1, assets = null) {
+		super._syncObject3D(alpha, assets);
 		const quad = this._quad();
 		const mat = quad.material;
 		const w = this.size[0] ?? 1;
@@ -1803,7 +1953,7 @@ var Sprite3D = class extends Node3D {
 		const ax = this.anchor[0] ?? .5;
 		const ay = this.anchor[1] ?? 0;
 		quad.position.set((.5 - ax) * w, (.5 - ay) * h, 0);
-		const tex = this.resolveTexture();
+		const tex = this.resolveTexture(assets);
 		if (mat.map !== tex) {
 			mat.map = tex;
 			mat.needsUpdate = true;
@@ -1999,20 +2149,12 @@ var AnimatedSprite3D = class extends Sprite3D {
 		}
 		this.currentFrame = this.frameList[this.frameIndex] ?? 0;
 	}
-	resolveTexture() {
+	resolveTexture(assets) {
 		if (!this.sheet || this.frameWidth <= 0 || this.frameHeight <= 0) return null;
 		if (this.loadedSheetRef !== this.sheet) {
 			this.sheetTexture?.dispose();
-			this.sheetTexture = null;
 			this.loadedSheetRef = this.sheet;
-			if (typeof document !== "undefined") {
-				const tex = new TextureLoader().load(this.sheet);
-				tex.colorSpace = SRGBColorSpace;
-				const filter = this.pixelArt ? NearestFilter : LinearFilter;
-				tex.magFilter = filter;
-				tex.minFilter = filter;
-				this.sheetTexture = tex;
-			}
+			this.sheetTexture = acquireOwnTexture(assets, this.sheet, { filter: this.pixelArt ? "nearest" : "linear" });
 		}
 		const tex = this.sheetTexture;
 		if (!tex) return null;
@@ -2141,7 +2283,10 @@ var BoneAttachment3D = class extends Node3D {
 	static typeName = "BoneAttachment3D";
 	static props = {
 		/** Node path to the ModelInstance3D whose skeleton to ride. */
-		target: { default: "" },
+		target: {
+			default: "",
+			nodePath: true
+		},
 		/** Bone name ("RightHand", "Head", …). Empty = inert. */
 		bone: { default: "" }
 	};
@@ -2205,11 +2350,17 @@ var BoneLookAt3D = class extends Node3D {
 	static typeName = "BoneLookAt3D";
 	static props = {
 		/** Node path to the ModelInstance3D whose bone to steer. */
-		target: { default: "" },
+		target: {
+			default: "",
+			nodePath: true
+		},
 		/** Bone name ("Head", "Neck", "Spine2" — Mixamo spellings matched). */
 		bone: { default: "Head" },
 		/** Node path to LOOK AT ('' = idle). */
-		lookAt: { default: "" },
+		lookAt: {
+			default: "",
+			nodePath: true
+		},
 		/** Comfort cone half-angle, degrees — beyond it the head returns to the anim. */
 		maxAngleDeg: { default: 75 },
 		/** Blend weight 0..1 (how far toward the target the bone turns). */
@@ -2400,7 +2551,10 @@ var CharacterController3D = class extends Node3D {
 		moveAction: { default: "move" },
 		jumpAction: { default: "jump" },
 		sprintAction: { default: "sprint" },
-		skinPath: { default: "../Skin" },
+		skinPath: {
+			default: "../Skin",
+			nodePath: true
+		},
 		skinYawOffset: { default: 0 },
 		animations: { default: {} }
 	};
@@ -3319,7 +3473,10 @@ var Flowers3D = class extends Node3D {
 		sway: { default: .5 },
 		drape: { default: null },
 		avoidWater: { default: true },
-		terrain: { default: "" }
+		terrain: {
+			default: "",
+			nodePath: true
+		}
 	};
 	/** 'lush' | 'sparse' | 'none' | plants per m² (load-time check + budget). */
 	density = "sparse";
@@ -4720,7 +4877,10 @@ var Foliage3D = class Foliage3D extends Node3D {
 		seed: { default: 1 },
 		drape: { default: null },
 		avoidWater: { default: true },
-		terrain: { default: "" },
+		terrain: {
+			default: "",
+			nodePath: true
+		},
 		renderOrder: { default: 2 }
 	};
 	/** Transparent blades draw after water (1) + opaque ground (overrides Node3D's 0). */
@@ -7984,7 +8144,10 @@ var River3D = class River3D extends Node3D {
 		] },
 		sunColor: { default: "#fff6e0" },
 		sunIntensity: { default: 1 },
-		terrain: { default: "" },
+		terrain: {
+			default: "",
+			nodePath: true
+		},
 		carve: { default: true },
 		flowForce: { default: 1 },
 		spray: { default: 1 }
@@ -10394,7 +10557,10 @@ var Tree3D = class Tree3D extends Node3D {
 		leafFadeEnd: { default: 0 },
 		leafShadows: { default: true },
 		drape: { default: null },
-		terrain: { default: "" }
+		terrain: {
+			default: "",
+			nodePath: true
+		}
 	};
 	/** 'simple' (primitive low-poly) | 'medium' (light ez-trees) | 'high' (full). */
 	tier = "medium";
@@ -11909,4 +12075,4 @@ function resolveEnvironmentHdri(env) {
 	return null;
 }
 //#endregion
-export { Terrain3D as A, keyboardIntensity as B, resolveFlowerDensity as C, BoneLookAt3D as D, Camera3D as E, InstancedMesh3D as F, rigPose as H, MeshInstance3D as I, buildMeshGeometry as L, TERRAIN_THEMES as M, terrainThemeLayers as N, BoneAttachment3D as O, Joint3D as P, QUARTER_PITCH as R, Flowers3D as S, CharacterController3D as T, movementState as V, LoftMesh3D as _, Tree3D as a, Foliage3D as b, buildRiverRings as c, riverCarveChannels as d, riverStepFor as f, ModelInstance3D as g, Particles3D as h, VoxelGrid3D as i, DEFAULT_TERRAIN_TEXTURE_BASE as j, Billboard3D as k, findRiverCoverageGaps as l, traceDownhillPath as m, registerNodes3D as n, Trail3D as o, smoothCourse as p, VOXEL_PALETTE as r, River3D as s, resolveEnvironmentHdri as t, projectToRiver as u, DirectionalLight3D as v, FLOWER_VARIETIES as w, DENSITY_PRESETS as x, OmniLight3D as y, cameraRelative as z };
+export { Terrain3D as A, keyboardIntensity as B, resolveFlowerDensity as C, BoneLookAt3D as D, Camera3D as E, InstancedMesh3D as F, acquireTexture as G, rigPose as H, MeshInstance3D as I, buildMeshGeometry as L, TERRAIN_THEMES as M, terrainThemeLayers as N, BoneAttachment3D as O, Joint3D as P, QUARTER_PITCH as R, Flowers3D as S, CharacterController3D as T, TextureCache3D as U, movementState as V, acquireOwnTexture as W, LoftMesh3D as _, Tree3D as a, Foliage3D as b, buildRiverRings as c, riverCarveChannels as d, riverStepFor as f, ModelInstance3D as g, Particles3D as h, VoxelGrid3D as i, DEFAULT_TERRAIN_TEXTURE_BASE as j, Billboard3D as k, findRiverCoverageGaps as l, traceDownhillPath as m, registerNodes3D as n, Trail3D as o, smoothCourse as p, VOXEL_PALETTE as r, River3D as s, resolveEnvironmentHdri as t, projectToRiver as u, DirectionalLight3D as v, FLOWER_VARIETIES as w, DENSITY_PRESETS as x, OmniLight3D as y, cameraRelative as z };

package/dist/{errors-1dXlIwoR.d.ts → errors-BY2kL0hv.d.ts}

@@ -1,4 +1,4 @@
-import { s as JsonObject } from "./schema-CcoWb32N.js";
+import { s as JsonObject } from "./schema-3ywbdlrv.js";
 
 //#region src/core/audit.d.ts
 /** Human-readable warnings (empty = clean). Pure JSON walk, no registry. */

package/dist/{gameplay-BxFtmfSe.js → gameplay-BvhcQbfJ.js}

@@ -1,7 +1,7 @@
-import { f as Node, g as Behavior, n as loadScene, y as registerBehavior } from "./loader-BwR0DxeM.js";
+import { f as Node, g as Behavior, n as loadScene, x as registerBehavior } from "./loader-Mig5fY4n.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { t as jsonClone } from "./json-BLk7H2Qa.js";
-import { r as effectiveOrder, t as duplicateNode } from "./duplicate-DlOvknDO.js";
+import { r as effectiveOrder, t as duplicateNode } from "./duplicate-C716f-97.js";
 import { Color, CubeCamera, DepthTexture, DoubleSide, Euler, FloatType, Frustum, HalfFloatType, LinearMipmapLinearFilter, MathUtils, Matrix4, Mesh, MeshDepthMaterial, Object3D, PerspectiveCamera, Plane, PlaneGeometry, Quaternion, ShaderMaterial, Sphere, Vector2, Vector3, Vector4, WebGLCubeRenderTarget, WebGLRenderTarget } from "three";
 //#region src/3d/frustum.ts
 const scratchFrustum = new Frustum();
@@ -2390,8 +2390,15 @@ var Node3D = class Node3D extends Node {
 	}
 	/** @internal Push JSON props onto the backing object. Called every frame.
 	*  `alpha` (0..1) interpolates a physics body between its last two fixed-step
-	*  positions; non-physics nodes ignore it and render `position` directly. */
-	_syncObject3D(alpha = 1) {
+	*  positions; non-physics nodes ignore it and render `position` directly.
+	*
+	*  `assets` is the renderer's store, the only route a node has to shared
+	*  textures — mirroring `_syncObject2D(assets)`, which has always taken it. It
+	*  is a PARAMETER rather than a field so a node that forgets it is a type
+	*  error rather than a silent per-node decode; overrides that do not need it
+	*  simply keep the one-argument signature. Null in a headless test or a
+	*  detached probe, where the node falls back to loading uncached. */
+	_syncObject3D(alpha = 1, _assets = null) {
 		const o = this._ensureObject3D();
 		const prev = this._interpPrev;
 		const curr = this._interpCurr;
@@ -3973,7 +3980,10 @@ const MIN_DRAFT_REF = .15;
 var Buoyancy = class extends Behavior {
 	static props = {
 		/** Water node path; empty = the first Water3D in the tree. */
-		water: { default: "" },
+		water: {
+			default: "",
+			nodePath: true
+		},
 		/** Where the resting WATERLINE sits below the body origin, in meters. A
 		* hull whose origin is its interior floor wants a draft of ~0.1: the water
 		* then rests that far under the floor and the boat is dry inside. */
@@ -4191,7 +4201,10 @@ function smoothingFactor(smoothing, dt) {
 var Chase = class extends Behavior {
 	static props = {
 		/** NodePath of the node to chase (resolved from THIS behavior's node). */
-		target: { default: "" },
+		target: {
+			default: "",
+			nodePath: true
+		},
 		/** Units per second toward the target. */
 		speed: { default: 60 },
 		/** Stop (and emit reachedTarget) when within this distance. */
@@ -4362,6 +4375,14 @@ group: { default: "player" } };
 		this.total += value;
 		this.emit("totalChanged", this.total);
 	}
+	/** How many have been picked up so far. */
+	serialize() {
+		return { total: this.total };
+	}
+	deserialize(data) {
+		const d = data;
+		if (typeof d.total === "number") this.total = d.total;
+	}
 };
 //#endregion
 //#region src/gameplay/health.ts
@@ -4455,6 +4476,18 @@ var Health = class extends Behavior {
 		this.emit("died");
 		if (this.freeOnDeath) this.node.queueFree();
 	}
+	/** Current HP and whether death already fired — `max` comes back from JSON. */
+	serialize() {
+		return {
+			current: this.current,
+			dead: this.dead
+		};
+	}
+	deserialize(data) {
+		const d = data;
+		if (typeof d.current === "number") this.current = Math.min(this.max, Math.max(0, d.current));
+		if (typeof d.dead === "boolean") this.dead = d.dead;
+	}
 };
 //#endregion
 //#region src/gameplay/trigger.ts
@@ -4686,7 +4719,10 @@ function phaseOf(hour) {
 var FollowCamera = class extends Behavior {
 	static props = {
 		/** NodePath of the node to follow (relative to this node, or absolute). */
-		target: { default: "" },
+		target: {
+			default: "",
+			nodePath: true
+		},
 		/** Constant offset added to the target's position ([x,y] or [x,y,z]). */
 		offset: { default: [] },
 		/** 0..1 retention factor: 0 = snap, higher = smoother chase. */
@@ -4802,7 +4838,10 @@ var GameFlow = class extends Behavior {
 	static props = {
 		restartAction: { default: "restart" },
 		freezeOnEnd: { default: true },
-		bannerPath: { default: "%Banner" }
+		bannerPath: {
+			default: "%Banner",
+			nodePath: true
+		}
 	};
 	/** Input action that restarts from gameover/won (declare it in `input{}`). */
 	restartAction = "restart";
@@ -5603,6 +5642,22 @@ var ScoreKeeper = class extends Behavior {
 			this.emit("lost");
 		}
 	}
+	/** The run's progress. `scoreToWin` is balance and comes back from JSON. */
+	serialize() {
+		return {
+			score: this.score,
+			lives: this.lives,
+			hasWon: this.hasWon,
+			hasLost: this.hasLost
+		};
+	}
+	deserialize(data) {
+		const d = data;
+		if (typeof d.score === "number") this.score = d.score;
+		if (typeof d.lives === "number") this.lives = d.lives;
+		if (typeof d.hasWon === "boolean") this.hasWon = d.hasWon;
+		if (typeof d.hasLost === "boolean") this.hasLost = d.hasLost;
+	}
 };
 //#endregion
 //#region src/gameplay/spawn-source.ts
@@ -5686,7 +5741,10 @@ var SpawnSource = class {
 var Spawner = class extends Behavior {
 	static props = {
 		/** Node path of the template to clone. */
-		prefab: { default: "" },
+		prefab: {
+			default: "",
+			nodePath: true
+		},
 		/** Seconds between spawns. */
 		interval: { default: 1 },
 		/** Max LIVE instances (0 = unlimited). */
@@ -5964,7 +6022,10 @@ var WaveSpawner = class extends Behavior {
 var ZombieAI = class extends Behavior {
 	static props = {
 		/** NodePath of the node to charge once near (usually the player). */
-		aggroTarget: { default: "" },
+		aggroTarget: {
+			default: "",
+			nodePath: true
+		},
 		/** Start charging when the target is within this distance. */
 		aggroRange: { default: 12 },
 		/** Give up the charge past this distance (0 = aggroRange × 1.5). */
@@ -5978,7 +6039,10 @@ var ZombieAI = class extends Behavior {
 		/** Seconds before forcibly choosing a new roam goal. */
 		wanderChangeEvery: { default: 3 },
 		/** Optional NodePath to DRIFT toward while roaming (e.g. the objective). */
-		goalTarget: { default: "" },
+		goalTarget: {
+			default: "",
+			nodePath: true
+		},
 		/** Stop (and idle) this close to the active target. */
 		stopRange: { default: 1.2 },
 		/** Move the parent node instead of this one (AI-on-a-child pattern). */