incanto 0.74.0 → 0.76.0

package/dist/{register-CjociOtt.js → register-B768Qedj.js}

@@ -1,5 +1,5 @@
 import { o as __exportAll } from "./json-CfTjpvW8.js";
-import { B as HudLayer, F as resolveOrderGroups, G as UiText, H as TAPPABLE, I as InputMap, J as Node, N as ORDER_GROUP_BASE, U as UiBanner, V as HudWidgetBase, W as UiBar, Y as diagnose, a as restoreBehaviors, ct as Signal, i as captureBehaviors, j as createSaveStore, q as requireText, t as ENGINE_STATE_KEY, z as FITS } from "./save-slots-CEUGeLuB.js";
+import { $ as Node, B as resolveOrderGroups, G as HudLayer, I as createSaveStore, J as UiBanner, K as HudWidgetBase, Q as requireText, R as ORDER_GROUP_BASE, V as InputMap, W as FITS, X as UiText, Y as UiBar, a as ENGINE_STATE_KEY, c as captureBehaviors, et as diagnose, i as worldPosition, l as restoreBehaviors, pt as Signal, q as TAPPABLE, r as worldDirection, t as hasPosition } from "./pose-ByFB_J3O.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { t as Rng } from "./rng-CDOMybym.js";
 import { p as registerNode } from "./touch-CioTZB-y.js";
@@ -2714,6 +2714,99 @@ var AudioPlayer = class extends Node {
 		this._spatialPose = pose;
 	}
 	/**
+	* Where this sound arrives from, for the record: gain, side and distance.
+	*
+	* The renderer feeds a pose every frame it draws; headless there is none, and
+	* that is exactly where the question matters — a harness asking "was the bell
+	* on my left" had nothing to read. So when no pose has been pushed, one is
+	* computed HERE, from the scene's own current camera: the same listener the
+	* panner would use, without a renderer to ask.
+	*
+	* Null when the sound is not spatial, or when the scene has no camera to hear
+	* it — the record then says nothing rather than inventing a centred sound.
+	*/
+	spatialAnswer() {
+		if (!this.spatial) return null;
+		const pose = this._spatialPose ?? this.poseFromScene();
+		if (!pose) return null;
+		const [sx, sy, sz] = pose.position;
+		const [lx, ly, lz] = pose.listener.position;
+		const distance = Math.hypot(sx - lx, sy - ly, sz - lz);
+		return {
+			gain: spatialGain(distance, {
+				refDistance: this.refDistance,
+				maxDistance: this.maxDistance,
+				rolloff: this.rolloff
+			}),
+			pan: spatialPan(pose.position, pose.listener),
+			distance
+		};
+	}
+	/** The listener the scene implies: its current camera, posed from the tree. */
+	poseFromScene() {
+		const root = this.tree?.root;
+		if (!root) return null;
+		let camera = null;
+		const walk = (node) => {
+			if (camera) return;
+			if ((node.constructor.typeName ?? "") === "Camera3D" && node.current === true) {
+				camera = node;
+				return;
+			}
+			for (const child of node.children) walk(child);
+		};
+		walk(root);
+		if (!camera) return null;
+		const cam = camera;
+		const at = worldPosition(cam);
+		if (at.length < 3) return null;
+		const forward = worldDirection(cam, [
+			0,
+			0,
+			-1
+		]);
+		const up = worldDirection(cam, [
+			0,
+			1,
+			0
+		]);
+		const emitter = this.emitterPosition();
+		if (!emitter) return null;
+		return {
+			position: emitter,
+			listener: {
+				position: [
+					at[0] ?? 0,
+					at[1] ?? 0,
+					at[2] ?? 0
+				],
+				forward: [
+					forward[0] ?? 0,
+					forward[1] ?? 0,
+					forward[2] ?? -1
+				],
+				up: [
+					up[0] ?? 0,
+					up[1] ?? 1,
+					up[2] ?? 0
+				]
+			}
+		};
+	}
+	/** Where this player SOUNDS from: its nearest spatial ancestor (or itself). */
+	emitterPosition() {
+		for (let at = this; at; at = at.parent) {
+			if (!hasPosition(at)) continue;
+			const world = worldPosition(at);
+			if (world.length >= 3) return [
+				world[0] ?? 0,
+				world[1] ?? 0,
+				world[2] ?? 0
+			];
+		}
+		return null;
+	}
+	/**
 	* Write this sound into the engine's audio record.
 	*
 	* The CALL happens even where the backend does not (headless, the verify VM),
@@ -2722,6 +2815,7 @@ var AudioPlayer = class extends Node {
 	*/
 	note(kind, name) {
 		const engine = this.tree?.engine;
+		const where = this.spatialAnswer();
 		engine?.audio.record({
 			kind,
 			name,
@@ -2729,6 +2823,7 @@ var AudioPlayer = class extends Node {
 			wiredAs: this.wiringPath(),
 			bus: this.bus === "music" ? "music" : "sfx",
 			at: engine.time,
+			...where ?? {},
 			...this.loop ? { loop: true } : {}
 		});
 	}
@@ -3034,11 +3129,22 @@ var UiDialogue = class extends HudWidgetBase {
 			]
 		},
 		charsPerSecond: { default: 40 },
