incanto 0.66.0 → 0.68.0

package/dist/{create-game-DYJCIzO0.js → create-game-DbWtVTxD.js}

@@ -1,14 +1,15 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { c as parseEnvironment3D, k as diagnose, n as loadScene, s as horizonColorFromSky, u as sunDirectionFromSky, z as registerBehavior } from "./loader-lQDCwNag.js";
-import { C as qualityRendering, _ as AudioPlayer, v as Engine, x as qualityCaps } from "./register-BmuqYTiY.js";
+import { c as parseEnvironment3D, k as diagnose, n as loadScene, s as horizonColorFromSky, u as sunDirectionFromSky, z as registerBehavior } from "./loader-BC4PNtJX.js";
+import { C as qualityRendering, _ as AudioPlayer, v as Engine, x as qualityCaps } from "./register-3ta-2Xig.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
-import { i as resolveRendering, n as attachTouchControls } from "./touch-DESwnpOc.js";
-import { a as openBundledEditor, c as claimCanvasGestures, i as devServerLibrary, l as audioErrors, n as pauseWhenHidden, o as poseFromRenderer, r as crossFade, s as wireDevChannel, t as teardown } from "./teardown-byR9USax.js";
+import { n as attachTouchControls } from "./touch-DEAmqGdf.js";
+import { n as withWebGLContext, r as resolveRendering } from "./webgl-unavailable-N9nQqesw.js";
+import { a as openBundledEditor, c as claimCanvasGestures, i as devServerLibrary, l as audioErrors, n as pauseWhenHidden, o as poseFromRenderer, r as crossFade, s as wireDevChannel, t as teardown } from "./teardown-D2NEmxPB.js";
 import { o as frameStats } from "./frame-report-BSMny7oe.js";
-import { J as createCausticsQuad, K as Node3D, U as PhysicsBody3D, n as registerGameplayBehaviors } from "./gameplay-D1RADWu3.js";
+import { J as createCausticsQuad, K as Node3D, U as PhysicsBody3D, n as registerGameplayBehaviors } from "./gameplay-DM1eu_cV.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-BlPsEmq6.js";
-import { n as enablePhysics3D } from "./physics-3d-BkHjwJgI.js";
+import { E as Camera3D, U as TextureCache3D, g as ModelInstance3D, n as registerNodes3D, t as resolveEnvironmentHdri, v as DirectionalLight3D } from "./environment-presets-CybQXNqS.js";
+import { n as enablePhysics3D } from "./physics-3d-bG3n70Ky.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";
@@ -27,6 +28,31 @@ import { Sky } from "three/examples/jsm/objects/Sky.js";
 */
 var AssetStore3D = class {
 	engine;
+	/**
+	* One geometry and one material per distinct SHAPE and per distinct look.
+	*
+	* `MeshInstance3D._createObject3D` used to `new BoxGeometry()` and
+	* `new MeshPhysicalMaterial()` for every node, even when byte-identical.
+	* Three identical nodes reported `geometry shared? false false / material
+	* shared? false false`, with distinct uuids. Measured at 3,200 units, all
+	* three runs at identical 3,209 draw calls / 1,741,932 triangles and an
+	* identical screenshot:
+	*
+	* ```
+	* per-node geometry + material   31.0 ms wall   (renderMs 27.3)
+	* share one geometry             27.0 ms
+	* + share two materials          15.4 ms        <- 2x the headroom
+	* ```
+	*
+	* 13.1 ms of that 26.5 ms cliff was GPU state churn from per-node objects,
+	* and none of it was visible headlessly: with no renderer `_syncObject3D`
+	* never runs, so the bench measured 55 ns/node instead of ~2,000.
+	*
+	* Renderer-scoped, deliberately — module-level state is the predecessor's
+	* fatal flaw and two games in one page must not share a cache.
+	*/
+	meshGeometries = /* @__PURE__ */ new Map();
+	meshMaterials = /* @__PURE__ */ new Map();
 	models = /* @__PURE__ */ new Map();
 	animations = /* @__PURE__ */ new Map();
 	modelKeys = /* @__PURE__ */ new Map();
@@ -61,22 +87,18 @@ var AssetStore3D = class {
 			url,
 			error
 		});
