incanto 0.72.0 → 0.74.0

package/dist/{environment-presets-BeHoaGhy.js → environment-presets-BkqlWewf.js}

@@ -1,14 +1,14 @@
-import { Y as diagnose } from "./save-slots-CEuJPUle.js";
-import { M as translateOn, t as registerCoreNodes } from "./register-5IYfooAN.js";
+import { Y as diagnose } from "./save-slots-CEUGeLuB.js";
+import { M as translateOn, t as registerCoreNodes } from "./register-CjociOtt.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { t as Rng } from "./rng-CDOMybym.js";
-import { c as getNodeSchema, h as didYouMean, p as registerNode } from "./touch-BnCyPA0G.js";
+import { c as getNodeSchema, h as didYouMean, p as registerNode } from "./touch-CioTZB-y.js";
 import { t as createNoise2D } from "./noise-D3nPpmFg.js";
-import { i as ParticleSim, n as resolveFrames, o as PARTICLE_PRESET_NAMES, r as validateAnimations, s as applyParticlePreset, t as resolveAnimation } from "./sprite-animation-CqR2o3SA.js";
-import { B as rejectScale, D as effectRng, G as StaticBody3D, H as CharacterBody3D, K as Node3D, L as Water3D, Q as worldPosition, T as tolerateUnknownAction, U as PhysicsBody3D, V as Area3D, W as RigidBody3D, X as colliderFootDrop, z as WaterCutout3D } from "./gameplay-BlQe-M07.js";
+import { i as ParticleSim, n as resolveFrames, o as PARTICLE_PRESET_NAMES, r as validateAnimations, s as applyParticlePreset, t as resolveAnimation } from "./sprite-animation-Bz3DHD_4.js";
+import { E as tolerateUnknownAction, G as PhysicsBody3D, H as rejectScale, J as Node3D, K as RigidBody3D, O as effectRng, Q as colliderFootDrop, U as Area3D, V as WaterCutout3D, W as CharacterBody3D, et as worldPosition, q as StaticBody3D, z as Water3D } from "./gameplay-Bxe1sMVT.js";
 import { t as checkSheetGrid } from "./sheet-grid-Cea343VO.js";
 import { n as splatWeights, t as buildHeightmap } from "./heightmap-BYgD5Edk.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 { 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, MathUtils, Matrix4, Mesh, MeshBasicMaterial, MeshDepthMaterial, MeshPhysicalMaterial, MeshStandardMaterial, NearestFilter, NoBlending, NoColorSpace, NormalBlending, PerspectiveCamera, PlaneGeometry, PointLight, Points, PointsMaterial, Quaternion, QuaternionKeyframeTrack, RGBADepthPacking, RGBAFormat, RepeatWrapping, SRGBColorSpace, ShaderChunk, ShaderMaterial, SphereGeometry, SpotLight, Texture, TextureLoader, UniformsLib, UniformsUtils, Vector3, Vector4, VectorKeyframeTrack } from "three";
 import { clone } from "three/addons/utils/SkeletonUtils.js";
 //#region src/3d/textures.ts
 /**
@@ -641,7 +641,10 @@ var InstancedMesh3D = class extends Node3D {
 		transforms: { default: [] },
 		castShadow: { default: false },
 		receiveShadow: { default: false },
-		collider: { default: null }
+		collider: {
+			default: null,
+			kinds: ["null", "object"]
+		}
 	};
 	mesh = "box";
 	size = [
@@ -783,7 +786,10 @@ var Joint3D = class extends Node3D {
 		length: { default: 0 },
 		stiffness: { default: 50 },
 		damping: { default: 5 },
-		collide: { default: null }
+		collide: {
+			default: null,
+			kinds: ["null", "boolean"]
+		}
 	};
 	type = "spherical";
 	target = "";
@@ -1583,12 +1589,18 @@ var Terrain3D = class extends Node3D {
 			default: .95,
 			range: { min: 0 }
 		},
-		islandEdge: { default: null },
+		islandEdge: {
+			default: null,
+			kinds: ["null", "boolean"]
+		},
 		layers: { default: [] },
 		textureBase: { default: DEFAULT_TERRAIN_TEXTURE_BASE },
 		basins: { default: [] },
 		channels: { default: [] },
-		wetline: { default: null }
+		wetline: {
+			default: null,
+			kinds: ["null", "object"]
+		}
 	};
 	/** [width, depth] extent in meters, centered on the node. */
 	size = [200, 200];