+		/**
+		* A line moves on by itself this long after it is fully shown (0 = wait
+		* for the click). Cutscenes have nobody clicking — the camera is on a rail
+		* and the controller is off. A line with choices always waits.
+		*/
+		autoAdvanceSeconds: {
+			default: 0,
+			range: { min: 0 }
+		},
 		width: { default: 520 }
 	};
 	anchor = "bottom";
 	/** Typewriter speed; 0 = instant lines. */
 	charsPerSecond = 40;
+	autoAdvanceSeconds = 0;
+	shownFor = 0;
 	width = 520;
 	queue = [];
 	current = null;
@@ -3190,6 +3296,7 @@ var UiDialogue = class extends HudWidgetBase {
 			this.current = this.queue.shift();
 			this.resolveCurrent();
 			this.revealed = this.charsPerSecond <= 0 ? this.current.text.length : 0;
+			this.shownFor = 0;
 			this.emit("lineShown", this.current.text);
 			if (this._element) {
 				if (this.speakerEl) this.speakerEl.textContent = this.current.speaker;
@@ -3220,6 +3327,10 @@ var UiDialogue = class extends HudWidgetBase {
 			});
 			this.choicesEl?.appendChild(b);
 		});
+		if (this.autoAdvanceSeconds > 0 && this.current && !this.current.choices && this.revealed >= this.current.text.length) {
+			this.shownFor += dt;
+			if (this.shownFor >= this.autoAdvanceSeconds) this.advance();
+		}
 	}
 };
 //#endregion
@@ -4206,6 +4317,487 @@ var UiMuteToggle = class extends UiToggle {
 	}
 };
 //#endregion
