incanto 0.65.0 → 0.67.0

package/dist/{create-game-W2xzTJhs.js → create-game-FAXdHta3.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-CgeR4ckF.js";
+import { c as parseEnvironment3D, k as diagnose, n as loadScene, s as horizonColorFromSky, u as sunDirectionFromSky, z as registerBehavior } from "./loader-KZESOZmE.js";
+import { C as qualityRendering, _ as AudioPlayer, v as Engine, x as qualityCaps } from "./register-Cs53CY7s.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-BordHL9o.js";
+import { n as attachTouchControls } from "./touch-DEAmqGdf.js";
+import { t as resolveRendering } from "./rendering-options-ByAdi8PF.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-LB9cTnXJ.js";
 import { o as frameStats } from "./frame-report-BSMny7oe.js";
-import { K as createCausticsQuad, V as PhysicsBody3D, W as Node3D, n as registerGameplayBehaviors } from "./gameplay-D-H986A4.js";
+import { J as createCausticsQuad, K as Node3D, U as PhysicsBody3D, n as registerGameplayBehaviors } from "./gameplay-CGSv-9XR.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-BvHs6HEk.js";
-import { n as enablePhysics3D } from "./physics-3d-DULB1lD1.js";
+import { E as Camera3D, U as TextureCache3D, g as ModelInstance3D, n as registerNodes3D, t as resolveEnvironmentHdri, v as DirectionalLight3D } from "./environment-presets-C-5g2pMh.js";
+import { n as enablePhysics3D } from "./physics-3d-i1IeAY0F.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();
@@ -253,10 +279,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 +309,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 = {
@@ -1967,6 +2028,67 @@ var Renderer3D = class {
 		};
 	}
 	/**
+	* The WORLD POINT under canvas pixel (sx, sy) — the other half of
+	* `screenFromWorld`, and the call `incanto-web-integration.md` has always
+	* offered "for taps and clicks".
+	*
+	* It did not exist in 3D. `Renderer2D` has had it since the beginning, the
+	* doc covers both runtimes, and an agent building a tower defense went looking
+	* for it and measured `typeof game.renderer.worldFromScreen === "undefined"`.
+	* `pick()` gives you the NODE under a pixel but never the POINT, so "put the
+	* thing where the player clicked on the ground" was not expressible and that
+	* game discretised its whole map into clickable pads instead.
+	*
+	* A pixel in 3D is a RAY, not a point, so this needs a surface to land on and
+	* takes the horizontal plane at `planeY` (default 0 — the ground). Returns
+	* null when the ray runs parallel to that plane or would only meet it behind
+	* the camera, which is what "the sky" looks like from here.
+	*
+	* For anything not flat — terrain, a hillside, a stack of crates — raycast
+	* physics instead: `rayFromScreen` gives you the origin and direction to feed
+	* `physics.castRay`.
+	*/
+	worldFromScreen(sx, sy, planeY = 0) {
+		const ray = this.rayFromScreen(sx, sy);
+		if (!ray) return null;
+		const dy = ray.dir[1];
+		if (Math.abs(dy) < 1e-6) return null;
+		const t = (planeY - ray.origin[1]) / dy;
+		if (t < 0) return null;
+		return {
+			x: ray.origin[0] + ray.dir[0] * t,
+			y: planeY,
+			z: ray.origin[2] + ray.dir[2] * t
+		};
+	}
+	/**
+	* The camera ray through canvas pixel (sx, sy) — origin and unit direction,
+	* ready for `physics.castRay(origin, dir, maxLen)`.
+	*
+	* This is the honest 3D answer to "where did the player click": on uneven
+	* ground the only thing that knows is the collision world.
+	*/
+	rayFromScreen(sx, sy) {
+		const cam = this.lastCamera;
+		if (!cam) return null;
+		pickNdc.set(sx / this.lastSize.w * 2 - 1, -(sy / this.lastSize.h * 2 - 1));
+		pickRaycaster.setFromCamera(pickNdc, cam);
+		const o = pickRaycaster.ray.origin;
+		const d = pickRaycaster.ray.direction;
+		return {
+			origin: [
+				o.x,
+				o.y,
+				o.z
+			],
+			dir: [
+				d.x,
+				d.y,
+				d.z
+			]
+		};
+	}
+	/**
 	* The node rendered under canvas pixel (sx, sy), or null — raycasts the last
 	* rendered camera into the scene and resolves the hit up to its `incantoNode`
 	* (every Node3D stamps that in `_ensureObject3D`). 3D depth-sorts, so the
@@ -2119,6 +2241,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);
@@ -2233,7 +2356,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;
@@ -2307,7 +2430,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,
@@ -2393,4 +2520,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/debug.d.ts

@@ -1,4 +1,4 @@
-import { Ft as LogLevel, T as RendererStats, b as Engine } from "./behavior-CmMuQ6CL.js";
+import { Ft as LogLevel, T as RendererStats, b as Engine } from "./behavior-ZnfzKDo3.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-B8QnX2-r.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-KZESOZmE.js";
 //#region src/core/scene/duplicate.ts
 function stripUids(json) {
 	const { uid: _uid, ...rest } = json;

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) => {
@@ -7842,6 +7843,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 +9799,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/{environment-presets-BvHs6HEk.js → environment-presets-C-5g2pMh.js}

@@ -1,11 +1,11 @@
-import { k as diagnose } from "./loader-lQDCwNag.js";
-import { L as translateOn, t as registerCoreNodes } from "./register-CgeR4ckF.js";
+import { k as diagnose } from "./loader-KZESOZmE.js";
+import { L as translateOn, t as registerCoreNodes } from "./register-Cs53CY7s.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 CharacterBody3D, F as Water3D, H as RigidBody3D, J as colliderFootDrop, L as WaterCutout3D, R as rejectScale, U as StaticBody3D, V as PhysicsBody3D, W as Node3D, w as tolerateUnknownAction, z as Area3D } from "./gameplay-D-H986A4.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-CGSv-9XR.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);
@@ -742,7 +782,8 @@ var Joint3D = class extends Node3D {
 		] },
 		length: { default: 0 },
 		stiffness: { default: 50 },
-		damping: { default: 5 }
+		damping: { default: 5 },
+		collide: { default: null }
 	};
 	type = "spherical";
 	target = "";
@@ -760,6 +801,31 @@ var Joint3D = class extends Node3D {
 	length = 0;
 	stiffness = 50;
 	damping = 5;
+	/**
+	* Do the two linked bodies still collide with EACH OTHER?
+	*
+	* `null` (default) decides from the joint type, because the two families want
+	* opposite answers:
+	*
+	* - **pivots** (`fixed`, `spherical`, `revolute`) → **off**. A hinge's bodies
+	*   overlap at the pivot by construction, so the contact solver fights the
+	*   joint and flings them. A puzzle builder's first hinge produced a bar that
+	*   spun chaotically forever and threw a 40 kg box thirty metres, and they
+	*   nearly filed "spherical joints inject energy":
+	*
+	*   ```
+	*   t=   0  Plank r=[0,0,0]      Box [ 0.00, 5.50,  2.40]
+	*   t=3000  Plank r=[-66,24,64]  Box [-29.70, 0.40, -4.91]
+	*   ```
+	*
+	* - **tethers** (`rope`, `spring`) → **on**. These anchor a thing to the world,
+	*   and the thing has to rest on what it is tethered to. Defaulting these off
+	*   drops a barrel roped to the floor straight through it — measured, in this
+	*   repo's own conformance room.
+	*
+	* Set `true`/`false` to say it outright.
+	*/
+	collide = null;
 	onEnterTree() {
 		if (!(this.parent instanceof PhysicsBody3D)) throw new IncantoError("TREE_VIOLATION", `Joint3D '${this.name}' must be a child of a physics body (its body A); parent is '${this.parent?.name ?? "none"}'.`);
 		if (this.target === "") throw new IncantoError("BAD_FORMAT", `Joint3D '${this.name}' needs a "target" node path to the body it links to.`);
@@ -2641,6 +2707,7 @@ var CharacterController3D = class extends Node3D {
 		/** Gravity multiplier while falling — >1 is the "snappy" arc. */
 		fallGravity: { default: 2.5 },
 		floatHeight: { default: .01 },
+		stepHeight: { default: .35 },
 		mouseLook: { default: true },
 		zoomMin: { default: 0 },
 		zoomMax: { default: 0 },
@@ -2673,6 +2740,25 @@ var CharacterController3D = class extends Node3D {
 	airControl = .2;
 	fallGravity = 2.5;
 	floatHeight = .01;
+	/**
+	* How high a step the PLAYER walks up without jumping (0 = off).
+	*
+	* The hover spring holds the capsule a fixed distance above whatever is
+	* DIRECTLY below it, so a vertical face stopped the player dead at about
+	* 0.2 m — while `CharacterBody3D.stepHeight` let every enemy climb 0.35 m.
+	* The docs said the player did not need this ("it floats over small ledges
+	* already"); it floats over 18 cm ones.
+	*
+	* This probes just AHEAD of the capsule in the direction of travel: if the
+	* ground there is higher, but by no more than `stepHeight`, the spring aims
+	* at THAT surface and lifts the character onto it. A wall taller than the
+	* step is not a step and still stops you.
+	*
+	* Do not reach for `floatHeight` instead. It does raise the character over
+	* ledges, and it silently makes it WEIGHTLESS: at `floatHeight: 0.28` a
+	* 200 kg character does not move a seesaw a 70 kg crate tips.
+	*/
+	stepHeight = .35;
 	mouseLook = true;
 	zoomMin = 0;
 	zoomMax = 0;
@@ -2803,8 +2889,26 @@ var CharacterController3D = class extends Node3D {
 			0,
 			-vel[2] * DRAG_DAMPING * mass
 		]);
-		if (toi !== null && toi < floatingDis * 2 && !this.jumping) {
-			const spring = SPRING_K * (floatingDis - toi) - vel[1] * SPRING_DAMPING;
+		let springToi = toi;
+		if (this.stepHeight > 0 && moving && toi !== null && !this.jumping && (vel[1] ?? 0) <= .5) {
+			const ahead = radius + .12;
+			const probeTop = originY + this.stepHeight + .05;
+			const stepHit = physics.castRay([
+				pos[0] + mx * ahead,
+				probeTop,
+				pos[2] + mz * ahead
+			], [
+				0,
+				-1,
+				0
+			], this.stepHeight + .05 + rayLen, body);
+			if (stepHit) {
+				const rise = probeTop - stepHit.distance - (originY - toi);
+				if (rise > .02 && rise <= this.stepHeight + .02) springToi = toi - rise;
+			}
+		}
+		if (springToi !== null && springToi < floatingDis * 2 && !this.jumping) {
+			const spring = SPRING_K * (floatingDis - springToi) - vel[1] * SPRING_DAMPING;
 			body.applyImpulse([
 				0,
 				spring * mass,