incanto 0.7.0 → 0.8.0

package/dist/{physics-2d-DmQ540uR.js → physics-2d-q2N362ph.js}

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
-import { _ as validateCollider2D, d as Area2D, f as CharacterBody2D, g as Node2D, m as RigidBody2D, p as PhysicsBody2D, u as Joint2D } from "./register-ClKnoILk.js";
+import { _ as RigidBody2D, b as validateCollider2D, g as PhysicsBody2D, h as CharacterBody2D, m as Area2D, p as Joint2D, y as Node2D } from "./register-Cqjxrfq0.js";
 import { n as registerDebugSource } from "./debug-draw-CZmOYjL2.js";
 //#region src/2d/physics/physics-2d.ts
 var physics_2d_exports = /* @__PURE__ */ __exportAll({
@@ -110,11 +110,27 @@ var Physics2D = class {
 		if (node.snapToGround && vy >= 0) this.kcc.enableSnapToGround(.05);
 		else this.kcc.disableSnapToGround();
 		this.kcc.setMaxSlopeClimbAngle(node.slopeLimitDeg * DEG);
+		let carryX = 0;
+		let carryY = 0;
+		if (e.ground && e.ground._physics === this) {
+			const [gx, gy] = worldPosition2D(e.ground);
+			carryX = gx - (e.groundX ?? gx);
+			carryY = gy - (e.groundY ?? gy);
+		} else e.ground = null;
 		const desired = {
-			x: (node.velocity[0] ?? 0) * this.lastDt / SCALE,
-			y: vy * this.lastDt / SCALE
+			x: ((node.velocity[0] ?? 0) * this.lastDt + carryX) / SCALE * 1,
+			y: (vy * this.lastDt + carryY) / SCALE * 1
 		};
-		this.kcc.computeColliderMovement(e.collider, desired, this.R.QueryFilterFlags.EXCLUDE_SENSORS);
+		const charBottomPx = e.body.translation().y * SCALE + charHalfHeight(node);
+		const predicate = (collider) => {
+			const other = this.byColliderHandle.get(collider.handle);
+			if (other && other !== node && other.collider.oneWay === true) {
+				if (vy < 0) return false;
+				if (charBottomPx > platformTopPx(other) + ONE_WAY_TOLERANCE_PX) return false;
+			}
+			return true;
+		};
+		this.kcc.computeColliderMovement(e.collider, desired, this.R.QueryFilterFlags.EXCLUDE_SENSORS, void 0, predicate);
 		const corrected = this.kcc.computedMovement();
 		const t = e.body.translation();
 		e.body.setNextKinematicTranslation({
@@ -122,6 +138,17 @@ var Physics2D = class {
 			y: t.y + corrected.y
 		});
 		node._grounded = this.kcc.computedGrounded();
+		if (node._grounded) {
+			const footX = (t.x + corrected.x) * SCALE;
+			const footY = (t.y + corrected.y) * SCALE + charHalfHeight(node) - 2;
+			const hit = this.castRay([footX, footY], [0, 1], 8, node);
+			if (hit?.node && !(hit.node instanceof CharacterBody2D)) {
+				e.ground = hit.node;
+				const [gx, gy] = worldPosition2D(hit.node);
+				e.groundX = gx;
+				e.groundY = gy;
+			} else e.ground = null;
+		} else e.ground = null;
 	}
 	/** Rapier debug segments, scaled back to pixels. Null while debugDraw is off. */
 	debugLines() {
@@ -327,6 +354,20 @@ function collectBodies(node, out) {
 * Composed world position (translation only — ancestor rotation/scale are NOT
 * supported for physics bodies; keep body ancestors untransformed or offset-only).
 */
+const ONE_WAY_TOLERANCE_PX = 4;
+/** Distance from a body's center to its lowest point, px. */
+function charHalfHeight(node) {
+	const c = node.collider;
+	if (c.shape === "rect") return (c.size?.[1] ?? 32) / 2;
+	if (c.shape === "capsule") return (c.height ?? 32) / 2 + (c.radius ?? 8);
+	return c.radius ?? 16;
+}
+/** The stand-on surface of a platform (y-down: its SMALLEST y), px. */
+function platformTopPx(node) {
+	const [, wy] = worldPosition2D(node);
+	const c = node.collider;
+	return wy - (c.shape === "rect" ? (c.size?.[1] ?? 32) / 2 : c.shape === "capsule" ? (c.height ?? 32) / 2 + (c.radius ?? 8) : c.radius ?? 16);
+}
 function worldPosition2D(node) {
 	let x = 0;
 	let y = 0;

package/dist/{physics-3d-CDjuhtt_.js → physics-3d-CvHr31d4.js}

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { n as registerDebugSource } from "./debug-draw-CZmOYjL2.js";
-import { D as CharacterBody3D, E as Area3D, M as validateCollider3D, O as PhysicsBody3D, T as Joint3D, j as Node3D, k as RigidBody3D, x as Terrain3D } from "./register-CscQqB7V.js";
+import { A as RigidBody3D, D as Area3D, E as Joint3D, M as Node3D, N as validateCollider3D, O as CharacterBody3D, S as Terrain3D, k as PhysicsBody3D } from "./register-Cbs7QxoV.js";
 import { Euler, Quaternion } from "three";
 //#region src/3d/physics/physics-3d.ts
 var physics_3d_exports = /* @__PURE__ */ __exportAll({

package/dist/react.d.ts

@@ -1,5 +1,5 @@
 import { c as JsonValue } from "./schema-CcoWb32N.js";
-import { n as BehaviorCtor, v as Engine, w as Scene } from "./behavior-e3kAmPGC.js";
+import { n as BehaviorCtor, v as Engine, w as Scene } from "./behavior-Bod1AyJS.js";
 import { CSSProperties, ReactNode } from "react";
 
 //#region src/react/index.d.ts

package/dist/react.js

@@ -156,7 +156,7 @@ function IncantoCanvas(props) {
 				pointer: latest.pointer,
 				...keyboard !== void 0 ? { keyboard } : {}
 			};
-			const next = await (_gameFactory ?? (mode === "3d" ? async (o) => (await import("./create-game-CEFoFN8d.js").then((n) => n.n)).createGame3D(o) : async (o) => (await import("./create-game-X5iRu6pf.js").then((n) => n.n)).createGame2D(o)))(opts);
+			const next = await (_gameFactory ?? (mode === "3d" ? async (o) => (await import("./create-game-66c4iYJE.js").then((n) => n.n)).createGame3D(o) : async (o) => (await import("./create-game-BNDSbhy-.js").then((n) => n.n)).createGame2D(o)))(opts);
 			if (disposed) {
 				next.dispose();
 				return;

package/dist/{register-CscQqB7V.js → register-Cbs7QxoV.js}

@@ -1,10 +1,10 @@
 import { f as Node } from "./loader-B4OEXDZ8.js";
-import { i as applyParticlePreset, o as effectiveOrder, r as PARTICLE_PRESET_NAMES, t as ParticleSim } from "./particle-sim-CrTE7c02.js";
+import { t as registerCoreNodes } from "./register-DRPIjrKG.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { t as Rng } from "./rng-DP-SR7eg.js";
-import { t as registerCoreNodes } from "./register-Dl_ixIJe.js";
 import { i as getNodeSchema, l as registerNode } from "./registry-BVJ2HbCn.js";
 import { t as createNoise2D } from "./noise-CGUMx44x.js";
+import { i as applyParticlePreset, o as effectiveOrder, r as PARTICLE_PRESET_NAMES, t as ParticleSim } from "./particle-sim-CyUU7HVU.js";
 import { n as splatWeights, t as buildHeightmap } from "./heightmap-CroQPEER.js";
 import { AdditiveBlending, AnimationClip, AnimationMixer, Box3, BoxGeometry, BufferAttribute, BufferGeometry, CanvasTexture, CapsuleGeometry, Color, ConeGeometry, CubeCamera, CylinderGeometry, DataTexture, DepthTexture, DirectionalLight, DoubleSide, Euler, FloatType, Frustum, Group, HalfFloatType, IcosahedronGeometry, ImageBitmapLoader, InstancedBufferAttribute, InstancedMesh, LinearFilter, LinearMipmapLinearFilter, LoopOnce, LoopRepeat, MathUtils, Matrix4, Mesh, MeshBasicMaterial, MeshDepthMaterial, MeshPhysicalMaterial, MeshStandardMaterial, NearestFilter, NoBlending, NormalBlending, Object3D, PerspectiveCamera, Plane, PlaneGeometry, PointLight, Points, PointsMaterial, Quaternion, QuaternionKeyframeTrack, RGBADepthPacking, RGBAFormat, RepeatWrapping, SRGBColorSpace, ShaderChunk, ShaderMaterial, Sphere, SphereGeometry, Texture, TextureLoader, UniformsLib, UniformsUtils, Vector2, Vector3, Vector4, VectorKeyframeTrack, WebGLCubeRenderTarget, WebGLRenderTarget } from "three";
 import { clone } from "three/addons/utils/SkeletonUtils.js";
@@ -1996,7 +1996,8 @@ var CharacterController3D = class extends Node3D {
 		jumpAction: { default: "jump" },
 		sprintAction: { default: "sprint" },
 		skinPath: { default: "../Skin" },
-		skinYawOffset: { default: 0 }
+		skinYawOffset: { default: 0 },
+		animations: { default: {} }
 	};
 	view = "free";
 	camDistance = 4;
@@ -2027,6 +2028,13 @@ var CharacterController3D = class extends Node3D {
 	* character facing away from the camera until it first moves).
 	*/
 	skinYawOffset = 0;
+	/**
+	* Movement-state → animation asset map, applied to the `skinPath` model
+	* directly — no CharacterAnimator behavior needed:
+	*   "animations": { "idle": "$idle", "run": "$run", "fastRun": "$sprint",
+	*                   "walk": "$walk", "airborne": "$jump" }
+	*/
+	animations = {};
 	/** Camera yaw/pitch in radians (mouse look mutates these). */
 	yaw = 0;
 	pitch = 0;
@@ -2147,6 +2155,11 @@ var CharacterController3D = class extends Node3D {
 		const next = movementState(this.grounded, moving ? intensity : 0);
 		if (next !== this.state) {
 			this.state = next;
+			const clip = this.animations[next];
+			if (clip && this.skinPath !== "") {
+				const skin = this.getNodeOrNull(this.skinPath);
+				if (skin && "animation" in skin) skin.animation = clip;
+			}
 			this.emit("movementStateChanged", next);
 		}
 		if (moving && this.skinPath !== "") {
@@ -6108,6 +6121,127 @@ function softSprite() {
 	return tex;
 }
 //#endregion
+//#region src/3d/nodes/trail-3d.ts
+const MAX_POINTS = 128;
+/**
+* A fading ribbon behind whatever this node is parented to — wingtip trails,
+* sword arcs, tyre streaks. Records the node's world position over `seconds`
+* and renders a camera-facing strip that tapers and fades to the tail.
+*
+*   { "name": "WingTrail", "type": "Trail3D",
+*     "props": { "width": 0.4, "color": "#dddddd", "seconds": 0.8 } }
+*
+* `emitting: false` stops laying new ribbon (the old tail still fades out).
+*/
+var Trail3D = class extends Node3D {
+	static typeName = "Trail3D";
+	static props = {
+		width: { default: .3 },
+		color: { default: "#ffffff" },
+		opacity: { default: .8 },
+		seconds: { default: .6 },
+		emitting: { default: true },
+		additive: { default: false },
+		/** Min world distance between recorded points (jitter filter). */
+		minDistance: { default: .05 }
+	};
+	width = .3;
+	color = "#ffffff";
+	opacity = .8;
+	seconds = .6;
+	emitting = true;
+	additive = false;
+	minDistance = .05;
+	points = [];
+	clock = 0;
+	mesh = null;
+	lastColor = "";
+	_createObject3D() {
+		const group = new Group();
+		const geometry = new BufferGeometry();
+		geometry.setAttribute("position", new BufferAttribute(new Float32Array(MAX_POINTS * 2 * 3), 3));
+		const material = new MeshBasicMaterial({
+			color: this.color,
+			transparent: true,
+			opacity: this.opacity,
+			side: DoubleSide,
+			depthWrite: false,
+			blending: this.additive ? AdditiveBlending : NormalBlending
+		});
+		this.mesh = new Mesh(geometry, material);
+		this.mesh.frustumCulled = false;
+		this.mesh.matrixAutoUpdate = false;
+		group.add(this.mesh);
+		return group;
+	}
+	update(dt) {
+		this.clock += dt;
+		while (this.points.length > 0 && this.clock - this.points[0].t > this.seconds) this.points.shift();
+	}
+	_onRender3D(ctx) {
+		const obj = this._ensureObject3D();
+		if (this.emitting) {
+			obj.getWorldPosition(worldScratch);
+			const last = this.points[this.points.length - 1];
+			if (!last || (last.x - worldScratch.x) ** 2 + (last.y - worldScratch.y) ** 2 + (last.z - worldScratch.z) ** 2 > this.minDistance * this.minDistance) {
+				this.points.push({
+					x: worldScratch.x,
+					y: worldScratch.y,
+					z: worldScratch.z,
+					t: this.clock
+				});
+				if (this.points.length > MAX_POINTS) this.points.shift();
+			}
+		}
+		const mesh = this.mesh;
+		if (!mesh) return;
+		mesh.matrixWorld.identity();
+		const mat = mesh.material;
+		if (this.color !== this.lastColor) {
+			this.lastColor = this.color;
+			mat.color = new Color(this.color);
+		}
+		mat.opacity = this.opacity;
+		const n = this.points.length;
+		const geometry = mesh.geometry;
+		const pos = geometry.getAttribute("position");
+		if (n < 2) {
+			geometry.setDrawRange(0, 0);
+			return;
+		}
+		for (let i = 0; i < n; i++) {
+			const p = this.points[i];
+			const q = this.points[Math.min(i + 1, n - 1)] ?? p;
+			dirScratch.set(q.x - p.x, q.y - p.y, q.z - p.z);
+			if (dirScratch.lengthSq() < 1e-8) dirScratch.set(0, 1, 0);
+			camScratch.set(ctx.camera.position.x - p.x, ctx.camera.position.y - p.y, ctx.camera.position.z - p.z);
+			sideScratch.crossVectors(dirScratch, camScratch).normalize();
+			const age = (this.clock - p.t) / this.seconds;
+			const half = this.width / 2 * Math.max(0, 1 - age);
+			pos.setXYZ(i * 2, p.x + sideScratch.x * half, p.y + sideScratch.y * half, p.z + sideScratch.z * half);
+			pos.setXYZ(i * 2 + 1, p.x - sideScratch.x * half, p.y - sideScratch.y * half, p.z - sideScratch.z * half);
+		}
+		pos.needsUpdate = true;
+		if (!geometry.index || geometry.index.count < (MAX_POINTS - 1) * 6) {
+			const indices = [];
+			for (let i = 0; i < MAX_POINTS - 1; i++) {
+				const a = i * 2;
+				indices.push(a, a + 1, a + 2, a + 1, a + 3, a + 2);
+			}
+			geometry.setIndex(indices);
+		}
+		geometry.setDrawRange(0, (n - 1) * 6);
+	}
+	/** Test hook: recorded point count. */
+	get pointCount() {
+		return this.points.length;
+	}
+};
+const worldScratch = new Vector3();
+const dirScratch = new Vector3();
+const camScratch = new Vector3();
+const sideScratch = new Vector3();
+//#endregion
 //#region src/3d/vegetation/eztree/options.ts
 /**
 * Predict the EXACT triangle count `buildEzTreeGeometry` will emit for these
@@ -11481,6 +11615,7 @@ function registerNodes3D() {
 	registerNode(CharacterController3D);
 	registerNode(VoxelGrid3D);
 	registerNode(Joint3D);
+	registerNode(Trail3D);
 	registerNode(Terrain3D);
 	registerNode(Water3D);
 	registerNode(Foliage3D);
@@ -11496,4 +11631,4 @@ function registerNodes3D() {
 	registerNode(CharacterBody3D);
 }
 //#endregion
-export { StaticBody3D as A, TERRAIN_THEMES as C, CharacterBody3D as D, Area3D as E, keyboardIntensity as F, movementState as I, rigPose as L, validateCollider3D as M, QUARTER_PITCH as N, PhysicsBody3D as O, cameraRelative as P, DEFAULT_TERRAIN_TEXTURE_BASE as S, Joint3D as T, FLOWER_VARIETIES as _, VoxelGrid3D as a, Billboard3D as b, ModelInstance3D as c, DirectionalLight3D as d, OmniLight3D as f, resolveFlowerDensity as g, Flowers3D as h, VOXEL_PALETTE as i, Node3D as j, RigidBody3D as k, LoftMesh3D as l, DENSITY_PRESETS as m, Water3D as n, Tree3D as o, Foliage3D as p, WATER_MAX_RIPPLES as r, Particles3D as s, registerNodes3D as t, MeshInstance3D as u, CharacterController3D as v, terrainThemeLayers as w, Terrain3D as x, Camera3D as y };
+export { RigidBody3D as A, DEFAULT_TERRAIN_TEXTURE_BASE as C, Area3D as D, Joint3D as E, cameraRelative as F, keyboardIntensity as I, movementState as L, Node3D as M, validateCollider3D as N, CharacterBody3D as O, QUARTER_PITCH as P, rigPose as R, Terrain3D as S, terrainThemeLayers as T, resolveFlowerDensity as _, VoxelGrid3D as a, Camera3D as b, Particles3D as c, MeshInstance3D as d, DirectionalLight3D as f, Flowers3D as g, DENSITY_PRESETS as h, VOXEL_PALETTE as i, StaticBody3D as j, PhysicsBody3D as k, ModelInstance3D as l, Foliage3D as m, Water3D as n, Tree3D as o, OmniLight3D as p, WATER_MAX_RIPPLES as r, Trail3D as s, registerNodes3D as t, LoftMesh3D as u, FLOWER_VARIETIES as v, TERRAIN_THEMES as w, Billboard3D as x, CharacterController3D as y };

package/dist/{register-ClKnoILk.js → register-Cqjxrfq0.js}

@@ -1,10 +1,10 @@
 import { f as Node } from "./loader-B4OEXDZ8.js";
-import { i as applyParticlePreset, o as effectiveOrder, r as PARTICLE_PRESET_NAMES, t as ParticleSim } from "./particle-sim-CrTE7c02.js";
+import { t as registerCoreNodes } from "./register-DRPIjrKG.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { t as Rng } from "./rng-DP-SR7eg.js";
-import { t as registerCoreNodes } from "./register-Dl_ixIJe.js";
 import { i as getNodeSchema, l as registerNode } from "./registry-BVJ2HbCn.js";
-import { AdditiveBlending, CanvasTexture, Color, DynamicDrawUsage, Group, InstancedMesh, MathUtils, Matrix4, Mesh, MeshBasicMaterial, NormalBlending, Object3D, PlaneGeometry } from "three";
+import { i as applyParticlePreset, o as effectiveOrder, r as PARTICLE_PRESET_NAMES, t as ParticleSim } from "./particle-sim-CyUU7HVU.js";
+import { AdditiveBlending, BufferAttribute, BufferGeometry, CanvasTexture, Color, DynamicDrawUsage, Group, InstancedMesh, MathUtils, Matrix4, Mesh, MeshBasicMaterial, NearestFilter, NormalBlending, Object3D, PlaneGeometry } from "three";
 //#region src/2d/physics/collider-validate.ts
 /**
 * Hard-validate a 2D collider prop — called at LOAD time (via the loader's
@@ -15,6 +15,7 @@ import { AdditiveBlending, CanvasTexture, Color, DynamicDrawUsage, Group, Instan
 function validateCollider2D(collider, nodeName) {
 	const shape = collider.shape;
 	if (shape === void 0) return;
+	if (collider.oneWay !== void 0 && typeof collider.oneWay !== "boolean") throw new IncantoError("BAD_FORMAT", `Collider on '${nodeName}': "oneWay" must be a boolean (platforms you jump up through), got ${JSON.stringify(collider.oneWay)}.`);
 	if (shape === "rect") {
 		const size = collider.size;
 		if (!Array.isArray(size) || size.length !== 2 || size.some((v) => typeof v !== "number")) throw new IncantoError("BAD_FORMAT", `Collider on '${nodeName}': rect needs "size": [width, height].`);
@@ -874,6 +875,254 @@ const colorScratchA = new Color();
 const colorScratchB = new Color();
 const colorScratchC = new Color();
 //#endregion
+//#region src/2d/tilemap-grid.ts
+/**
+* Normalize the `cells` prop into an index grid. Two author formats:
+* - string rows: `"." `/`" "` = empty, digits `0-9` = tile index, anything
+*   else must be in `legend` (char → index). Unknown chars HARD-fail.
+* - number rows: passed through (`-1` = empty).
+* Ragged rows are right-padded with empty.
+*/
+function parseCells(cells, legend) {
+	const rows = [];
+	let width = 0;
+	for (const row of cells) {
+		const out = [];
+		if (typeof row === "string") for (const ch of row) {
+			const mapped = legend[ch];
+			if (mapped !== void 0) out.push(mapped);
+			else if (ch === "." || ch === " ") out.push(-1);
+			else if (ch >= "0" && ch <= "9") out.push(ch.charCodeAt(0) - 48);
+			else throw new IncantoError("BAD_FORMAT", `TileMap2D: unknown tile char '${ch}' — add it to "legend" (char → tile index), or use '.'/' ' for empty and digits 0-9.`);
+		}
+		else for (const v of row) out.push(v);
+		width = Math.max(width, out.length);
+		rows.push(out);
+	}
+	for (const row of rows) while (row.length < width) row.push(-1);
+	return rows;
+}
+/**
+* Greedy rectangle merge over the solid cells: maximal horizontal runs,
+* extended downward while the identical run repeats. A platform level's
+* hundreds of solid tiles collapse to a handful of colliders.
+*/
+function mergeSolidRects(grid, solid) {
+	const h = grid.length;
+	const w = h > 0 ? grid[0].length : 0;
+	const used = grid.map((row) => row.map(() => false));
+	const isSolid = (x, y) => solid.has(grid[y][x]);
+	const rects = [];
+	for (let y = 0; y < h; y++) for (let x = 0; x < w; x++) {
+		if (!isSolid(x, y) || used[y][x]) continue;
+		let runW = 1;
+		while (x + runW < w && isSolid(x + runW, y) && !used[y][x + runW]) runW++;
+		let runH = 1;
+		grow: while (y + runH < h) {
+			for (let i = 0; i < runW; i++) if (!isSolid(x + i, y + runH) || used[y + runH][x + i]) break grow;
+			runH++;
+		}
+		for (let dy = 0; dy < runH; dy++) for (let i = 0; i < runW; i++) used[y + dy][x + i] = true;
+		rects.push({
+			x,
+			y,
+			w: runW,
+			h: runH
+		});
+	}
+	return rects;
+}
+//#endregion
+//#region src/2d/nodes/tile-map-2d.ts
+/**
+* A whole tile level as ONE node — grid render in a single draw call plus
+* greedy-merged static colliders. Author the level as rows of characters:
+*
+*   { "name": "Level", "type": "TileMap2D", "props": {
+*       "texture": "$tiles", "tileSize": 32,
+*       "cells": [
+*         "..................",
+*         "......111.........",
+*         "000000000000000000"
+*       ],
+*       "solid": [0, 1] } }
+*
+* `.` / space = empty, digits 0-9 = atlas tile index, other chars map through
+* `legend` (e.g. `{"G": 12}`). The atlas is read left-to-right, top-to-bottom
+* in `tileSize` squares. Tiles listed in `solid` become static colliders,
+* greedy-merged into a few rectangles (hundreds of cells → a handful of
+* bodies). Cell (0,0) renders with its TOP-LEFT on this node's origin.
+*/
+var TileMap2D = class extends Node2D {
+	static typeName = "TileMap2D";
+	static props = {
+		/** Atlas texture asset ref; tiles are tileSize×tileSize squares in it. */
+		texture: { default: "" },
+		tileSize: { default: 32 },
+		/** Atlas columns; 0 = derive from the texture width. */
+		columns: { default: 0 },
+		/** Rows of chars (or number arrays, -1 empty). */
+		cells: { default: [] },
+		/** char → atlas tile index for non-digit chars. */
+		legend: { default: {} },
+		/** Tile indices that get merged static colliders. */
+		solid: { default: [] },
+		opacity: { default: 1 }
+	};
+	texture = "";
+	tileSize = 32;
+	columns = 0;
+	_cells = [];
+	_legend = {};
+	_solid = [];
+	/** Rebuild flags — raised when the map-shaping props are REPLACED. */
+	geometryDirty = true;
+	collidersDirty = true;
+	/** Replace the whole array to change the map (mutations are not watched). */
+	get cells() {
+		return this._cells;
+	}
+	set cells(value) {
+		this._cells = value;
+		this.geometryDirty = true;
+		this.collidersDirty = true;
+	}
+	get legend() {
+		return this._legend;
+	}
+	set legend(value) {
+		this._legend = value;
+		this.geometryDirty = true;
+		this.collidersDirty = true;
+	}
+	get solid() {
+		return this._solid;
+	}
+	set solid(value) {
+		this._solid = value;
+		this.collidersDirty = true;
+	}
+	opacity = 1;
+	tileMesh = null;
+	builtColumns = 0;
+	builtRows = 0;
+	/** Loader hook: bad cells fail at LOAD (unknown chars), not at render. */
+	static validateJson(node) {
+		const map = node;
+		parseCells(map._cells, map._legend);
+	}
+	/** The parsed index grid (test/tooling hook). */
+	grid() {
+		return parseCells(this._cells, this._legend);
+	}
+	onReady() {
+		this.rebuildColliders();
+	}
+	update(_dt) {
+		if (this.collidersDirty) this.rebuildColliders();
+	}
+	rebuildColliders() {
+		this.collidersDirty = false;
+		for (const child of [...this.children]) if (child.name.startsWith("__tileSolid")) child.free();
+		if (this._solid.length === 0) return;
+		const ts = this.tileSize;
+		mergeSolidRects(this.grid(), new Set(this._solid)).forEach((r, i) => {
+			const body = new StaticBody2D(`__tileSolid${i}`);
+			body.position = [(r.x + r.w / 2) * ts, (r.y + r.h / 2) * ts];
+			body.collider = {
+				shape: "rect",
+				size: [r.w * ts, r.h * ts]
+			};
+			this.addChild(body);
+		});
+	}
+	/** @internal The drawable mesh (lazily created under the backing object). */
+	_mesh() {
+		if (!this.tileMesh) {
+			this.tileMesh = new Mesh(new BufferGeometry(), new MeshBasicMaterial({
+				transparent: true,
+				depthWrite: false
+			}));
+			this._ensureObject2D().add(this.tileMesh);
+		}
+		return this.tileMesh;
+	}
+	_syncObject2D(assets) {
+		super._syncObject2D(assets);
+		const mesh = this._mesh();
+		const mat = mesh.material;
+		if (!this.texture || !assets) {
+			mesh.visible = false;
+			return;
+		}
+		const texture = assets.getTexture(this.texture);
+		const image = texture.image;
+		if (!image?.width || !image.height) {
+			mesh.visible = false;
+			return;
+		}
+		mesh.visible = this.opacity > 0;
+		mesh.renderOrder = this.effectiveRenderOrder;
+		mat.opacity = this.opacity;
+		if (mat.map !== texture) {
+			texture.magFilter = NearestFilter;
+			mat.map = texture;
+			mat.needsUpdate = true;
+			this.geometryDirty = true;
+		}
+		const columns = this.columns > 0 ? this.columns : Math.max(1, Math.floor(image.width / this.tileSize));
+		const atlasRows = Math.max(1, Math.floor(image.height / this.tileSize));
+		if (columns !== this.builtColumns || atlasRows !== this.builtRows) this.geometryDirty = true;
+		if (!this.geometryDirty) return;
+		this.geometryDirty = false;
+		this.builtColumns = columns;
+		this.builtRows = atlasRows;
+		this.buildGeometry(mesh.geometry, columns, atlasRows);
+	}
+	/** One quad per visible tile, atlas UVs — a single draw call for the level. */
+	buildGeometry(geometry, columns, atlasRows) {
+		const grid = this.grid();
+		const ts = this.tileSize;
+		const positions = [];
+		const uvs = [];
+		const indices = [];
+		for (let y = 0; y < grid.length; y++) {
+			const row = grid[y];
+			for (let x = 0; x < row.length; x++) {
+				const tile = row[x];
+				if (tile < 0) continue;
+				const x0 = x * ts;
+				const x1 = x0 + ts;
+				const y0 = -(y * ts);
+				const y1 = -((y + 1) * ts);
+				const base = positions.length / 3;
+				positions.push(x0, y0, 0, x1, y0, 0, x1, y1, 0, x0, y1, 0);
+				const col = tile % columns;
+				const rowIdx = Math.floor(tile / columns);
+				const u0 = col / columns;
+				const u1 = (col + 1) / columns;
+				const v0 = 1 - rowIdx / atlasRows;
+				const v1 = 1 - (rowIdx + 1) / atlasRows;
+				uvs.push(u0, v0, u1, v0, u1, v1, u0, v1);
+				indices.push(base, base + 2, base + 1, base, base + 3, base + 2);
+			}
+		}
+		geometry.setAttribute("position", new BufferAttribute(new Float32Array(positions), 3));
+		geometry.setAttribute("uv", new BufferAttribute(new Float32Array(uvs), 2));
+		geometry.setIndex(indices);
+		geometry.computeBoundingSphere();
+	}
+	/** Test hook: rendered tile count (quads in the built geometry). */
+	get renderedTileCount() {
+		const pos = this.tileMesh?.geometry.getAttribute("position");
+		return pos ? pos.count / 4 : 0;
+	}
+	free() {
+		this.tileMesh?.geometry.dispose();
+		super.free();
+	}
+};
+//#endregion
 //#region src/2d/nodes/ui-layer.ts
 const ANCHORS = [
 	"top-left",
@@ -949,6 +1198,7 @@ function registerNodes2D() {
 	registerNode(CharacterBody2D);
 	registerNode(CharacterController2D);
 	registerNode(Joint2D);
+	registerNode(TileMap2D);
 }
 //#endregion
-export { validateCollider2D as _, ColorRect2D as a, AnimatedSprite2D as c, Area2D as d, CharacterBody2D as f, Node2D as g, StaticBody2D as h, Label as i, Sprite2D as l, RigidBody2D as m, UILayer as n, CharacterController2D as o, PhysicsBody2D as p, Particles2D as r, Camera2D as s, registerNodes2D as t, Joint2D as u };
+export { RigidBody2D as _, parseCells as a, validateCollider2D as b, ColorRect2D as c, AnimatedSprite2D as d, Sprite2D as f, PhysicsBody2D as g, CharacterBody2D as h, mergeSolidRects as i, CharacterController2D as l, Area2D as m, UILayer as n, Particles2D as o, Joint2D as p, TileMap2D as r, Label as s, registerNodes2D as t, Camera2D as u, StaticBody2D as v, Node2D as y };

package/dist/{register-C35HDZpm.js → register-CxmuI9FL.js}

@@ -1,6 +1,6 @@
 import { f as Node, t as buildNodeJson, y as Signal } from "./loader-B4OEXDZ8.js";
+import { t as registerCoreNodes } from "./register-DRPIjrKG.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
-import { t as registerCoreNodes } from "./register-Dl_ixIJe.js";
 import { n as jsonEquals, t as jsonClone } from "./json-BLk7H2Qa.js";
 import { l as registerNode } from "./registry-BVJ2HbCn.js";
 //#region src/net/network-manager.ts