+//#region src/core/nodes/ui-minimap.ts
+const DEG = Math.PI / 180;
+/** How often the tree is re-scanned for the followed node and the groups (frames). */
+const SCAN_FRAMES = 30;
+/**
+* A minimap — the world around one node, top-down, as dots on a disc.
+*
+* ```json
+* { "name": "Map", "type": "UiMinimap",
+*   "props": { "anchor": "topRight", "size": 160, "radius": 40,
+*              "dots": { "enemy": "#ff5050", "pickup": "#ffd54f", "goal": "#3aa0ff" } } }
+* ```
+*
+* It follows the first node in the `player` group unless `follow` names
+* one, shows every node in the groups listed in `dots` within `radius` world units
+* (metres in 3D, px in 2D — the plane is x/z in 3D and x/y in 2D), and can
+* turn with a `heading` node so "ahead" is up. Everything it draws is a
+* number first: `markers()` is the same list headless, so a harness can ask
+* what the map shows.
+*/
+var UiMinimap = class extends HudWidgetBase {
+	static typeName = "UiMinimap";
+	static props = {
+		...HudWidgetBase.props,
+		/** Diameter (px). */
+		size: { default: 160 },
+		/** World units shown from the centre to the rim (m in 3D, px in 2D). */
+		radius: { default: 40 },
+		/** The node at the centre; '' = the first node in the `player` group. */
+		follow: {
+			default: "",
+			nodePath: true
+		},
+		/** Group → colour: every node in a listed group is a dot. (Not `groups` — that is the node's own membership.) */
+		dots: { default: {} },
+		/** A node whose yaw turns the map so its "ahead" is up (+Z-forward); '' = north (−z) up. */
+		heading: {
+			default: "",
+			nodePath: true
+		},
+		/** Colour of the followed node's own marker. */
+		self: { default: "#ffffff" },
+		/** Marker diameter (px). */
+		dotSize: { default: 6 },
+		background: { default: "rgba(0,0,0,0.45)" },
+		shape: {
+			default: "circle",
+			options: ["circle", "square"]
+		}
+	};
+	size = 160;
+	radius = 40;
+	follow = "";
+	dots = {};
+	heading = "";
+	self = "#ffffff";
+	dotSize = 6;
+	background = "rgba(0,0,0,0.45)";
+	shape = "circle";
+	canvas = null;
+	centreNode = null;
+	members = /* @__PURE__ */ new Map();
+	scanIn = 0;
+	/**
+	* Loader hook: `dots` is a name map — its KEYS are the author's group names,
+	* so any key is right — and every VALUE must be a colour string. A number or
+	* an object where a colour should be drew nothing, silently.
+	*/
+	static validateJson(node) {
+		const dots = node.dots;
+		if (typeof dots !== "object" || dots === null || Array.isArray(dots)) throw new IncantoError("PROP_TYPE_MISMATCH", `UiMinimap '${node.name}': "dots" must be an object of group → colour, got ${JSON.stringify(dots)}.`, { prop: "dots" });
+		for (const [group, color] of Object.entries(dots)) if (typeof color !== "string" || color === "") throw new IncantoError("PROP_TYPE_MISMATCH", `UiMinimap '${node.name}': dots.${group} must be a colour string (like "#ff5050"), got ${JSON.stringify(color)}.`, { prop: "dots" });
+	}
+	/** The followed node, or null when nothing is in the `player` group either. */
+	centre() {
+		this.rescan(false);
+		return this.centreNode;
+	}
+	/** Every dot on the map right now, in canvas px — the followed node is not among them. */
+	markers() {
+		this.rescan(false);
+		const centre = this.centreNode;
+		if (!centre) return [];
+		const c = worldOf$1(centre);
+		const is3d = c.length >= 3;
+		const half = this.size / 2;
+		const scale = this.radius > 0 ? half / this.radius : 0;
+		const yaw = this.headingYaw();
+		const out = [];
+		for (const [group, color] of Object.entries(this.dots)) for (const node of this.members.get(group) ?? []) {
+			if (node === centre || node.tree === null) continue;
+			const p = worldOf$1(node);
+			const dx = (p[0] ?? 0) - (c[0] ?? 0);
+			const d2 = is3d ? (p[2] ?? 0) - (c[2] ?? 0) : (p[1] ?? 0) - (c[1] ?? 0);
+			if (Math.hypot(dx, d2) > this.radius) continue;
+			let x;
+			let y;
+			if (yaw === null) {
+				x = half + dx * scale;
+				y = half + d2 * scale;
+			} else {
+				const ux = Math.sin(yaw);
+				const uz = Math.cos(yaw);
+				const rx = -uz;
+				const rz = ux;
+				x = half + (dx * rx + d2 * rz) * scale;
+				y = half - (dx * ux + d2 * uz) * scale;
+			}
+			out.push({
+				x,
+				y,
+				color: String(color),
+				group,
+				node
+			});
+		}
+		return out;
+	}
+	/** The heading's yaw in radians, or null for north-up. */
+	headingYaw() {
+		if (this.heading === "") return null;
+		const h = this.getNodeOrNull(this.heading);
+		if (!h) return null;
+		const r = h.rotation;
+		if (typeof r === "number") return r * DEG;
+		return (r?.[1] ?? 0) * DEG;
+	}
+	rescan(force) {
+		if (!force && this.scanIn > 0 && this.centreNode && this.centreNode.tree !== null) {
+			this.scanIn -= 1;
+			return;
+		}
+		this.scanIn = SCAN_FRAMES;
+		const root = this.getRoot();
+		const tree = this.tree;
+		this.centreNode = this.follow !== "" ? this.getNodeOrNull(this.follow) : tree?.getNodesInGroup("player")[0] ?? null;
+		this.members.clear();
+		for (const group of Object.keys(this.dots)) this.members.set(group, tree ? tree.getNodesInGroup(group) : collectGroup(root, group));
+	}
+	_build() {
+		const canvas = document.createElement("canvas");
+		canvas.width = this.size;
+		canvas.height = this.size;
+		canvas.style.cssText = `width:${this.size}px;height:${this.size}px;display:block;`;
+		this.canvas = canvas;
+		return canvas;
+	}
+	_sync() {
+		const canvas = this.canvas;
+		if (!canvas) return;
+		if (canvas.width !== this.size) {
+			canvas.width = this.size;
+			canvas.height = this.size;
+			canvas.style.width = `${this.size}px`;
+			canvas.style.height = `${this.size}px`;
+		}
+		const ctx = canvas.getContext("2d");
+		if (!ctx) return;
+		const s = this.size;
+		const half = s / 2;
+		ctx.clearRect(0, 0, s, s);
+		ctx.save();
+		if (this.shape === "circle") {
+			ctx.beginPath();
+			ctx.arc(half, half, half, 0, Math.PI * 2);
+			ctx.clip();
+		}
+		ctx.fillStyle = this.background;
+		ctx.fillRect(0, 0, s, s);
+		ctx.strokeStyle = "rgba(255,255,255,0.25)";
+		ctx.lineWidth = 1;
+		ctx.beginPath();
+		ctx.moveTo(half, 0);
+		ctx.lineTo(half, s);
+		ctx.moveTo(0, half);
+		ctx.lineTo(s, half);
+		ctx.stroke();
+		const r = Math.max(1, this.dotSize / 2);
+		for (const m of this.markers()) {
+			ctx.fillStyle = m.color;
+			ctx.beginPath();
+			ctx.arc(m.x, m.y, r, 0, Math.PI * 2);
+			ctx.fill();
+		}
+		if (this.centreNode) {
+			ctx.fillStyle = this.self;
+			ctx.beginPath();
+			ctx.moveTo(half, half - r * 1.6);
+			ctx.lineTo(half + r * 1.1, half + r * 1.1);
+			ctx.lineTo(half - r * 1.1, half + r * 1.1);
+			ctx.closePath();
+			ctx.fill();
+		}
+		ctx.restore();
+		if (this.shape === "circle") {
+			ctx.strokeStyle = "rgba(255,255,255,0.5)";
+			ctx.lineWidth = 2;
+			ctx.beginPath();
+			ctx.arc(half, half, half - 1, 0, Math.PI * 2);
+			ctx.stroke();
+		}
+	}
+};
+/** Ancestor-summed position — a node parented to a moving thing is where it is drawn. */
+function worldOf$1(node) {
+	let x = 0;
+	let y = 0;
+	let z = 0;
+	let dims = 0;
+	for (let n = node; n; n = n.parent) {
+		const p = n.position;
+		if (!Array.isArray(p)) continue;
+		dims = Math.max(dims, p.length);
+		x += p[0] ?? 0;
+		y += p[1] ?? 0;
+		z += p[2] ?? 0;
+	}
+	return dims >= 3 ? [
+		x,
+		y,
+		z
+	] : [x, y];
+}
+function collectGroup(node, group, out = []) {
+	if (node.isInGroup(group)) out.push(node);
+	for (const c of node.children) collectGroup(c, group, out);
+	return out;
+}
+//#endregion
+//#region src/core/nodes/ui-waypoint.ts
+/**
+* An objective marker — a diamond over the target, an arrow at the screen's
+* edge when it is off screen or behind you, the metres left under it.
+*
+* ```json
+* { "name": "Mark", "type": "UiWaypoint",
+*   "props": { "target": "/root/Shop1", "label": "bakery", "hideWithin": 4, "arriveWithin": 3 } }
+* ```
+*
+* It floats over `target` through `engine.toScreen` (the renderer's own
+* projection), so `anchor` means nothing here. Off screen it slides to the
+* `margin` rectangle along the line from the centre and turns its arrow that
+* way; behind the camera it is mirrored through the centre first, so it
+* still points the way to turn. `distance` is measured from `from` — the
+* first node in the `player` group by default. `hideWithin` hides it when
+* you are that close; `arrived` fires once when `from` comes within
+* `arriveWithin`, and again after leaving and coming back.
+*
+* `screen()` is the same answer headless, from whatever `toScreen` a test
+* installs — a harness can ask where the marker is and which way it points.
+*/
+var UiWaypoint = class extends HudWidgetBase {
+	static typeName = "UiWaypoint";
+	static props = {
+		...HudWidgetBase.props,
+		/** The node the marker floats over. */
+		target: {
+			default: "",
+			nodePath: true
+		},
+		/** Text under the diamond ('' = none). */
+		label: { default: "" },
+		color: { default: "#ffd54f" },
+		/** The diamond's size, px. */
+		size: { default: 22 },
+		/** Show the metres left. */
+		distance: { default: true },
+		/** Keep it on screen at the edge when the target is off screen or behind. */
+		clamp: { default: true },
+		/** How far in from the edge it stops, px. */
+		margin: { default: 40 },
+		/** Hide when `from` is this close (m); 0 = never. */
+		hideWithin: {
+			default: 0,
+			range: { min: 0 }
+		},
+		/** `arrived` fires when `from` comes this close (m); 0 = never. */
+		arriveWithin: {
+			default: 0,
+			range: { min: 0 }
+		},
+		/** Who the distance is measured from; '' = the first node in the `player` group. */
+		from: {
+			default: "",
+			nodePath: true
+		}
+	};
+	static signals = [...HudWidgetBase.signals, "arrived"];
+	target = "";
+	label = "";
+	color = "#ffd54f";
+	size = 22;
+	distance = true;
+	clamp = true;
+	margin = 40;
+	hideWithin = 0;
+	arriveWithin = 0;
+	from = "";
+	inside = false;
+	box = null;
+	arrow = null;
+	diamond = null;
+	text = null;
+	/** Metres from `from` to the target, or null when either is missing. */
+	distanceNow() {
+		const t = this.targetNode();
+		const f = this.fromNode();
+		if (!t || !f) return null;
+		const a = worldOf(t);
+		const b = worldOf(f);
+		return Math.hypot((a[0] ?? 0) - (b[0] ?? 0), (a[1] ?? 0) - (b[1] ?? 0), (a[2] ?? 0) - (b[2] ?? 0));
+	}
+	/**
+	* Where the marker is, in canvas px, for a view this big (the canvas, in the
+	* browser). Null when there is no target or no renderer has offered a
+	* projection.
+	*/
+	screen(view = this.viewport()) {
+		const to = this.tree?.engine?.toScreen;
+		const t = this.targetNode();
+		if (!to || !t) return null;
+		const p = to(worldOf(t));
+		if (!p) return null;
+		const w = view.width;
+		const h = view.height;
+		const cx = w / 2;
+		const cy = h / 2;
+		let x = p.x;
+		let y = p.y;
+		const behind = p.behind;
+		if (behind) {
+			x = w - x;
+			y = h - y;
+		}
+		const onScreen = !behind && x >= 0 && x <= w && y >= 0 && y <= h;
+		const m = this.margin;
+		const insideMargin = x >= m && x <= w - m && y >= m && y <= h - m;
+		let dx = x - cx;
+		let dy = y - cy;
+		if (Math.abs(dx) < 1e-6 && Math.abs(dy) < 1e-6) dy = 1;
+		const angle = Math.atan2(dy, dx);
+		let clamped = false;
+		if (this.clamp && (behind || !insideMargin)) {
+			const halfW = Math.max(1, cx - m);
+			const halfH = Math.max(1, cy - m);
+			const tx = Math.abs(dx) > 1e-6 ? halfW / Math.abs(dx) : Number.POSITIVE_INFINITY;
+			const ty = Math.abs(dy) > 1e-6 ? halfH / Math.abs(dy) : Number.POSITIVE_INFINITY;
+			const s = Math.min(tx, ty);
+			if (s < 1 || behind) {
+				dx *= s;
+				dy *= s;
+				x = cx + dx;
+				y = cy + dy;
+				clamped = true;
+			}
+		}
+		const d = this.distanceNow() ?? 0;
+		const visible = this.visible && !(this.hideWithin > 0 && d < this.hideWithin);
+		return {
+			x,
+			y,
+			angle,
+			behind,
+			onScreen,
+			clamped,
+			distance: d,
+			visible
+		};
+	}
+	update(dt) {
+		if (this.arriveWithin > 0) {
+			const d = this.distanceNow();
+			const now = d !== null && d <= this.arriveWithin;
+			if (now && !this.inside) this.emit("arrived");
+			this.inside = now;
+		}
+		super.update(dt);
+	}
+	_build() {
+		const box = document.createElement("div");
+		box.style.cssText = "position:fixed;left:0;top:0;display:flex;flex-direction:column;align-items:center;gap:2px;pointer-events:none;transform:translate(-50%,-50%);will-change:transform;";
+		const arrow = document.createElement("div");
+		arrow.style.cssText = `width:0;height:0;border-top:7px solid transparent;border-bottom:7px solid transparent;border-left:12px solid ${this.color};transform-origin:50% 50%;display:none;`;
+		const diamond = document.createElement("div");
+		diamond.style.cssText = `width:${this.size}px;height:${this.size}px;background:${this.color};transform:rotate(45deg);box-shadow:0 0 6px rgba(0,0,0,0.5);`;
+		const text = document.createElement("div");
+		text.style.cssText = "font:600 13px/1.2 system-ui,sans-serif;color:#fff;text-shadow:0 1px 3px #000;white-space:nowrap;text-align:center;";
+		box.append(diamond, text, arrow);
+		this.box = box;
+		this.arrow = arrow;
+		this.diamond = diamond;
+		this.text = text;
+		return box;
+	}
+	_sync() {
+		const box = this.box;
+		if (!box) return;
+		const s = this.screen();
+		if (!s || !s.visible) {
+			box.style.display = "none";
+			return;
+		}
+		box.style.display = "flex";
+		const view = this.viewport();
+		const bw = box.offsetWidth || 0;
+		const bh = box.offsetHeight || 0;
+		const x = Math.min(Math.max(s.x, bw / 2), view.width - bw / 2);
+		const y = Math.min(Math.max(s.y, bh / 2), view.height - bh / 2);
+		box.style.transform = `translate(${x}px, ${y}px) translate(-50%, -50%)`;
+		if (this.diamond) {
+			this.diamond.style.background = this.color;
+			this.diamond.style.width = `${this.size}px`;
+			this.diamond.style.height = `${this.size}px`;
+			this.diamond.style.display = s.clamped ? "none" : "";
+		}
+		if (this.arrow) {
+			this.arrow.style.display = s.clamped ? "" : "none";
+			this.arrow.style.borderLeftColor = this.color;
+			this.arrow.style.transform = `rotate(${s.angle}rad)`;
+		}
+		if (this.text) {
+			const parts = [];
+			if (this.label !== "") parts.push(this.label);
+			if (this.distance) parts.push(`${Math.round(s.distance)} m`);
+			this.text.textContent = parts.join(" · ");
+			this.text.style.display = parts.length ? "" : "none";
+		}
+	}
+	/** The canvas's size in the browser; a stand-in headless. */
+	viewport() {
+		if (typeof document !== "undefined") {
+			const canvas = document.querySelector("canvas");
+			if (canvas) {
+				const r = canvas.getBoundingClientRect();
+				if (r.width > 0 && r.height > 0) return {
+					width: r.width,
+					height: r.height
+				};
+			}
+			if (typeof window !== "undefined" && window.innerWidth > 0) return {
+				width: window.innerWidth,
+				height: window.innerHeight
+			};
+		}
+		return {
+			width: 1280,
+			height: 720
+		};
+	}
+	targetNode() {
+		if (this.target === "") return null;
+		const t = this.getNodeOrNull(this.target);
+		return t && t.tree !== null ? t : null;
+	}
+	fromNode() {
+		if (this.from !== "") {
+			const f = this.getNodeOrNull(this.from);
+			return f && f.tree !== null ? f : null;
+		}
+		return (this.tree?.getNodesInGroup("player") ?? [])[0] ?? null;
+	}
+};
+/** Translation-only world position, 2D or 3D. */
+function worldOf(node) {
+	let x = 0;
+	let y = 0;
+	let z = 0;
+	for (let n = node; n; n = n.parent) {
+		const p = n.position;
+		if (!Array.isArray(p)) continue;
+		x += p[0] ?? 0;
+		y += p[1] ?? 0;
+		z += p[2] ?? 0;
+	}
+	return [
+		x,
+		y,
+		z
+	];
+}
+//#endregion
 //#region src/core/register.ts
 /**
 * Register the core node types. Call once in your game entry before loading
@@ -4225,6 +4817,8 @@ function registerCoreNodes() {
 	registerNode(UiDialogue);
 	registerNode(UiPanel);
 	registerNode(UiImage);
+	registerNode(UiMinimap);
+	registerNode(UiWaypoint);
 	registerNode(UiSlider);
 	registerNode(UiToggle);
 	registerNode(UiSelect);
@@ -4236,4 +4830,4 @@ function registerCoreNodes() {
 	registerNode(UiMuteToggle);
 }
 //#endregion
-export { T_PREFIX as A, SFX_PRESET_NAMES as B, qualityRendering as C, EffectLog as D, LogManager as E, isAudioContextAvailable as F, crossfadeGains as G, synthSfx as H, ROLLOFF_MODELS as I, fadeGain as K, spatialGain as L, translateOn as M, translationKey as N, BASE_LOCALE as O, SfxEngine as P, spatialPan as R, qualityEnvironment as S, suggestQuality as T, MusicManager as U, sfxDuration as V, WebAudioMusicBackend as W, AudioPlayer as _, UiMuteToggle as a, Settings as b, UiRenderScaleSelect as c, UiToggle as d, UiVolumeSlider as f, UiDialogue as g, UiButton as h, UiLanguageSelect as i, suggestLocale as j, Localization as k, UiSelect as l, Respawn as m, UiFrameCapSelect as n, UiPanel as o, Timer as p, AudioBuses as q, UiImage as r, UiQualitySelect as s, registerCoreNodes as t, UiSlider as u, Engine as v, readDeviceHints as w, qualityCaps as x, engine_exports as y, SFX_PRESETS as z };
+export { BASE_LOCALE as A, spatialPan as B, qualityCaps as C, suggestQuality as D, readDeviceHints as E, translationKey as F, MusicManager as G, SFX_PRESET_NAMES as H, SfxEngine as I, fadeGain as J, WebAudioMusicBackend as K, isAudioContextAvailable as L, T_PREFIX as M, suggestLocale as N, LogManager as O, translateOn as P, ROLLOFF_MODELS as R, Settings as S, qualityRendering as T, sfxDuration as U, SFX_PRESETS as V, synthSfx as W, AudioBuses as Y, UiButton as _, UiImage as a, Engine as b, UiPanel as c, UiSelect as d, UiSlider as f, Respawn as g, Timer as h, UiFrameCapSelect as i, Localization as j, EffectLog as k, UiQualitySelect as l, UiVolumeSlider as m, UiWaypoint as n, UiLanguageSelect as o, UiToggle as p, crossfadeGains as q, UiMinimap as r, UiMuteToggle as s, registerCoreNodes as t, UiRenderScaleSelect as u, UiDialogue as v, qualityEnvironment as w, engine_exports as x, AudioPlayer as y, spatialGain as z };