incanto 0.74.0 → 0.76.0

package/dist/{replay-B6BbgGM_.js → replay-DrqQ6dZj.js}

@@ -1,5 +1,5 @@
-import { L as handlerShadowWarnings, R as sceneDimension, V as HudWidgetBase, Z as nodeRefWarnings } from "./save-slots-CEUGeLuB.js";
-import { N as translationKey } from "./register-CjociOtt.js";
+import { H as handlerShadowWarnings, K as HudWidgetBase, U as sceneDimension, nt as nodeRefWarnings } from "./pose-ByFB_J3O.js";
+import { F as translationKey } from "./register-B768Qedj.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { u as getNodeType } from "./touch-CioTZB-y.js";
 //#region src/core/light-types.ts
@@ -120,10 +120,12 @@ const WORLD_QUERY_TYPES = new Set([
 * the two lists disagree again.
 */
 const SAVEABLE_SCRIPTS = new Set([
+	"Checkpoint",
 	"Collector",
 	"Currency",
 	"DayNight",
 	"Health",
+	"Phases",
 	"SavePoint",
 	"ScoreKeeper",
 	"WaveSpawner"
@@ -227,10 +229,10 @@ function auditScene(scene, opts = {}) {
 			}[type];
 			if (art && ((props[art[0]] ?? "") === "" || props[art[0]] === void 0)) warnings.push(`${path}: ${type} has no "${art[0]}", so nothing of it is drawn — it loads, validates and takes up a row in the tree, and puts no pixel on screen. Give it ${art[1]}.`);
 			if (type === "InstancedMesh3D") {
-				if ((Array.isArray(props.transforms) ? props.transforms : []).length === 0) warnings.push(`${path}: InstancedMesh3D has no "transforms", so it draws nothing — a scatter with no rows. Add [x, y, z, yawDeg?, scale?] rows, or fill them from a behaviour and say so.`);
+				if ((Array.isArray(props.transforms) ? props.transforms : []).length === 0) warnings.push(`${path}: InstancedMesh3D has no "transforms", so it draws nothing — a scatter with no rows. Add [x, y, z, yawDeg?, scale?] rows. If a behaviour fills them (an aiming arc, a wave of markers), author it "visible": false — the node is genuinely invisible until the rows arrive, and the behaviour that writes them turns it on.`);
 			}
 		}
-		if (type === "CharacterController3D") cameraDrivers.push(path);
+		if (type === "CharacterController3D" && props.enabled !== false && props.camera !== "none") cameraDrivers.push(path);
 		if (type === "Terrain3D") terrains.push(path);
 		if (DRAPERS.has(type) && (props.terrain ?? "") === "") autoDrapers.push(path);
 		if (LIGHT_TYPES.has(type)) lights += 1;
@@ -278,9 +280,12 @@ function auditScene(scene, opts = {}) {
 		what: rootTransform
 	} : null, root.script?.name === "PrefabShelf");
 	if (needUid.length > 0) warnings.push(`these carry state a save keeps and have no uid to key it under, so the save comes back EMPTY and the load reports no problem: ${needUid.join(", ")}. Give each one a "uid" from newUid().`);
+	warnings.push(...propsThatAreOverwritten(root));
+	const floorless = terrainsWithNoFloor(root);
+	if (floorless.length > 0 && floorless.length === terrains.length) warnings.push(`${floorless.join(", ")}: nothing in this scene can be stood on — no Terrain3D is under a body whose collider is \`{ "shape": "heightfield" }\`, so the ground is DRAWN and the player falls through it. Wrap it: a \`StaticBody3D\` with that collider, the Terrain3D as its child. (A terrain that is only scenery is fine beside one that is solid.)`);
 	if (terrains.length > 1 && autoDrapers.length > 0) warnings.push(`${autoDrapers.join(", ")}: this scene has ${terrains.length} Terrain3Ds (${terrains.join(", ")}) and these do not say which one they grow on — with no \`terrain\` path they take the FIRST one in the tree, so the rest drape to the wrong height with nothing reported. Name it: "terrain": "%Name".`);
 	if (cameraDrivers.length > 1) warnings.push(`${cameraDrivers.join(", ")}: ${cameraDrivers.length} CharacterController3Ds drive the SAME camera (each one finds the first \`current\` camera in the tree), so the last of them wins every frame and the others have no view. For local co-op give each player a panel with \`createSplitScreen\` (one engine each); otherwise only one node may carry a controller.`);
-	if (cameraDrivers.length > 0 && followedCameras.length > 0) warnings.push(`${followedCameras.join(", ")}: a FollowCamera writes this camera's position every frame, and so does the CharacterController3D at ${cameraDrivers.join(", ")} — the controller owns the camera in every view it has. Drop one of them: use the controller's own \`view\`/\`camDistance\`, or take the controller off the camera duty.`);
+	if (cameraDrivers.length > 0 && followedCameras.length > 0) warnings.push(`${followedCameras.join(", ")}: a FollowCamera writes this camera's position every frame, and so does the CharacterController3D at ${cameraDrivers.join(", ")} — the controller owns the camera in every view it has. Drop one of them: use the controller's own \`view\`/\`camDistance\`, or set the controller's \`"camera": "none"\` and let the scene own its camera.`);
 	if (cameras > 0 && currentCameras === 0) warnings.push("no camera has \"current\": true — the screen renders from a default view, probably not what you framed.");
 	if (currentCameras > 1) warnings.push(`${currentCameras} cameras claim "current": true — only the first found wins.`);
 	const isFragment = opts.instanced === true || scene.fragment === true;
@@ -349,6 +354,91 @@ function groupsInScene(root) {
 	walk(root);
 	return out;
 }
+/**
+* Terrains nothing can stand on.
+*
+* A `Terrain3D` DRAWS a landscape; it is solid only when it sits under a body
+* whose collider is `{ "shape": "heightfield" }` — colliders are props on
+* bodies in this engine, never implicit. Get that wrong and the terrain looks
+* perfect, `heightAt` answers correctly, `snapToGround` places everything on it,
+* and the player falls straight through in silence.
+*
+* Measured while building a river-valley game from the packed tarball: the
+* walker fell from 22 m past 0 with no error anywhere, every frame, while the
+* terrain under it reported 22.00. The shipped templates all get it right,
+* which is exactly why nobody had hit it.
+*/
+/**
+* Props a node WRITES OVER, per type.
+*
+* `Weather3D` extends `Particles3D` and tunes the whole emitter from `kind` and
+* `intensity`; `Flock3D` extends `InstancedMesh3D` and rewrites `transforms`
+* every frame from the boids. Both INHERIT those props, so the loader accepts
+* them, the editor offers them, and `bun run unused-props` lists them as things
+* no scene sets — which reads as an invitation. An author who writes
+* `"rate": 400` on a Weather3D gets exactly nothing.
+*
+* Hard-coded, like `SAVEABLE_SCRIPTS` and `DRAPERS` above: the audit reads JSON
+* and has no registry, and a node that overwrites an inherited prop is a rare
+* enough thing to name.
+*/
+const OVERWRITTEN = {
+	Weather3D: {
+		props: [
+			"rate",
+			"burst",
+			"lifetime",
+			"speed",
+			"directionDeg",
+			"spreadDeg",
+			"gravity",
+			"drag",
+			"sizeStart",
+			"sizeEnd",
+			"colorStart",
+			"colorEnd",
+			"alphaStart",
+			"alphaEnd",
+			"blend",
+			"emitBox",
+			"drift",
+			"worldSpace",
+			"maxParticles",
+			"camera"
+		],
+		instead: "`kind`, `intensity`, `radius`, `height`, `wind` and `follow` are what steer it"
+	},
+	Flock3D: {
+		props: ["transforms"],
+		instead: "`count`, `radius`, `height`, `speed`, `turn`, `separation`, `sight`, `alignment`, `cohesion` and `follow` are what steer it"
+	}
+};
+/** Nodes that author a prop their own type will discard. */
+function propsThatAreOverwritten(root) {
+	const out = [];
+	const walk = (node, path) => {
+		const rule = OVERWRITTEN[node.type ?? ""];
+		if (rule) {
+			const written = rule.props.filter((p) => node.props?.[p] !== void 0);
+			if (written.length > 0) out.push(`${path}: ${node.type} overwrites ${written.map((p) => `\`${p}\``).join(", ")} on its first frame — the value here is discarded. ${rule.instead}.`);
+		}
+		for (const child of node.children ?? []) walk(child, `${path}/${child.name ?? "?"}`);
+	};
+	walk(root, `/${root.name ?? "?"}`);
+	return out;
+}
+function terrainsWithNoFloor(root) {
+	const out = [];
+	const walk = (node, path, host) => {
+		const type = node.type ?? "";
+		const collider = (node.props ?? {}).collider;
+		const mine = collider && collider.shape === "heightfield" ? path : host;
+		if (type === "Terrain3D" && mine === null) out.push(path);
+		for (const child of node.children ?? []) walk(child, `${path}/${child.name ?? "?"}`, mine);
+	};
+	walk(root, `/${root.name ?? "?"}`, null);
+	return out;
+}
 function hurtableGroups(root) {
 	const out = /* @__PURE__ */ new Set();
 	const hasHealth = (node) => node.script?.name === "Health" || (node.children ?? []).some(hasHealth);
@@ -598,19 +688,43 @@ function startRecording(engine) {
 		originalStep();
 	};
 	let stopped = false;
-	return { stop() {
-		if (!stopped) {
-			stopped = true;
-			for (const [name, fn] of originals) input[name] = fn;
-			engineAny.tick = originalTick;
-			engineAny.step = originalStep;
+	return {
+		stop() {
+			if (!stopped) {
+				stopped = true;
+				for (const [name, fn] of originals) input[name] = fn;
+				engineAny.tick = originalTick;
+				engineAny.step = originalStep;
+			}
+			return {
+				replay: 1,
+				ticks,
+				events
+			};
+		},
+		take() {
+			return {
+				replay: 1,
+				ticks: [...ticks],
+				events: events.map((e) => [...e])
+			};
+		},
+		rewind(n) {
+			const keep = Math.max(0, Math.min(Math.floor(n), ticks.length));
+			ticks.length = keep;
+			let write = 0;
+			for (const event of events) if (event[0] < keep) {
+				events[write] = event;
+				write += 1;
+			}
+			events.length = write;
+			return {
+				replay: 1,
+				ticks: [...ticks],
+				events: events.map((e) => [...e])
+			};
 		}
-		return {
-			replay: 1,
-			ticks,
-			events
-		};
-	} };
+	};
 }
 /**
 * Drive a fresh engine through a recording: for each recorded tick, feed
@@ -620,7 +734,8 @@ function startRecording(engine) {
 function replay(engine, recording, opts) {
 	const input = engine.input;
 	let cursor = 0;
-	for (let i = 0; i < recording.ticks.length; i++) {
+	const last = Number.isFinite(opts?.until) ? Math.max(0, Math.min(Math.floor(opts?.until), recording.ticks.length)) : recording.ticks.length;
+	for (let i = 0; i < last; i++) {
 		while (cursor < recording.events.length && recording.events[cursor][0] === i) {
 			const [, method, ...args] = recording.events[cursor];
 			const fn = input[method];

package/dist/{replay-wZK5Ok5c.d.ts → replay-W5nCw_cU.d.ts}

@@ -1,5 +1,5 @@
-import { b as Engine } from "./behavior-J1cmVah0.js";
-import { s as JsonObject } from "./rng-Bb-IutXB.js";
+import { b as Engine } from "./behavior-B_245qRy.js";
+import { s as JsonObject } from "./rng-BsXZg3D6.js";
 
 //#region src/core/audit.d.ts
 /** Human-readable warnings (empty = clean). Pure JSON walk, no registry. */
@@ -136,6 +136,24 @@ interface ReplayJson {
 interface Recorder {
   /** Detach the taps and return the recording. */
   stop(): ReplayJson;
+  /**
+  * The tape SO FAR, without ending it.
+  *
+  * `stop()` was the only way to read a recording, so reading it ended it — and
+  * a game that rewinds and keeps playing had to start a second recording whose
+  * tick indices restart at zero, then stitch the two together itself.
+  */
+  take(): ReplayJson;
+  /**
+  * Drop everything after tick `n` and keep recording from there — the tape
+  * half of a REWIND.
+  *
+  * Returns the recording up to the cut, which is what `replay()` re-runs into
+  * a freshly loaded scene: deterministic replay reproduces the world bit for
+  * bit, physics included, so a rewind needs no snapshot at all. Clamped to the
+  * tape's own ends.
+  */
+  rewind(n: number): ReplayJson;
 }
 /**
 * Tap the engine's input entry points and tick clock. Recording starts at
@@ -149,6 +167,7 @@ declare function startRecording(engine: Engine): Recorder;
 */
 declare function replay(engine: Engine, recording: ReplayJson, opts?: {
   onTick?: (index: number) => void;
+  until?: number;
 }): void;
 //#endregion
 export { startRecording as a, IncantoErrorDetails as c, replay as i, auditScene as l, ReplayEvent as n, IncantoError as o, ReplayJson as r, IncantoErrorCode as s, Recorder as t, instancedScenes as u };

package/dist/{rng-Bb-IutXB.d.ts → rng-BsXZg3D6.d.ts}

@@ -110,6 +110,13 @@ interface ConnectionJson {
     group?: string;
     tag?: JsonObject;
   };
+  /**
+  * Arguments to call the handler with, INSTEAD of whatever the signal emitted
+  * — `Function.bind` for a wire. `phase2 → Banner.show` with
+  * `["ENRAGED", { "color": "#ff5c5c" }]` is a line in the scene file rather
+  * than a two-line behaviour whose whole job is one constant.
+  */
+  args?: JsonValue[];
 }
 //#endregion
 //#region src/core/rng.d.ts

package/dist/{split-screen-BxZ5rBe7.js → split-screen-B-dIcQsQ.js}

@@ -1,6 +1,6 @@
 import { n as jsonEquals, t as jsonClone } from "./json-CfTjpvW8.js";
-import { J as Node, Y as diagnose, ct as Signal, d as rebuildOptions, h as loadScene, l as markCloned, m as buildSceneSubtree, p as stripUids, u as markTemplateName } from "./save-slots-CEUGeLuB.js";
-import { t as registerCoreNodes, v as Engine } from "./register-CjociOtt.js";
+import { $ as Node, _ as stripUids, b as loadScene, et as diagnose, h as rebuildOptions, m as markTemplateName, p as markCloned, pt as Signal, y as buildSceneSubtree } from "./pose-ByFB_J3O.js";
+import { b as Engine, t as registerCoreNodes } from "./register-B768Qedj.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { p as registerNode } from "./touch-CioTZB-y.js";
 //#region src/net/loopback.ts
@@ -1150,7 +1150,7 @@ function applySyncPatch(root, patch, setProp, onMissingNode) {
 	}
 }
 async function createDefaultTransport(config, diagnostics) {
-	const { createAgent8Server } = await import("./agent8-CHTT4unP.js").then((n) => n.t);
+	const { createAgent8Server } = await import("./agent8-B-bh3n0X.js").then((n) => n.t);
 	return createAgent8Server(config, diagnostics);
 }
 //#endregion
@@ -1217,8 +1217,10 @@ var NetworkSpawner = class extends Node {
 		const entries = this.currentEntries(manager);
 		for (const [key, state] of Object.entries(entries)) {
 			let instance = this.spawned.get(key);
+			const patch = this.patchOf(state);
 			if (!instance) {
 				if (this.failedKeys.has(key)) continue;
+				if (!patch) continue;
 				try {
 					const json = manager.resolveScene(this.scene);
 					instance = buildSceneSubtree({
@@ -1236,7 +1238,6 @@ var NetworkSpawner = class extends Node {
 				this.spawned.set(key, instance);
 				this.emit("spawned", instance, key);
 			}
-			const patch = this.patchOf(state);
 			if (patch) applySyncPatch(instance, patch, (target, prop, value) => this.setProp(target, prop, value), (missing) => this.report(`'${missing}' names a node this scene does not have`));
 		}
 		for (const [key, instance] of [...this.spawned.entries()]) if (!(key in entries)) {
@@ -1283,6 +1284,7 @@ var NetworkSpawner = class extends Node {
 	}
 	setProp(target, prop, value) {
 		if (this.interpolate && prop === "position" && Array.isArray(value)) {
+			if (!this.positionTargets.has(target)) target.position = [...value];
 			this.positionTargets.set(target, value);
 			return;
 		}
@@ -1384,7 +1386,10 @@ async function createSplitScreen(opts) {
 	for (let i = 0; i < accounts.length; i++) {
 		const account = accounts[i];
 		const engine = new Engine(opts.seed !== void 0 ? { seed: opts.seed + i } : {});
-		engine.setScene(loadScene(jsonClone(opts.scene), opts.load));
+		engine.setScene(loadScene(jsonClone(opts.scene), {
+			...opts.load,
+			engine
+		}));
 		const manager = await NetworkManager.create(engine, {
 			transport: server.createClient(account),
 			...opts.room !== void 0 || i > 0 ? { room: opts.room ?? players[0].manager.roomId } : {}

package/dist/{split-screen-D6sx8z3Z.d.ts → split-screen-CiLJf2-C.d.ts}

@@ -1,7 +1,7 @@
-import { Lt as Signal, b as Engine, jt as Node } from "./behavior-J1cmVah0.js";
+import { Lt as Signal, b as Engine, jt as Node } from "./behavior-B_245qRy.js";
 import { t as DiagnosticSink } from "./diagnostics-Cu85N3tL.js";
-import { a as SceneJson, c as JsonValue, s as JsonObject } from "./rng-Bb-IutXB.js";
-import { t as LoadSceneOptions } from "./loader-BAeWMYfF.js";
+import { a as SceneJson, c as JsonValue, s as JsonObject } from "./rng-BsXZg3D6.js";
+import { t as LoadSceneOptions } from "./loader-CbkVdXL8.js";
 
 //#region src/net/types.d.ts
 type Unsubscribe = () => void;

package/dist/{sprite-animation-Bz3DHD_4.js → sprite-animation-SQa5gIu2.js}

@@ -266,12 +266,14 @@ var ParticleSim = class {
 		const speed = c.speed[0] + this.rng.next() * (c.speed[1] - c.speed[0]);
 		const zTilt = c.spreadZ ? (this.rng.next() - .5) * (c.spreadDeg * Math.PI / 180) : 0;
 		const planar = Math.cos(zTilt);
-		d[base + 0] = 0;
-		d[base + 1] = 0;
-		d[base + 2] = 0;
-		d[base + 3] = Math.cos(angle) * speed * planar;
-		d[base + 4] = Math.sin(angle) * speed * planar;
-		d[base + 5] = Math.sin(zTilt) * speed;
+		const box = c.emitBox;
+		d[base + 0] = box ? (this.rng.next() * 2 - 1) * box[0] : 0;
+		d[base + 1] = box ? (this.rng.next() * 2 - 1) * box[1] : 0;
+		d[base + 2] = box ? (this.rng.next() * 2 - 1) * box[2] : 0;
+		const drift = c.drift;
+		d[base + 3] = Math.cos(angle) * speed * planar + (drift?.[0] ?? 0);
+		d[base + 4] = Math.sin(angle) * speed * planar + (drift?.[1] ?? 0);
+		d[base + 5] = Math.sin(zTilt) * speed + (drift?.[2] ?? 0);
 		d[base + 6] = 0;
 		d[base + 7] = c.lifetime[0] + this.rng.next() * (c.lifetime[1] - c.lifetime[0]);
 		d[base + 8] = this.rng.next();

package/dist/{src-CqtvYtSN.js → src-D823V07k.js}

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