incanto 0.60.0 → 0.62.0

package/dist/{loader-TvkRFbyL.d.ts → loader-DolLJWJn.d.ts}

@@ -1,4 +1,4 @@
-import { P as Scene, b as Engine } from "./behavior-DWKTUzKI.js";
+import { P as Scene, b as Engine } from "./behavior-DsgayMsH.js";
 import { i as SceneJson } from "./schema-CFeioQRE.js";
 
 //#region src/core/scene/loader.d.ts
@@ -6,6 +6,18 @@ interface LoadSceneOptions {
   /** Resolve a sub-scene path referenced by `{instance: '<path>'}`. */
   resolveScene?: (path: string) => SceneJson;
   /**
+  * Assets declared ELSEWHERE in the project, for `$ref` validation.
+  *
+  * A scene a `NetworkSpawner` spawns resolves its refs against the HOST's
+  * `assets{}` — `remote-player.scene.json` names `$characters/base` and
+  * declares nothing itself, which is correct and cannot be checked from that
+  * one file. A tool with the whole project passes the union in; loading the
+  * file alone still fails, because alone it really cannot resolve.
+  */
+  declaredAssets?: Record<string, {
+    type?: unknown;
+  }>;
+  /**
   * Tool/preview mode (the editor's ▶ play strips behaviors — and their
   * `static signals` with them): declare each connection's signal on its
   * from-node instead of hard-failing with UNKNOWN_SIGNAL. Games should

package/dist/net.d.ts

@@ -1,5 +1,5 @@
-import { At as Node, d as PropSchema } from "./behavior-DWKTUzKI.js";
-import { a as NetworkManagerOptions, c as LocalGameServer, d as ServerClass, f as createLocalGameServer, g as Unsubscribe, h as NetworkTransport, i as NetworkManager, l as LocalGameServerOptions, m as LoopbackTransport, n as SplitScreenPlayer, o as applySyncPatch, p as LoopbackHub, r as createSplitScreen, s as CollectionOptions, t as SplitScreenOptions, u as LocalGameServerTransport } from "./split-screen-BQ3tAsf-.js";
+import { d as PropSchema, jt as Node } from "./behavior-DsgayMsH.js";
+import { a as NetworkManagerOptions, c as LocalGameServer, d as ServerClass, f as createLocalGameServer, g as Unsubscribe, h as NetworkTransport, i as NetworkManager, l as LocalGameServerOptions, m as LoopbackTransport, n as SplitScreenPlayer, o as applySyncPatch, p as LoopbackHub, r as createSplitScreen, s as CollectionOptions, t as SplitScreenOptions, u as LocalGameServerTransport } from "./split-screen-D7OopelJ.js";
 
 //#region src/net/agent8.d.ts
 /**

package/dist/net.js

@@ -1,3 +1,3 @@
 import { n as createAgent8Server } from "./agent8-CvsfVskX.js";
-import { a as NetworkManager, d as createLocalGameServer, f as LoopbackHub, l as LocalGameServer, n as registerNodesNet, o as applySyncPatch, p as LoopbackTransport, r as NetworkSpawner, t as createSplitScreen, u as LocalGameServerTransport } from "./split-screen-CL5Yvxse.js";
+import { a as NetworkManager, d as createLocalGameServer, f as LoopbackHub, l as LocalGameServer, n as registerNodesNet, o as applySyncPatch, p as LoopbackTransport, r as NetworkSpawner, t as createSplitScreen, u as LocalGameServerTransport } from "./split-screen-CBM9wcMX.js";
 export { LocalGameServer, LocalGameServerTransport, LoopbackHub, LoopbackTransport, NetworkManager, NetworkSpawner, applySyncPatch, createAgent8Server, createLocalGameServer, createSplitScreen, registerNodesNet };

package/dist/pathfinding-_fGrCFmH.d.ts

@@ -0,0 +1,28 @@
+//#region src/core/pathfinding.d.ts
+/**
+* Grid A* — the pathfinding every top-down/RPG/tower-defense asks for and
+* agents keep re-inventing badly. Pure and dimension-free: cells in, cells
+* out; the caller maps cells to world units (px, meters, tiles).
+*/
+interface PathGrid {
+  width: number;
+  height: number;
+  /** True = impassable. Out-of-bounds is always solid. */
+  solid(x: number, y: number): boolean;
+}
+interface FindPathOptions {
+  /** Allow diagonal steps (blocked from cutting corners). Default true. */
+  diagonal?: boolean;
+  /** Abort guard for huge/impossible searches. Default 20000 nodes. */
+  maxExpansions?: number;
+}
+/**
+* A* from `from` to `to` (inclusive cell coords). Returns the cell path
+* INCLUDING both endpoints, or null when unreachable. Straight steps cost
+* 1, diagonals √2; the heuristic is octile (admissible for both modes).
+*/
+declare function findPath(grid: PathGrid, from: [number, number], to: [number, number], opts?: FindPathOptions): [number, number][] | null;
+/** Build a PathGrid from row-strings ('#' = solid) — tests and tile games. */
+declare function gridFromRows(rows: readonly string[]): PathGrid;
+//#endregion
+export { gridFromRows as i, PathGrid as n, findPath as r, FindPathOptions as t };

package/dist/{physics-2d-DqdVp1bt.js → physics-2d-BXmu2i7W.js}

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { w as diagnose } from "./loader-D8n7TU8W.js";
+import { k as diagnose } from "./loader-DEe272nY.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
-import { _ as RigidBody2D, b as validateCollider2D, g as PhysicsBody2D, h as CharacterBody2D, m as Area2D, p as Joint2D, y as Node2D } from "./register-BSu2dWGC.js";
+import { _ as RigidBody2D, b as validateCollider2D, g as PhysicsBody2D, h as CharacterBody2D, m as Area2D, p as Joint2D, y as Node2D } from "./register-CNh4FlbD.js";
 import { n as registerDebugSource } from "./debug-draw-BM3DsvtT.js";
 import { t as withoutRapierInitNoise } from "./quiet-rapier-BAJ4K94N.js";
 //#region src/2d/physics/physics-2d.ts
@@ -100,7 +100,10 @@ var Physics2D = class {
 				node.position = [t.x * SCALE - ox, t.y * SCALE - oy];
 			}
 			if (node instanceof RigidBody2D) {
-				if (!node.fixedRotation) node.rotation = e.body.rotation() / DEG;
+				if (!node.fixedRotation) {
+					node.rotation = e.body.rotation() / DEG;
+					e.lastRot = node.rotation;
+				}
 				const lv = e.body.linvel();
 				node.linearVelocity = [lv.x * SCALE, lv.y * SCALE];
 				e.lastVX = node.linearVelocity[0] ?? 0;
@@ -428,6 +431,7 @@ var Physics2D = class {
 				collider,
 				lastX: wx,
 				lastY: wy,
+				lastRot: node.rotation,
 				lastVX: 0,
 				lastVY: 0
 			};
@@ -456,6 +460,10 @@ var Physics2D = class {
 			e.lastX = px;
 			e.lastY = py;
 		}
+		if (node.rotation !== e.lastRot) {
+			e.body.setRotation(node.rotation * DEG, true);
+			e.lastRot = node.rotation;
+		}
 		if (node instanceof RigidBody2D) {
 			const vx = node.linearVelocity[0] ?? 0;
 			const vy = node.linearVelocity[1] ?? 0;

package/dist/{physics-3d-BP0DZb_1.js → physics-3d-ClxP6Uv7.js}

@@ -1,10 +1,10 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { w as diagnose } from "./loader-D8n7TU8W.js";
+import { k as diagnose } from "./loader-DEe272nY.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
-import { H as validateCollider3D, I as Area3D, L as CharacterBody3D, R as PhysicsBody3D, V as Node3D, z as RigidBody3D } from "./gameplay-BBEjPFsR.js";
+import { B as CharacterBody3D, G as validateCollider3D, H as RigidBody3D, V as PhysicsBody3D, W as Node3D, z as Area3D } from "./gameplay-CaHqDiQD.js";
 import { n as registerDebugSource } from "./debug-draw-BM3DsvtT.js";
 import { t as withoutRapierInitNoise } from "./quiet-rapier-BAJ4K94N.js";
-import { A as Terrain3D, F as InstancedMesh3D, L as buildMeshGeometry, P as Joint3D } from "./environment-presets-8cjF3t6w.js";
+import { A as Terrain3D, F as InstancedMesh3D, L as buildMeshGeometry, P as Joint3D } from "./environment-presets-BAWeOeqf.js";
 import { Euler, Matrix4, Quaternion, Vector3 } from "three";
 //#region src/3d/physics/collider-lines.ts
 /**
@@ -318,6 +318,9 @@ var Physics3D = class {
 					rot[0] = eulerScratch.x / DEG;
 					rot[1] = eulerScratch.y / DEG;
 					rot[2] = eulerScratch.z / DEG;
+					e.lastRot[0] = rot[0];
+					e.lastRot[1] = rot[1];
+					e.lastRot[2] = rot[2];
 				}
 				const lv = e.body.linvel();
 				const nv = node.linearVelocity;
@@ -644,6 +647,11 @@ var Physics3D = class {
 					wy,
 					wz
 				],
+				lastRot: [
+					node.rotation[0] ?? 0,
+					node.rotation[1] ?? 0,
+					node.rotation[2] ?? 0
+				],
 				lastV: [
 					0,
 					0,
@@ -679,6 +687,21 @@ var Physics3D = class {
 			e.last[2] = p[2];
 			node._interpPrev = node._interpCurr = null;
 		}
+		const rx = node.rotation[0] ?? 0;
+		const ry = node.rotation[1] ?? 0;
+		const rz = node.rotation[2] ?? 0;
+		if (rx !== e.lastRot[0] || ry !== e.lastRot[1] || rz !== e.lastRot[2]) {
+			quatScratch.setFromEuler(eulerScratch.set(rx * DEG, ry * DEG, rz * DEG, "XYZ"));
+			e.body.setRotation({
+				x: quatScratch.x,
+				y: quatScratch.y,
+				z: quatScratch.z,
+				w: quatScratch.w
+			}, true);
+			e.lastRot[0] = rx;
+			e.lastRot[1] = ry;
+			e.lastRot[2] = rz;
+		}
 		if (node instanceof RigidBody3D) {
 			const v = [
 				node.linearVelocity[0] ?? 0,
@@ -854,15 +877,20 @@ function collectBodies(node, out) {
 * Convex, always: a hull is a few planes to test against, where a triangle
 * mesh is a tree of them, and nothing scattered across a map needs concavity.
 */
-function meshShapedDesc(R, kind, size, scale) {
-	const x = (size[0] ?? 1) * scale;
-	const y = (size[1] ?? 1) * scale;
-	const z = (size[2] ?? 1) * scale;
+function meshShapedDesc(R, kind, size, scale, who) {
+	const sx = scale[0] ?? 1;
+	const sy = scale[1] ?? 1;
+	const sz = scale[2] ?? 1;
+	const x = (size[0] ?? 1) * sx;
+	const y = (size[1] ?? 1) * sy;
+	const z = (size[2] ?? 1) * sz;
+	const radial = Math.max(Math.abs(sx), Math.abs(sz));
+	if (who && kind !== "box" && kind !== "plane" && Math.abs(sx - sz) > 1e-6) console.warn(`[incanto] Collider on '${who}': shape 'auto' fits a ${kind} to a mesh scaled [${sx}, ${sy}, ${sz}]. A ${kind} has one radius, so the widest of x/z (${radial}) is used. Use a box, or scale x and z the same.`);
 	switch (kind) {
 		case "box": return R.ColliderDesc.cuboid(x / 2, y / 2, z / 2);
-		case "sphere": return R.ColliderDesc.ball(x);
-		case "capsule": return R.ColliderDesc.capsule(y / 2, x);
-		case "cylinder": return R.ColliderDesc.cylinder(y / 2, x);
+		case "sphere": return R.ColliderDesc.ball((size[0] ?? 1) * Math.max(radial, Math.abs(sy)));
+		case "capsule": return R.ColliderDesc.capsule(y / 2, (size[0] ?? 1) * radial);
+		case "cylinder": return R.ColliderDesc.cylinder(y / 2, (size[0] ?? 1) * radial);
 		case "plane": return R.ColliderDesc.cuboid(x / 2, .01, z / 2);
 		default: return R.ColliderDesc.convexHull(meshPoints(kind, [
 			x,
@@ -937,18 +965,79 @@ const TRIMESH_BUDGET = 2e4;
 function isStaticShape(node) {
 	return !(node instanceof RigidBody3D || node instanceof CharacterBody3D);
 }
-/** Every mesh a body carries, itself first — `auto` shapes itself on one. */
-function meshesUnder(node, out, models) {
+/**
+* Every mesh a body carries, itself first — `auto` shapes itself on one.
+*
+* The transform chain is composed on the way down because `auto` used to drop
+* it: the collector returned `{name, mesh, size}` and the `auto` branch built
+* the shape at the BODY's origin, at the authored size, scale hard-coded to 1.
+* The renderer applies all three every frame (`Node3D._syncObject3D`), so
+* measured on a body whose plank child sits at `[0, 3, 0]`:
+*
+* ```
+* drawn plank top y = 3.2
+* ray straight down from y=10 : HIT Deck — surface at y=0.200
+* ```
+*
+* and on one scaled 4×:
+*
+* ```
+* drawn crate top y = 2.0
+* ray straight down : HIT Crate — surface at y=0.500
+* ray down inside the DRAWN 4 m crate : MISS
+* ```
+*
+* You walk through the deck you can see and land on an invisible slab at ground
+* level — from the shape whose entire promise is that "a blocker can never
+* disagree with what the player sees". The sibling paths in this same file were
+* already right: `syncScatters` honours every scatter row's translation, yaw
+* and scale, and `modelTriangles` bakes a GLB's world matrices. Only the
+* primitive-mesh branch dropped it.
+*/
+function meshesUnder(node, out, models, at = [
+	0,
+	0,
+	0
+], turn = [
+	0,
+	0,
+	0
+], scale = [
+	1,
+	1,
+	1
+]) {
 	if (isMountedModel(node)) models.push(node);
 	else {
 		const self = node;
 		if (typeof self.mesh === "string" && Array.isArray(self.size)) out.push({
 			name: node.name,
 			mesh: self.mesh,
-			size: self.size
+			size: self.size,
+			at: [...at],
+			turn: [...turn],
+			scale: [...scale]
 		});
 	}
-	for (const child of node.children) meshesUnder(child, out, models);
+	for (const child of node.children) {
+		const t = child;
+		const p = Array.isArray(t.position) ? t.position : [];
+		const r = Array.isArray(t.rotation) ? t.rotation : [];
+		const c = Array.isArray(t.scale) ? t.scale : [];
+		meshesUnder(child, out, models, [
+			at[0] + (p[0] ?? 0) * scale[0],
+			at[1] + (p[1] ?? 0) * scale[1],
+			at[2] + (p[2] ?? 0) * scale[2]
+		], [
+			turn[0] + (r[0] ?? 0),
+			turn[1] + (r[1] ?? 0),
+			turn[2] + (r[2] ?? 0)
+		], [
+			scale[0] * (c[0] ?? 1),
+			scale[1] * (c[1] ?? 1),
+			scale[2] * (c[2] ?? 1)
+		]);
+	}
 }
 /** Every scatter field asking to be solid (see InstancedMesh3D.collider). */
 function collectScatters(node, out) {
@@ -1019,7 +1108,10 @@ function parseCollider3D(R, node) {
 	const desc = buildColliderDesc3D(R, collider, node.name, node);
 	if (!desc) return null;
 	const offset = collider.offset;
-	if (Array.isArray(offset)) desc.setTranslation(offset[0] ?? 0, offset[1] ?? 0, offset[2] ?? 0);
+	if (Array.isArray(offset)) {
+		const at = desc.translation;
+		desc.setTranslation(at.x + (offset[0] ?? 0), at.y + (offset[1] ?? 0), at.z + (offset[2] ?? 0));
+	}
 	return desc;
 }
 /**
@@ -1070,8 +1162,20 @@ function buildColliderDesc3D(R, collider, nodeName, node) {
 		const parts = meshes.length + models.length;
 		if (parts > 1) console.warn(`[incanto] Collider on '${nodeName}': shape 'auto' fits ONE mesh and took '${(mesh ?? model)?.name}'; ${parts - 1} other mesh(es) here are not solid. Give each part its own body.`);
 		if (mesh) {
-			const desc = meshShapedDesc(R, mesh.mesh, mesh.size, 1);
-			if (desc) return desc;
+			const desc = meshShapedDesc(R, mesh.mesh, mesh.size, mesh.scale, nodeName);
+			if (desc) {
+				desc.setTranslation(mesh.at[0], mesh.at[1], mesh.at[2]);
+				if (mesh.turn[0] !== 0 || mesh.turn[1] !== 0 || mesh.turn[2] !== 0) {
+					quatScratch.setFromEuler(eulerScratch.set(mesh.turn[0] * DEG, mesh.turn[1] * DEG, mesh.turn[2] * DEG, "XYZ"));
+					desc.setRotation({
+						x: quatScratch.x,
+						y: quatScratch.y,
+						z: quatScratch.z,
+						w: quatScratch.w
+					});
+				}
+				return desc;
+			}
 		} else if (model && node) {
 			const tri = modelTriangles(node, model);
 			if (!tri) return null;

package/dist/react.d.ts

@@ -1,4 +1,4 @@
-import { P as Scene, b as Engine, n as BehaviorCtor } from "./behavior-DWKTUzKI.js";
+import { P as Scene, b as Engine, n as BehaviorCtor } from "./behavior-DsgayMsH.js";
 import { c as JsonValue } from "./schema-CFeioQRE.js";
 import { CSSProperties, ReactNode } from "react";
 

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-BCm38FJV.js").then((n) => n.n)).createGame3D(o) : async (o) => (await import("./create-game-ClnIb_M5.js").then((n) => n.n)).createGame2D(o)))(opts);
+			const next = await (_gameFactory ?? (mode === "3d" ? async (o) => (await import("./create-game-Caut3bqN.js").then((n) => n.n)).createGame3D(o) : async (o) => (await import("./create-game-BpunnGPX.js").then((n) => n.n)).createGame2D(o)))(opts);
 			if (disposed) {
 				next.dispose();
 				return;

package/dist/{register-BSu2dWGC.js → register-CNh4FlbD.js}

@@ -1,9 +1,10 @@
-import { C as Node, b as effectiveOrder, w as diagnose } from "./loader-D8n7TU8W.js";
-import { I as translateOn, t as registerCoreNodes } from "./register-Da3hXh2H.js";
+import { O as Node, k as diagnose, w as effectiveOrder } from "./loader-DEe272nY.js";
+import { L as translateOn, t as registerCoreNodes } from "./register-D3yx8D4r.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-WWcQcfMr.js";
+import { i as getNodeSchema, l as registerNode } from "./registry-CF70EArN.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 { N as localFromWorld, P as worldPosition } from "./gameplay-CaHqDiQD.js";
 import { t as checkSheetGrid } from "./sheet-grid-BT6N_Bjs.js";
 import { AdditiveBlending, BufferAttribute, BufferGeometry, CanvasTexture, Color, DynamicDrawUsage, Group, InstancedMesh, MathUtils, Matrix4, Mesh, MeshBasicMaterial, NearestFilter, NormalBlending, Object3D, PlaneGeometry, SRGBColorSpace } from "three";
 //#region src/2d/physics/collider-validate.ts
@@ -94,6 +95,30 @@ var Node2D = class extends Node {
 		return new Object3D();
 	}
 	/** @internal Push JSON props onto the backing object. Called every frame. */
+	/**
+	* Has this node produced the thing `static: true` is about to freeze?
+	*
+	* `static` latches after the first sync, and a textured node's first sync
+	* happens BEFORE its texture has decoded — `TextureLoader.load()` returns a
+	* `Texture` with `image === undefined` and fills it asynchronously, while
+	* `Renderer2D.render()` calls `assets.load()` and `syncTree2D()` in the same
+	* frame. So the state frozen was `visible = false`, forever. Measured on two
+	* identical sprites differing only in `static`:
+	*
+	* ```
+	* frame 1            Backdrop(static) visible: false   Control visible: false
+	* 600 frames later   Backdrop(static) visible: false width 1
+	*                    Control          visible: true  width 64
+	* ```
+	*
+	* Nothing throws: the texture loaded fine, so `assetErrors()` is empty,
+	* `stats().errors` is 0, and `framing` reads props rather than pixels and
+	* still calls the node on-screen. Overridden by the nodes that wait on an
+	* image; a node with nothing to wait for is ready by definition.
+	*/
+	_staticReady(_assets) {
+		return true;
+	}
 	_syncObject2D(_assets) {
 		const o = this._ensureObject2D();
 		o.position.set(this.position[0] ?? 0, -(this.position[1] ?? 0), 0);
@@ -302,7 +327,8 @@ var Joint2D = class extends Node2D {
 		},
 		target: {
 			default: "",
-			nodePath: true
+			nodePath: true,
+			required: true
 		},
 		anchor: { default: [0, 0] },
 		targetAnchor: { default: [0, 0] },
@@ -344,7 +370,13 @@ const UNIT_PLANE$2 = new PlaneGeometry(1, 1);
 var Sprite2D = class extends Node2D {
 	static typeName = "Sprite2D";
 	static props = {
-		texture: { default: "" },
+		texture: {
+			default: "",
+			asset: {
+				kind: "texture",
+				refOnly: true
+			}
+		},
 		anchor: { default: [.5, .5] },
 		flipX: { default: false },
 		flipY: { default: false },
@@ -386,6 +418,9 @@ var Sprite2D = class extends Node2D {
 			height: image.height
 		};
 	}
+	_staticReady(assets) {
+		return this.texture === "" || this.resolveTexture(assets) !== null;
+	}
 	_syncObject2D(assets) {
 		super._syncObject2D(assets);
 		const quad = this._quad();
@@ -422,7 +457,13 @@ var AnimatedSprite2D = class extends Sprite2D {
 	static typeName = "AnimatedSprite2D";
 	static signals = ["animationFinished"];
 	static props = {
-		sheet: { default: "" },
+		sheet: {
+			default: "",
+			asset: {
+				kind: "spritesheet",
+				refOnly: true
+			}
+		},
 		animations: { default: {} },
 		autoplay: { default: "" }
 	};
@@ -564,18 +605,36 @@ var Camera2D = class extends Node2D {
 		if (!this.follow) return;
 		const target = this.getNodeOrNull(this.follow);
 		if (!(target instanceof Node2D)) return;
-		const tx = target.position[0] ?? 0;
-		const ty = target.position[1] ?? 0;
+		const [tx = 0, ty = 0] = worldPosition(target);
+		const [px = 0, py = 0] = worldPosition(this);
 		const s = Math.min(Math.max(this.smoothing, 0), .99);
 		const f = s <= 0 ? 1 : 1 - s ** (dt * 60);
-		const px = this.position[0] ?? 0;
-		const py = this.position[1] ?? 0;
-		this.position = [px + (tx - px) * f, py + (ty - py) * f];
+		const [lx = 0, ly = 0] = localFromWorld(this, [px + (tx - px) * f, py + (ty - py) * f]);
+		this.position = [lx, ly];
 	}
 	/** View center after clamping the (vw×vh)/zoom view rect inside `limits`. */
+	/**
+	* The view centre the renderer draws around, in WORLD space.
+	*
+	* It used to read `this.position` raw — the LOCAL prop — while every other
+	* 2D node gets its ancestors composed for free by the three scene graph. So a
+	* camera parented to the player, the Godot/Phaser idiom the authoring skill
+	* explicitly permits, framed the world origin:
+	*
+	* ```
+	* player world position : [1400, 900]
+	* renderer view centre  : {"x":0,"y":0}
+	* framing               : camera /Level/Player/Cam centred [1400, 900]
+	*                         1 in view, 0 outside it
+	* ```
+	*
+	* `framing` composes full world matrices, so the instrument the skills tell
+	* you to trust certified a view the renderer never drew.
+	*/
 	clampedCenter(vw, vh) {
-		let cx = this.position[0] ?? 0;
-		let cy = this.position[1] ?? 0;
+		const world = worldPosition(this);
+		let cx = world[0] ?? 0;
+		let cy = world[1] ?? 0;
 		if (this.limits.length !== 0 && this.limits.length !== 4) throw new IncantoError("BAD_FORMAT", `Camera2D '${this.name}' limits must be [] or [minX,minY,maxX,maxY], got length ${this.limits.length}.`);
 		if (this.limits.length === 4) {
 			const [minX, minY, maxX, maxY] = this.limits;
@@ -828,7 +887,14 @@ var Label = class extends Node2D {
 		fontSize: { default: 16 },
 		color: { default: "#ffffff" },
 		font: { default: "monospace" },
-		align: { default: "left" }
+		align: { default: "left" },
+		opacity: {
+			default: 1,
+			range: {
+				min: 0,
+				max: 1
+			}
+		}
 	};
 	text = "";
 	fontSize = 16;
@@ -836,6 +902,16 @@ var Label = class extends Node2D {
 	font = "monospace";
 	/** 'left' | 'center' | 'right' — anchor of the text block on the node origin. */
 	align = "left";
+	/**
+	* 0..1, like `Sprite2D` and `ColorRect2D`.
+	*
+	* Label was the one 2D drawable without it, and the gap showed up through
+	* `FloatAway` — whose own doc names "a 2D `Label`" as a node it works on.
+	* `FloatAway` writes `opacity` when the node has one, so on a Label the
+	* number rose to full height at FULL opacity and then vanished in a single
+	* frame: the pop that behavior exists to avoid.
+	*/
+	opacity = 1;
 	quadMesh = null;
 	canvas = null;
 	lastKey = "";
@@ -863,7 +939,8 @@ var Label = class extends Node2D {
 			this.lastKey = key;
 			this.rasterize();
 		}
-		quad.visible = true;
+		quad.visible = this.opacity > 0;
+		quad.material.opacity = this.opacity;
 		quad.renderOrder = this.effectiveRenderOrder;
 	}
 	rasterize() {
@@ -1306,7 +1383,13 @@ var TileMap2D = class extends Node2D {
 	static typeName = "TileMap2D";
 	static props = {
 		/** Atlas texture asset ref; tiles are tileSize×tileSize squares in it. */
-		texture: { default: "" },
+		texture: {
+			default: "",
+			asset: {
+				kind: "texture",
+				refOnly: true
+			}
+		},
 		tileSize: { default: 32 },
 		/** Atlas columns; 0 = derive from the texture width. */
 		columns: { default: 0 },
@@ -1398,6 +1481,11 @@ var TileMap2D = class extends Node2D {
 		}
 		return this.tileMesh;
 	}
+	_staticReady(assets) {
+		if (this.texture === "" || !assets) return this.texture === "";
+		const image = assets.getTexture(this.texture).image;
+		return Boolean(image?.width);
+	}
 	_syncObject2D(assets) {
 		super._syncObject2D(assets);
 		const mesh = this._mesh();