-		for (const [ref, url] of this.modelKeys) {
-			const entry = this.models.get(url);
-			if (entry?.error) out.push({
-				ref,
-				url,
-				error: String(entry.error)
-			});
-		}
-		for (const [ref, decl] of this.animationKeys) {
-			const entry = this.animations.get(decl.url);
-			if (entry?.error) out.push({
-				ref,
-				url: decl.url,
-				error: String(entry.error)
-			});
-		}
+		const modelRefs = new Map([...this.modelKeys].map(([ref, url]) => [url, ref]));
+		for (const [url, entry] of this.models) if (entry.error) out.push({
+			ref: modelRefs.get(url) ?? url,
+			url,
+			error: String(entry.error)
+		});
+		const clipRefs = new Map([...this.animationKeys].map(([ref, decl]) => [decl.url, ref]));
+		for (const [url, entry] of this.animations) if (entry.error) out.push({
+			ref: clipRefs.get(url) ?? url,
+			url,
+			error: String(entry.error)
+		});
 		return out;
 	}
 	/** Map a scene's `assets` header. */
@@ -253,10 +275,27 @@ function yieldToFrame(maxWaitMs = DEFAULT_MAX_WAIT_MS, raf = typeof requestAnima
 * - hard-validates the merged result NOW (in your call stack), so a bad patch
 *   throws where you wrote it — never inside the render loop
 */
-function setEnvironment3D(engine, patch) {
+/**
+* The environment stages a quality tier is allowed to touch.
+*
+* These are the ones `qualityEnvironment` names, and the ones that must snap
+* back to what the scene file says rather than accumulating.
+*/
+const TIER_KEYS = [
+	"shadows",
+	"bloom",
+	"post",
+	"clouds"
+];
+function setEnvironment3D(engine, patch, opts) {
 	const scene = engine.scene;
 	if (!scene) throw new IncantoError("BAD_FORMAT", "setEnvironment3D: the engine has no scene.");
 	const merged = { ...scene.environment ?? {} };
+	if (opts?.rebaseTierKeys) {
+		const authored = scene.source?.environment ?? {};
+		for (const key of TIER_KEYS) if (key in authored) merged[key] = authored[key];
+		else delete merged[key];
+	}
 	for (const [key, value] of Object.entries(patch)) if (value === null) delete merged[key];
 	else if (typeof value === "object" && !Array.isArray(value) && typeof merged[key] === "object" && merged[key] !== null && !Array.isArray(merged[key])) merged[key] = {
 		...merged[key],
@@ -266,6 +305,24 @@ function setEnvironment3D(engine, patch) {
 	parseEnvironment3D(merged);
 	scene.environment = merged;
 }
+/**
+* Apply a quality tier — the only caller that may RESET as well as patch.
+*
+* A tier is re-applied every time the player moves the slider, so it cannot
+* compose with what the last one left behind: `low` strips the author's bloom,
+* and `high` then has nothing to put back. This re-derives the four tier-owned
+* stages from the scene FILE first, so every tier is reversible, and so a stage
+* the author never wrote can never appear — the contract `settings.ts` states
+* and `incanto-performance.md` promises: *the tier can only take things away.*
+*
+* Measured before this, on a scene with no `bloom` and no `post` in its JSON:
+* `high` and `medium` both rendered five GL passes at 3.3 ms where `low`
+* rendered one at 1.24 ms — 62% of the frame on a chain the game never asked
+* for, and `environment.bloom` read back `{strength: 0.8, threshold: 1}`.
+*/
+function applyQualityTier3D(engine, patch) {
+	setEnvironment3D(engine, patch, { rebaseTierKeys: true });
+}
 //#endregion
 //#region src/3d/adaptive-resolution.ts
 const DEFAULTS = {
@@ -1430,11 +1487,11 @@ var Renderer3D = class {
 			pixelRatio: opts.pixelRatio,
 			preserveDrawingBuffer: opts.preserveDrawingBuffer
 		});
-		this.webgl = new WebGLRenderer({
+		this.webgl = withWebGLContext(() => new WebGLRenderer({
 			canvas: opts.canvas,
 			antialias: rendering.antialias,
 			preserveDrawingBuffer: rendering.preserveDrawingBuffer
-		});
+		}));
 		this.webgl.info.autoReset = false;
 		this.engine.picker = (x, y) => this.pick(x, y);
 		this.basePixelRatio = rendering.pixelRatio;
@@ -2180,6 +2237,7 @@ async function createGame3D(opts) {
 	const engine = new Engine({
 		seed: opts.seed,
 		fixedHz: opts.fixedHz,
+		...opts.settings ? { settings: opts.settings } : {},
 		...opts._scheduler ? { scheduler: opts._scheduler } : {}
 	});
 	const sourceJson = cloneSceneJson(opts.scene);
@@ -2294,7 +2352,7 @@ async function createGame3D(opts) {
 	cleanups.push(engine.settings.bindAudio(engine.audio));
 	cleanups.push(engine.settings.bindLocale(engine.locale));
 	cleanups.push(engine.settings.bindQuality((patch) => {
-		setEnvironment3D(engine, patch);
+		applyQualityTier3D(engine, patch);
 	}));
 	cleanups.push(engine.settings.bindFrameCap((fps) => {
 		engine.maxFps = fps;
@@ -2368,7 +2426,11 @@ async function createGame3D(opts) {
 	}
 	return {
 		engine,
-		scene,
+		get scene() {
+			const live = engine.scene;
+			if (!live) throw new IncantoError("TREE_VIOLATION", "game.scene: the engine has no scene.");
+			return live;
+		},
 		sourceJson,
 		renderer,
 		physics,
@@ -2454,4 +2516,4 @@ function wireAudioUnlock(engine, root, canvas) {
 	return detachAll;
 }
 //#endregion
-export { Environment3D as a, syncTree as i, create_game_exports as n, setEnvironment3D as o, Renderer3D as r, AssetStore3D as s, createGame3D as t };
+export { Environment3D as a, AssetStore3D as c, syncTree as i, create_game_exports as n, applyQualityTier3D as o, Renderer3D as r, setEnvironment3D as s, createGame3D as t };

package/dist/{create-game-Dd7H4bJV.js → create-game-IZIydDwI.js}

@@ -1,14 +1,15 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { d as computeViewport, f as resolveViewport, k as diagnose, n as loadScene, z as registerBehavior } from "./loader-lQDCwNag.js";
-import { _ as AudioPlayer, v as Engine } from "./register-BmuqYTiY.js";
+import { d as computeViewport, f as resolveViewport, k as diagnose, n as loadScene, z as registerBehavior } from "./loader-BC4PNtJX.js";
+import { _ as AudioPlayer, v as Engine } from "./register-3ta-2Xig.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
-import { i as resolveRendering, n as attachTouchControls } from "./touch-DESwnpOc.js";
-import { a as openBundledEditor, c as claimCanvasGestures, i as devServerLibrary, l as audioErrors, n as pauseWhenHidden, r as crossFade, s as wireDevChannel, t as teardown } from "./teardown-byR9USax.js";
+import { n as attachTouchControls } from "./touch-DEAmqGdf.js";
+import { n as withWebGLContext, r as resolveRendering } from "./webgl-unavailable-N9nQqesw.js";
+import { a as openBundledEditor, c as claimCanvasGestures, i as devServerLibrary, l as audioErrors, n as pauseWhenHidden, r as crossFade, s as wireDevChannel, t as teardown } from "./teardown-D2NEmxPB.js";
 import { o as frameStats } from "./frame-report-BSMny7oe.js";
-import { n as registerGameplayBehaviors } from "./gameplay-D1RADWu3.js";
-import { g as PhysicsBody2D, n as UILayer, t as registerNodes2D, u as Camera2D, y as Node2D } from "./register-D0CxCveZ.js";
+import { n as registerGameplayBehaviors } from "./gameplay-DM1eu_cV.js";
+import { g as PhysicsBody2D, n as UILayer, t as registerNodes2D, u as Camera2D, y as Node2D } from "./register-ibCjm-wH.js";
 import { t as debugSources } from "./debug-draw-BM3DsvtT.js";
-import { n as enablePhysics2D } from "./physics-2d-Cji5A6sX.js";
+import { n as enablePhysics2D } from "./physics-2d-B7Y6dPZO.js";
 import { Box3, BufferAttribute, BufferGeometry, Color, LineBasicMaterial, LineSegments, LinearFilter, NearestFilter, OrthographicCamera, Raycaster, SRGBColorSpace, Scene, TextureLoader, Vector2, Vector3, WebGLRenderer } from "three";
 //#region src/2d/assets.ts
 /**
@@ -444,11 +445,11 @@ var Renderer2D = class {
 			pixelRatio: 1,
 			preserveDrawingBuffer: false
 		}, globalThis.devicePixelRatio ?? 1, opts);
-		this.webgl = new WebGLRenderer({
+		this.webgl = withWebGLContext(() => new WebGLRenderer({
 			canvas: opts.canvas,
 			antialias: rendering.antialias,
 			preserveDrawingBuffer: rendering.preserveDrawingBuffer
-		});
+		}));
 		this.webgl.info.autoReset = false;
 		this.engine.picker = (x, y) => this.pick(x, y);
 		this.basePixelRatio = rendering.pixelRatio;
@@ -756,6 +757,7 @@ async function createGame2D(opts) {
 	const engine = new Engine({
 		seed: opts.seed,
 		fixedHz: opts.fixedHz,
+		...opts.settings ? { settings: opts.settings } : {},
 		...opts._scheduler ? { scheduler: opts._scheduler } : {}
 	});
 	const sourceJson = cloneSceneJson(opts.scene);
@@ -918,7 +920,11 @@ async function createGame2D(opts) {
 	}
 	return {
 		engine,
-		scene,
+		get scene() {
+			const live = engine.scene;
+			if (!live) throw new IncantoError("TREE_VIOLATION", "game.scene: the engine has no scene.");
+			return live;
+		},
 		sourceJson,
 		renderer,
 		physics,

package/dist/debug.d.ts

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

package/dist/debug.js

@@ -1,5 +1,6 @@
 import { t as jsonClone } from "./json-CwwhxQgb.js";
 import { s as mergeStaticProps } from "./registry-CF70EArN.js";
+import { r as capturePointer } from "./touch-DEAmqGdf.js";
 import { t as debugSources } from "./debug-draw-BM3DsvtT.js";
 //#region src/debug/capture.ts
 /**
@@ -369,7 +370,7 @@ var FloatingPanel = class {
 			active = e.pointerId;
 			lastX = e.clientX;
 			lastY = e.clientY;
-			grip.setPointerCapture?.(e.pointerId);
+			capturePointer(grip, e.pointerId);
 		});
 		grip.addEventListener("pointermove", (e) => {
 			if (e.pointerId !== active) return;
@@ -565,7 +566,7 @@ function openRegionSelect(opts) {
 		applyStyle(popup, { display: "none" });
 		applyStyle(box, { cursor: next === "move" ? "grabbing" : "crosshair" });
 		const id = event.pointerId;
-		if (id !== void 0) layer.setPointerCapture?.(id);
+		if (id !== void 0) capturePointer(layer, id);
 		render();
 	}
 	function render() {

package/dist/{duplicate-CqSAtdrh.js → duplicate-IWIqk0HJ.js}

@@ -1,4 +1,4 @@
-import { a as serializeNode, t as buildNodeJson } from "./loader-lQDCwNag.js";
+import { a as serializeNode, t as buildNodeJson } from "./loader-BC4PNtJX.js";
 //#region src/core/scene/duplicate.ts
 function stripUids(json) {
 	const { uid: _uid, ...rest } = json;

package/dist/{editor-switch-DAvWQeld.d.ts → editor-switch-CnIOiyNJ.d.ts}

@@ -1,4 +1,4 @@
-import { s as JsonObject } from "./schema-CFeioQRE.js";
+import { s as JsonObject } from "./schema-B6ugCV1Q.js";
 
 //#region src/core/diagnostics.d.ts
 /** The minimum an engine has to look like to receive a diagnostic. */

package/dist/editor.js

@@ -2380,7 +2380,8 @@ var Vn = [
 	"connections",
 	"input",
 	"multiplayer",
-	"strings"
+	"strings",
+	"environment"
 ];
 function Hn(e, t, n) {
 	e.appendChild(Tr("scene")), e.appendChild(Ar("name", String(t.working.name ?? ""), (e) => {
@@ -2397,19 +2398,25 @@ function Hn(e, t, n) {
 		t.mutate(() => {
 			t.working.dimension = r.value;
 		});
-	}), e.appendChild(B("dimension", r)), e.appendChild(Tr("physics", "physics"));
-	let i = (t.working.physics ?? {}).gravity ?? (t.working.dimension === "3d" ? [
+	}), e.appendChild(B("dimension", r));
+	let i = document.createElement("input");
+	i.type = "checkbox", i.checked = t.working.fragment === !0, i.addEventListener("change", () => {
+		t.mutate(() => {
+			i.checked ? t.working.fragment = !0 : delete t.working.fragment;
+		});
+	}), e.appendChild(B("fragment", i)), e.appendChild(Tr("physics", "physics"));
+	let a = (t.working.physics ?? {}).gravity ?? (t.working.dimension === "3d" ? [
 		0,
 		-9.81,
 		0
-	] : [0, 980]), a = t.working.dimension === "3d" ? [
+	] : [0, 980]), o = t.working.dimension === "3d" ? [
 		0,
 		-9.81,
 		0
 	] : [0, 980];
-	e.appendChild(Mr("gravity", i, (e) => {
+	e.appendChild(Mr("gravity", a, (e) => {
 		t.mutate(() => {
-			if (JSON.stringify(e) === JSON.stringify(a)) {
+			if (JSON.stringify(e) === JSON.stringify(o)) {
 				let e = { ...t.working.physics };
 				delete e.gravity, Object.keys(e).length === 0 ? delete t.working.physics : t.working.physics = e;
 			} else t.working.physics = {
@@ -7842,6 +7849,10 @@ var ss = class {
 			return !0;
 		}) === !0;
 	}
+	resume(e) {
+		let t = this.original;
+		this.reset(e), this.original = t;
+	}
 	reset(e) {
 		this.working = e, this.working.root && cs(this.working.root), this.original = JSON.stringify(this.working), this.undoStack = [], this.selection = [], this.emit();
 	}
@@ -9794,7 +9805,7 @@ async function xc(e = {}) {
 		let t = e.target.matches("input, textarea, select");
 		(e.metaKey || e.ctrlKey) && e.key === "z" ? (e.preventDefault(), u.undo()) : (e.metaKey || e.ctrlKey) && e.key === "s" ? (e.preventDefault(), p.disabled || p.click()) : !t && e.code === "KeyF" ? P.zoomToFit() : !t && (e.code === "Digit0" || e.code === "Numpad0") ? P.gameView() : !t && e.code === "KeyW" ? P.setMode("move") : !t && e.code === "KeyE" ? P.setMode("rotate") : !t && e.code === "KeyR" && P.setMode("scale");
 	};
-	return window.addEventListener("keydown", Me), n.push(() => window.removeEventListener("keydown", Me)), F(), e.camera && P.setEditCamera(e.camera.position, e.camera.target), kt.ready(C, w, o.version), {
+	return window.addEventListener("keydown", Me), n.push(() => window.removeEventListener("keydown", Me)), F(), e.scene && u.resume(e.scene), e.camera && P.setEditCamera(e.camera.position, e.camera.target), kt.ready(C, w, o.version), {
 		working: () => u.working,
 		camera: () => P.editCamera(),
 		showError: O,

package/dist/env.d.ts

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

package/dist/{environment-presets-BlPsEmq6.js → environment-presets-CybQXNqS.js}

@@ -1,11 +1,11 @@
-import { k as diagnose } from "./loader-lQDCwNag.js";
-import { L as translateOn, t as registerCoreNodes } from "./register-BmuqYTiY.js";
+import { k as diagnose } from "./loader-BC4PNtJX.js";
+import { L as translateOn, t as registerCoreNodes } from "./register-3ta-2Xig.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-CF70EArN.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-CY-mrr1L.js";
-import { B as rejectScale, G as StaticBody3D, H as CharacterBody3D, K as Node3D, L as Water3D, U as PhysicsBody3D, V as Area3D, W as RigidBody3D, X as colliderFootDrop, w as tolerateUnknownAction, z as WaterCutout3D } from "./gameplay-D1RADWu3.js";
+import { B as rejectScale, G as StaticBody3D, H as CharacterBody3D, I as worldPosition, K as Node3D, L as Water3D, U as PhysicsBody3D, V as Area3D, W as RigidBody3D, X as colliderFootDrop, w as tolerateUnknownAction, z as WaterCutout3D } from "./gameplay-DM1eu_cV.js";
 import { t as checkSheetGrid } from "./sheet-grid-BT6N_Bjs.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";
@@ -387,6 +387,10 @@ var MeshInstance3D = class extends Node3D {
 		validateMeshMaterial(node.material, node.name);
 	}
 	geometryKey = "";
+	materialKey = "";
+	/** True while this node is using a cache entry it must not dispose. */
+	sharedGeometry = false;
+	sharedMaterial = false;
 	textureKey = "";
 	loadedTextures = [];
 	_createObject3D() {
@@ -395,12 +399,48 @@ var MeshInstance3D = class extends Node3D {
 	_syncObject3D(alpha = 1, assets = null) {
 		super._syncObject3D(alpha, assets);
 		const m = this._ensureObject3D();
-		const key = `${this.mesh}:${JSON.stringify(this.size)}`;
+		const key = `${this.mesh}:${this.size.join(",")}`;
 		if (key !== this.geometryKey) {
-			m.geometry.dispose();
-			m.geometry = buildMeshGeometry(this.mesh, this.size);
+			if (!this.sharedGeometry) m.geometry.dispose();
+			const cached = assets?.meshGeometries.get(key);
+			if (cached) {
+				m.geometry = cached;
+				this.sharedGeometry = true;
+			} else {
+				const built = buildMeshGeometry(this.mesh, this.size);
+				m.geometry = built;
+				this.sharedGeometry = Boolean(assets);
+				assets?.meshGeometries.set(key, built);
+			}
 			this.geometryKey = key;
 		}
+		const look = JSON.stringify(this.material);
+		if (assets && look !== this.materialKey) {
+			const shared = assets.meshMaterials.get(look);
+			if (shared) {
+				if (!this.sharedMaterial) m.material.dispose();
+				m.material = shared;
+				this.sharedMaterial = true;
+				this.materialKey = look;
+				this.textureKey = "shared";
+				m.castShadow = this.castShadow;
+				m.receiveShadow = this.receiveShadow;
+				return;
+			}
+			if (this.sharedMaterial) {
+				m.material = new MeshPhysicalMaterial();
+				this.sharedMaterial = false;
+				this.textureKey = "";
+			}
+			this.materialKey = look;
+			const mine = m.material;
+			applyMeshMaterial(mine, this.material);
+			this.syncTextures(mine, assets);
+			assets.meshMaterials.set(look, mine);
+			m.castShadow = this.castShadow;
+			m.receiveShadow = this.receiveShadow;
+			return;
+		}
 		const mat = m.material;
 		applyMeshMaterial(mat, this.material);
 		this.syncTextures(mat, assets);
@@ -2674,6 +2714,7 @@ var CharacterController3D = class extends Node3D {
 		pitchMin: { default: -1.3 },
 		pitchMax: { default: 1.5 },
 		cameraCollision: { default: true },
+		platformCarry: { default: true },
 		turnSpeed: { default: 100 },
 		camLerp: { default: 25 },
 		moveAction: { default: "move" },
@@ -2726,6 +2767,43 @@ var CharacterController3D = class extends Node3D {
 	pitchMax = 1.5;
 	/** Spring-arm: pull the orbit camera in front of walls/ground instead of clipping. */
 	cameraCollision = true;
+	/**
+	* Ride whatever you are standing on.
+	*
+	* `false` restores the old behaviour: the controller steers toward a target
+	* velocity in WORLD space, so standing still on a moving floor brakes you off
+	* it. Turn it off for a conveyor you want to be scenery.
+	*/
+	platformCarry = true;
+	/** The node the ground probe hit last step, and where it was. */
+	carriedBy = null;
+	carriedFrom = [0, 0];
+	/**
+	* How fast the floor is moving, in world units per second.
+	*
+	* From the POSITION DELTA, not `linearVelocity`, because the documented way
+	* to author a platform is to move its `position` — a behavior, a `PathFollow`,
+	* an `Oscillate` — and that path calls `body.setTranslation`, which teleports
+	* and carries no momentum at all. The delta sees both kinds.
+	*
+	* Only while grounded on the SAME node two steps running: the first step on a
+	* new platform has nothing to compare against, and inventing a velocity there
+	* would fling the player on every step onto one.
+	*/
+	groundCarry(ground, dt) {
+		if (!this.platformCarry || !this.grounded || !ground || dt <= 0) {
+			this.carriedBy = ground;
+			if (ground) this.carriedFrom = groundXZ(ground);
+			return [0, 0];
+		}
+		const at = groundXZ(ground);
+		const same = this.carriedBy === ground;
+		const was = this.carriedFrom;
+		this.carriedBy = ground;
+		this.carriedFrom = at;
+		if (!same) return [0, 0];
+		return [(at[0] - was[0]) / dt, (at[1] - was[1]) / dt];
+	}
 	turnSpeed = 100;
 	/** Camera smoothing rate (1-exp(-rate·dt)); side view uses 5. */
 	camLerp = 25;
@@ -2790,6 +2868,8 @@ var CharacterController3D = class extends Node3D {
 		const rayLen = radius + 2;
 		const originY = pos[1] - halfHeight;
 		let toi = null;
+		/** What the probe landed on — the platform, when there is one. */
+		let ground = null;
 		for (const [ox, oz] of [
 			[0, 0],
 			[radius, 0],
@@ -2808,11 +2888,15 @@ var CharacterController3D = class extends Node3D {
 			], rayLen, body);
 			if (hit) {
 				const d = hit.distance;
-				toi = toi === null ? d : Math.min(toi, d);
+				if (toi === null || d < toi) {
+					toi = d;
+					ground = hit.node;
+				}
 				if (ox === 0 && oz === 0) break;
 			}
 		}
 		this.grounded = toi !== null && toi < floatingDis * 2;
+		const carry = this.groundCarry(ground, dt);
 		const footed = toi !== null && toi < floatingDis * 1.3 && (vel[1] ?? 0) <= .5;
 		let mx = 0;
 		let mz = 0;
@@ -2837,17 +2921,17 @@ var CharacterController3D = class extends Node3D {
 		const speedMultiplier = 1 + (this.sprintMultiplier - 1) * intensity;
 		const targetSpeed = moving ? this.maxSpeed * speedMultiplier : 0;
 		const control = this.grounded ? 1 : this.airControl;
-		const ax = (mx * targetSpeed - vel[0]) / ACC_DELTA_TIME * control;
-		const az = (mz * targetSpeed - vel[2]) / ACC_DELTA_TIME * control;
+		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([
 			ax * mass,
 			0,
 			az * mass
 		]);
 		if (!moving && this.grounded) body.applyImpulse([
-			-vel[0] * DRAG_DAMPING * mass,
+			-(vel[0] - carry[0]) * DRAG_DAMPING * mass,
 			0,
-			-vel[2] * DRAG_DAMPING * mass
+			-(vel[2] - carry[1]) * DRAG_DAMPING * mass
 		]);
 		let springToi = toi;
 		if (this.stepHeight > 0 && moving && toi !== null && !this.jumping && (vel[1] ?? 0) <= .5) {
@@ -3097,6 +3181,11 @@ function worldOf(node) {
 * coyote time incoherent (a held button would re-fire through the whole
 * window). Undeclared actions are tolerated, and reported once.
 */
+/** A node's world x/z — the platform may itself be parented to something. */
+function groundXZ(node) {
+	const world = worldPosition(node);
+	return [world[0] ?? 0, world[2] ?? 0];
+}
 //#endregion
 //#region src/3d/vegetation/grass-placement.ts
 const NOISE_SCALE = .15;

package/dist/{gameplay-D1RADWu3.js → gameplay-DM1eu_cV.js}

@@ -1,7 +1,7 @@
-import { O as Node, P as Behavior, _ as SaveSlots, k as diagnose, n as loadScene, w as effectiveOrder, z as registerBehavior } from "./loader-lQDCwNag.js";
+import { O as Node, P as Behavior, _ as SaveSlots, k as diagnose, n as loadScene, w as effectiveOrder, z as registerBehavior } from "./loader-BC4PNtJX.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { t as jsonClone } from "./json-CwwhxQgb.js";
-import { t as duplicateNode } from "./duplicate-CqSAtdrh.js";
+import { t as duplicateNode } from "./duplicate-IWIqk0HJ.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();
@@ -5016,12 +5016,20 @@ var Health = class extends Behavior {
 	* unlosable. Every checker was green on it, and `incanto-playtest` even
 	* reported `lost in 19/20` because a single `died` reads as a loss.
 	*
-	* Wire it where the life is spent:
+	* **Wire `reviveFull`, not this, to `lifeLost`.** `ScoreKeeper.loseLife()`
+	* emits `lifeLost` WITH the remaining life count, and this method's first
+	* parameter is the HP to come back at — so the documented recipe revived at
+	* 2 HP, then 1, then 0, and nothing warned (the wire-arity guard fires only
+	* when a handler is UNDER-fed, and `hp` is optional):
 	*
-	* ```json
-	* { "signal": "lifeLost", "from": "Score", "to": "Player", "handler": "revive" }
+	* ```
+	* death 1: lives=2  hp=2
+	* death 2: lives=1  hp=1
+	* death 3: lives=0  hp=0  dead=false   <- alive at zero HP
 	* ```
 	*
+	* Reach for `revive(hp)` when your game genuinely wants a partial comeback.
+	*
 	* A no-op on the living — reviving someone who never died would silently
 	* refill their health, which is a different feature and not this one.
 	*/
@@ -5033,6 +5041,21 @@ var Health = class extends Behavior {
 		this.invulnTimer = this.invulnerableFor;
 		this.emit("revived", this.current);
 	}
+	/**
+	* Bring a dead one back at FULL health — the handler a life-lost wire wants.
+	*
+	* It exists because `revive` takes an optional `hp` and `lifeLost` carries the
+	* life count, so wiring the two silently made "you have 2 lives left" mean
+	* "come back at 2 HP". This takes no arguments, so no signal's payload can
+	* ever change what it means.
+	*
+	* ```json
+	* { "signal": "lifeLost", "from": "Score", "to": "Player", "handler": "reviveFull" }
+	* ```
+	*/
+	reviveFull() {
+		this.revive();
+	}
 	/** Drop to 0 and die immediately (ignores i-frames). */
 	kill() {
 		if (this.dead) return;
@@ -6652,6 +6675,20 @@ var SavePoint = class extends Behavior {
 		this.slots ??= new SaveSlots(this.game);
 		return this.slots;
 	}
+	/**
+	* Has this run already said the saves are going nowhere?
+	*
+	* `saved(slot)` is the engine's own instrument for "it saved", and it fired
+	* identically in a private window where the write landed in a Map that dies
+	* with the tab. In-session everything looked healthy — the slot read back,
+	* `slotScene()` answered — and across the reload the score went 5 to 0 and
+	* `list()` went `["1"]` to `[]`, with `engine.log.entries().length = 0` and
+	* `stats().errors = 0` in every phase. Byte-identical to a healthy control.
+	*
+	* So it goes through `engine.log`, not just the console: that is what
+	* `incanto-logs` reads and what the `says` rung reports.
+	*/
+	warnedVolatile = false;
 	pendingRestore = false;
 	pendingProbe = false;
 	onReady() {
@@ -6711,6 +6748,10 @@ var SavePoint = class extends Behavior {
 			savedAt: Date.now(),
 			playtime: Math.round(this.elapsed)
 		});
+		if (!this.store().persistent && !this.warnedVolatile) {
+			this.warnedVolatile = true;
+			engine.log.warn(`SavePoint wrote slot '${this.slot}' to memory, not to disk — this browser refused localStorage (private window, storage disabled, or quota exhausted), so the run is lost when the page closes. \`SaveSlots.persistent\` is how a game asks before promising the player anything.`);
+		}
 		this.emit("saved", this.slot);
 	}
 	/**