@@ -2666,7 +2678,7 @@ const correctionScratch = new Quaternion();
 const parentScratch = new Quaternion();
 const quatScratch$1 = new Quaternion();
 //#endregion
-//#region src/3d/nodes/camera-3d.ts
+//#region src/3d/nodes/look-at.ts
 const RAD2DEG$1 = 180 / Math.PI;
 /** World up. The whole fix is that this argument exists. */
 const UP = new Vector3(0, 1, 0);
@@ -2675,6 +2687,50 @@ const targetScratch = new Vector3();
 const lookScratch = new Matrix4();
 const eulerScratch$1 = new Euler(0, 0, 0, "XYZ");
 /**
+* Aim a node's `rotation` at whatever its `lookAt` path names — the camera's
+* rule, shared with the spot light so that "point the searchlight at the
+* player" is one prop and not Euler arithmetic.
+*
+* Runs in `update` and not `_syncObject3D`: the second is the renderer's copy
+* pass and a static node is pruned from it, which silently freezes anything
+* driven there. `rotation` is written as an ordinary prop, so the editor, the
+* serializer and `describeFraming` all see what the node is actually doing.
+*
+* A path that resolves to nothing is an AUDIT finding, not a throw: every
+* other `nodePath` prop in the engine is reported by `auditScene` /
+* `incanto-check`, and throwing here would QUARANTINE the node. A target with
+* no world position (a light, a HudLayer, a plain `Node`) is warned about
+* once per path and the node keeps its authored rotation. Returns the path
+* that has been warned about, for the caller to remember.
+*/
+function aimAt(node, warned, what) {
+	if (node.lookAt === "") return warned;
+	const target = node.getNodeOrNull(node.lookAt);
+	if (!target) return warned;
+	const to = worldPosition(target);
+	if (to.length < 3) {
+		if (warned !== node.lookAt) {
+			diagnose(node.tree?.engine ?? null, "warn", `[incanto] ${node.getPath()}: lookAt '${node.lookAt}' resolves to a ${target.constructor.typeName ?? "Node"}, which has no world position — the ${what} keeps its authored rotation. Point it at a Node3D.`);
+			return node.lookAt;
+		}
+		return warned;
+	}
+	const from = worldPosition(node);
+	eyeScratch.set(from[0] ?? 0, from[1] ?? 0, from[2] ?? 0);
+	targetScratch.set(to[0] ?? 0, to[1] ?? 0, to[2] ?? 0);
+	if (eyeScratch.distanceToSquared(targetScratch) < 1e-12) return warned;
+	lookScratch.lookAt(eyeScratch, targetScratch, UP);
+	eulerScratch$1.setFromRotationMatrix(lookScratch, "XYZ");
+	node.rotation = [
+		eulerScratch$1.x * RAD2DEG$1,
+		eulerScratch$1.y * RAD2DEG$1,
+		eulerScratch$1.z * RAD2DEG$1
+	];
+	return warned;
+}
+//#endregion
+//#region src/3d/nodes/camera-3d.ts
+/**
 * A perspective camera. Mark exactly one camera `current: true`; with none
 * marked, the renderer falls back to the first camera in tree order.
 * Aspect ratio is managed by the renderer on resize.
@@ -2722,38 +2778,13 @@ var Camera3D = class extends Node3D {
 	current = false;
 	lookAt = "";
 	/**
-	* Aim, every frame, whenever `lookAt` names something.
-	*
-	* In `update` and not `_syncObject3D`: the second is the renderer's copy pass
-	* and a static node is pruned from it, which silently freezes anything driven
-	* there. `rotation` is written as an ordinary prop, so the editor, the
-	* serializer and `describeFraming` all see what the camera is actually doing.
+	* Aim, every frame, whenever `lookAt` names something — see `aimAt`, which
+	* the spot light shares.
 	*/
 	/** The `lookAt` path already reported as unlookable — cleared by a new one. */
 	warnedLookAt = "";
 	update(_dt) {
-		if (this.lookAt === "") return;
-		const target = this.getNodeOrNull(this.lookAt);
-		if (!target) return;
-		const to = worldPosition(target);
-		if (to.length < 3) {
-			if (this.warnedLookAt !== this.lookAt) {
-				this.warnedLookAt = this.lookAt;
-				diagnose(this.tree?.engine ?? null, "warn", `[incanto] ${this.getPath()}: lookAt '${this.lookAt}' resolves to a ${target.constructor.typeName ?? "Node"}, which has no world position — the camera keeps its authored rotation. Point it at a Node3D.`);
-			}
-			return;
-		}
-		const from = worldPosition(this);
-		eyeScratch.set(from[0] ?? 0, from[1] ?? 0, from[2] ?? 0);
-		targetScratch.set(to[0] ?? 0, to[1] ?? 0, to[2] ?? 0);
-		if (eyeScratch.distanceToSquared(targetScratch) < 1e-12) return;
-		lookScratch.lookAt(eyeScratch, targetScratch, UP);
-		eulerScratch$1.setFromRotationMatrix(lookScratch, "XYZ");
-		this.rotation = [
-			eulerScratch$1.x * RAD2DEG$1,
-			eulerScratch$1.y * RAD2DEG$1,
-			eulerScratch$1.z * RAD2DEG$1
-		];
+		this.warnedLookAt = aimAt(this, this.warnedLookAt, "camera");
 	}
 	_createObject3D() {
 		return new PerspectiveCamera(this.fov, 1, this.near, this.far);
@@ -2782,6 +2813,8 @@ const MOVEMENT_STATES = [
 	"fastRun",
 	"airborne"
 ];
+/** Air control stands down this long after a wall kick, so the kick lands. */
+const WALL_LOCKOUT_SECONDS = .18;
 const ACC_DELTA_TIME = 8;
 const DRAG_DAMPING = .15;
 const SPRING_K = 1.2;
@@ -2820,7 +2853,7 @@ const UP_VEC = new Vector3(0, 1, 0);
 */
 var CharacterController3D = class extends Node3D {
 	static typeName = "CharacterController3D";
-	static signals = ["movementStateChanged"];
+	static signals = ["movementStateChanged", "wallJumped"];
 	static props = {
 		view: {
 			default: "free",
@@ -2847,6 +2880,11 @@ var CharacterController3D = class extends Node3D {
 		maxJumps: { default: 1 },
 		/** How much of your ground control you keep in the air (0 = none, 1 = full). */
 		airControl: { default: .2 },
+		wallJumpImpulse: { default: [0, 0] },
+		wallSlideSpeed: {
+			default: 0,
+			range: { min: 0 }
+		},
 		/** Gravity multiplier while falling — >1 is the "snappy" arc. */
 		fallGravity: { default: 2.5 },
 		floatHeight: { default: .01 },
@@ -2888,6 +2926,17 @@ var CharacterController3D = class extends Node3D {
 	jumpCutMultiplier = 1;
 	maxJumps = 1;
 	airControl = .2;
+	/**
+	* `[away, up]` m/s: airborne and pressing into a wall, `jump` kicks off it —
+	* away along the wall's normal, up. `[0, 0]` (default) = no wall-jumps.
+	* The controller owns this because a kick written from outside lasted three
+	* frames: the jump cut halved its rise on release and air control steered
+	* the horizontal straight back into the wall. After a kick, air control
+	* stands down for `WALL_LOCKOUT` so the kick lands.
+	*/
+	wallJumpImpulse = [0, 0];
+	/** Max fall speed (m/s) while pressing into a wall; 0 = no wall slide. */
+	wallSlideSpeed = 0;
 	fallGravity = 2.5;
 	floatHeight = .01;
 	/**
@@ -3008,6 +3057,10 @@ var CharacterController3D = class extends Node3D {
 	rising = false;
 	/** Between the jump impulse and the landing — the animation's clock. */
 	jumping = false;
+	/** Seconds of air control still suppressed after a wall kick. */
+	wallLockout = 0;
+	/** The outward normal of the wall being pressed into this step, if any. */
+	wallNormal = null;
 	get body() {
 		const parent = this.parent;
 		if (!(parent instanceof RigidBody3D)) throw new IncantoError("TREE_VIOLATION", `CharacterController3D '${this.name}' must be a child of a RigidBody3D (parent is '${parent?.name ?? "none"}').`);
@@ -3090,7 +3143,29 @@ var CharacterController3D = class extends Node3D {
 		const intensity = keyboardIntensity(moving, sprinting);
 		const speedMultiplier = 1 + (this.sprintMultiplier - 1) * intensity;
 		const targetSpeed = moving ? this.maxSpeed * speedMultiplier : 0;
-		const control = this.grounded ? 1 : this.airControl;
+		this.wallNormal = null;
+		if ((this.wallSlideSpeed > 0 || this.wallJumpImpulse.some((v) => v !== 0)) && !this.grounded && moving) {
+			const r = body.collider.radius ?? .32;
+			const n = (this.tree?.engine?.physics?.castRay([
+				pos[0] ?? 0,
+				pos[1] ?? 0,
+				pos[2] ?? 0
+			], [
+				mx,
+				0,
+				mz
+			], r + .25, body, { staticOnly: true }))?.normal;
+			if (n && Math.hypot(n[0] ?? 0, n[2] ?? 0) > .5) {
+				const len = Math.hypot(n[0] ?? 0, n[2] ?? 0);
+				this.wallNormal = [
+					(n[0] ?? 0) / len,
+					0,
+					(n[2] ?? 0) / len
+				];
+			}
+		}
+		this.wallLockout = Math.max(0, this.wallLockout - dt);
+		const control = this.wallLockout > 0 ? 0 : this.grounded ? 1 : this.airControl;
 		const ax = (mx * targetSpeed + carry[0] - vel[0]) / ACC_DELTA_TIME * control;
 		const az = (mz * targetSpeed + carry[1] - vel[2]) / ACC_DELTA_TIME * control;
 		body.applyImpulse([
@@ -3121,7 +3196,7 @@ var CharacterController3D = class extends Node3D {
 				if (rise > .02 && rise <= this.stepHeight + .02) springToi = toi - rise;
 			}
 		}
-		if (springToi !== null && springToi < floatingDis * 2 && !this.jumping) {
+		if (springToi !== null && springToi < floatingDis * 2 && !this.jumping && (vel[1] ?? 0) < 2) {
 			const spring = SPRING_K * (floatingDis - springToi) - vel[1] * SPRING_DAMPING;
 			body.applyImpulse([
 				0,
@@ -3141,7 +3216,27 @@ var CharacterController3D = class extends Node3D {
 		const pressedJump = this.readAction("jumpAction", () => input.justPressed(this.jumpAction), false, "The character will never jump.");
 		if (pressedJump) this.bufferLeft = Math.max(this.jumpBufferSeconds, 0);
 		else this.bufferLeft = Math.max(0, this.bufferLeft - dt);
-		if ((this.bufferLeft > 0 || pressedJump) && (footed || this.coyoteLeft > 0 || this.jumpsUsed < this.maxJumps)) {
+		const wantsJump = this.bufferLeft > 0 || pressedJump;
+		const wall = this.wallNormal;
+		if (wantsJump && !this.grounded && wall && this.wallJumpImpulse.some((v) => v !== 0)) {
+			const away = this.wallJumpImpulse[0] ?? 0;
+			const up = this.wallJumpImpulse[1] ?? 0;
+			body.linearVelocity = [
+				wall[0] * away,
+				up,
+				wall[2] * away
+			];
+			vel[0] = wall[0] * away;
+			vel[1] = up;
+			vel[2] = wall[2] * away;
+			this.grounded = false;
+			this.bufferLeft = 0;
+			this.coyoteLeft = 0;
+			this.rising = false;
+			this.jumping = true;
+			this.wallLockout = WALL_LOCKOUT_SECONDS;
+			this.emit("wallJumped", wall);
+		} else if (wantsJump && (footed || this.coyoteLeft > 0 || this.jumpsUsed < this.maxJumps)) {
 			const jumpVel = this.jumpVelocity * (1 + (this.sprintJumpMultiplier - 1) * intensity);
 			body.linearVelocity = [
 				vel[0],
@@ -3169,8 +3264,17 @@ var CharacterController3D = class extends Node3D {
 				this.rising = false;
 			}
 		}
+		const sliding = this.wallSlideSpeed > 0 && !footed && this.wallNormal !== null && (vel[1] ?? 0) < 0;
+		if (sliding && (vel[1] ?? 0) < -this.wallSlideSpeed) {
+			body.linearVelocity = [
+				vel[0],
+				-this.wallSlideSpeed,
+				vel[2]
+			];
+			vel[1] = -this.wallSlideSpeed;
+		}
 		if ((vel[1] ?? 0) < FALLING_MAX_VEL) body.gravityScale = 0;
-		else if ((vel[1] ?? 0) < 0 && !footed) body.gravityScale = this.fallGravity;
+		else if ((vel[1] ?? 0) < 0 && !footed) body.gravityScale = sliding ? 1 : this.fallGravity;
 		else body.gravityScale = 1;
 		if (this.view === "side" && Math.abs(pos[2]) > .01) body.position = [
 			body.position[0] ?? 0,
@@ -3973,7 +4077,10 @@ var Flowers3D = class extends Node3D {
 		height: { default: .45 },
 		clustering: { default: .6 },
 		sway: { default: .5 },
-		drape: { default: null },
+		drape: {
+			default: null,
+			kinds: ["null", "boolean"]
+		},
 		avoidWater: { default: true },
 		terrain: {
 			default: "",
@@ -5387,7 +5494,10 @@ var Foliage3D = class Foliage3D extends Node3D {
 		},
 		flowers: { default: 0 },
 		seed: { default: 1 },
-		drape: { default: null },
+		drape: {
+			default: null,
+			kinds: ["null", "boolean"]
+		},
 		avoidWater: { default: true },
 		terrain: {
 			default: "",
@@ -6308,6 +6418,98 @@ var OmniLight3D = class extends Node3D {
 		light.distance = this.range;
 	}
 };
+/**
+* A cone of light — a flashlight, a searchlight, a car's headlights, a stage
+* spot, a guard's torch.
+*
+* It AIMS down the node's local −Z, exactly like a camera: at rest it points
+* along −Z, `rotation: [-90, 0, 0]` points it at the floor, and a headlamp
+* mounted on a +Z-forward skin wants `rotation: [0, 180, 0]`. `coneDeg` is the
+* FULL angle of the cone (a "30° beam" is 30), converted to three's half-angle
+* here so nobody has to halve it by hand. `intensity` is in the same physical
+* units as `OmniLight3D` — tens, not ones. Shadows are a perspective map from
+* the cone's apex, so `castShadow` costs one extra render per frame per light.
+*/
+var SpotLight3D = class extends Node3D {
+	static typeName = "SpotLight3D";
+	static props = {
+		color: { default: "#ffffff" },
+		intensity: {
+			default: 1,
+			range: { min: 0 }
+		},
+		range: { default: 0 },
+		coneDeg: {
+			default: 60,
+			range: {
+				min: 0,
+				max: 180,
+				exclusiveMin: true,
+				exclusiveMax: true
+			}
+		},
+		penumbra: {
+			default: .3,
+			range: {
+				min: 0,
+				max: 1
+			}
+		},
+		castShadow: { default: false },
+		shadowMapSize: { default: 1024 },
+		lookAt: {
+			default: "",
+			nodePath: true
+		}
+	};
+	color = "#ffffff";
+	intensity = 1;
+	/** 0 = unlimited (three `distance` semantics). */
+	range = 0;
+	/** Full cone angle in degrees, exclusive of 0 and 180. */
+	coneDeg = 60;
+	/** 0 = hard edge, 1 = the whole cone is falloff. */
+	penumbra = .3;
+	castShadow = false;
+	shadowMapSize = 1024;
+	/**
+	* A node path to AIM at, every frame — the camera's prop, for the same
+	* reason: a searchlight that tracks the player, a stage spot on the boss.
+	* Aiming by hand is Euler arithmetic in XYZ order, where a yaw on the same
+	* node as a pitch swings the cone sideways (at yaw 180 a −55° pitch points
+	* UP). Empty = the authored `rotation` is the aim.
+	*/
+	lookAt = "";
+	warnedLookAt = "";
+	update(_dt) {
+		this.warnedLookAt = aimAt(this, this.warnedLookAt, "light");
+	}
+	_createObject3D() {
+		const light = new SpotLight();
+		light.add(light.target);
+		light.target.position.set(0, 0, -1);
+		return light;
+	}
+	_syncObject3D() {
+		super._syncObject3D();
+		const light = this._ensureObject3D();
+		light.color.set(this.color);
+		light.intensity = this.intensity;
+		light.distance = this.range;
+		light.angle = MathUtils.degToRad(this.coneDeg / 2);
+		light.penumbra = this.penumbra;
+		light.castShadow = this.castShadow;
+		if (this.castShadow) {
+			if (light.shadow.mapSize.x !== this.shadowMapSize) {
+				light.shadow.mapSize.set(this.shadowMapSize, this.shadowMapSize);
+				light.shadow.map?.dispose();
+				light.shadow.map = null;
+			}
+			light.shadow.bias = -2e-4;
+			light.shadow.normalBias = .002;
+		}
+	}
+};
 //#endregion
 //#region src/3d/nodes/loft-mesh-3d.ts
 /**
@@ -11564,7 +11766,10 @@ var Tree3D = class Tree3D extends Node3D {
 		leafFadeStart: { default: 0 },
 		leafFadeEnd: { default: 0 },
 		leafShadows: { default: true },
-		drape: { default: null },
+		drape: {
+			default: null,
+			kinds: ["null", "boolean"]
+		},
 		terrain: {
 			default: "",
 			nodePath: true
@@ -12908,9 +13113,29 @@ var VoxelGrid3D = class extends Node3D {
 		for (const [i, row] of self.voxels.entries()) if (!Array.isArray(row) || row.length < 3 || row.some((v) => typeof v !== "number")) throw new IncantoError("BAD_FORMAT", `VoxelGrid3D '${node.name}': voxels[${i}] must be [x, y, z, tile?] (numbers), got ${JSON.stringify(row)}.`);
 		if (self.voxels.length > MAX_INSTANCES) throw new IncantoError("BAD_FORMAT", `VoxelGrid3D '${node.name}': ${self.voxels.length} voxels exceeds the ${MAX_INSTANCES} this node can draw. Everything past the cap would still be SOLID and still be reported by tileAt(), and simply not appear. Split the world into several VoxelGrid3D nodes (one per chunk) and show the ones near the player.`);
 	}
-	/** JSON-authored blocks as [x, y, z, tile] tuples (generated terrains bake these). */
-	voxels = [];
-	appliedVoxels = null;
+	_voxels = [];
+	/**
+	* JSON-authored blocks as [x, y, z, tile] tuples (generated terrains bake
+	* these). The seed lands WHEN THE PROP DOES — at load, before the tree
+	* readies — not on the first `update()` as it used to: a sibling that
+	* builds chunk colliders from `blocks()` at ready (the minecraft template's
+	* Builder) saw an empty map and a baked hut was walked through, and the
+	* late `setBlocks` then WIPED whatever a generator had built at ready.
+	* Now a generator calling `setBlocks` after load is the author replacing
+	* the seed, never the seed replacing the author.
+	*/
+	get voxels() {
+		return this._voxels;
+	}
+	set voxels(rows) {
+		this._voxels = rows;
+		if (rows.length > 0) this.setBlocks(rows.map((t) => ({
+			x: t[0] ?? 0,
+			y: t[1] ?? 0,
+			z: t[2] ?? 0,
+			tile: t[3] ?? 0
+		})));
+	}
 	/** Said once per node: a runtime overflow must not spam a frame loop. */
 	reportedOverflow = false;
 	map = /* @__PURE__ */ new Map();
@@ -12969,15 +13194,6 @@ var VoxelGrid3D = class extends Node3D {
 		return this.mesh;
 	}
 	update() {
-		if (this.voxels.length > 0 && this.voxels !== this.appliedVoxels) {
-			this.appliedVoxels = this.voxels;
-			this.setBlocks(this.voxels.map((t) => ({
-				x: t[0] ?? 0,
-				y: t[1] ?? 0,
-				z: t[2] ?? 0,
-				tile: t[3] ?? 0
-			})));
-		}
 		if (this.map.size > MAX_INSTANCES && !this.reportedOverflow) {
 			this.reportedOverflow = true;
 			diagnose(this.tree?.engine ?? null, "error", `[incanto] VoxelGrid3D '${this.getPath()}' holds ${this.map.size} blocks and can draw ${MAX_INSTANCES}. The rest are still solid and still reported by tileAt(), and do not appear. Split the world across several VoxelGrid3D nodes.`);
@@ -13099,6 +13315,7 @@ function registerNodes3D() {
 	registerNode(Camera3D);
 	registerNode(DirectionalLight3D);
 	registerNode(OmniLight3D);
+	registerNode(SpotLight3D);
 	registerNode(StaticBody3D);
 	registerNode(RigidBody3D);
 	registerNode(Area3D);
@@ -13136,4 +13353,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, 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 };
+export { Billboard3D as A, cameraRelative as B, Flowers3D as C, Camera3D as D, CharacterController3D as E, Joint3D as F, acquireOwnTexture as G, movementState as H, InstancedMesh3D as I, acquireTexture as K, MeshInstance3D as L, DEFAULT_TERRAIN_TEXTURE_BASE as M, TERRAIN_THEMES as N, BoneLookAt3D as O, terrainThemeLayers as P, buildMeshGeometry as R, DENSITY_PRESETS as S, FLOWER_VARIETIES as T, rigPose as U, keyboardIntensity as V, TextureCache3D as W, LoftMesh3D as _, Tree3D as a, SpotLight3D as b, buildRiverRings as c, riverCarveChannels as d, riverStepFor as f, ModelInstance3D as g, Particles3D as h, VoxelGrid3D as i, Terrain3D as j, BoneAttachment3D 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, resolveFlowerDensity as w, Foliage3D as x, OmniLight3D as y, QUARTER_PITCH as z };