incanto 0.52.0 → 0.54.0

package/dist/{register-DVwlnZAZ.js → register-p48lHE2o.js}

@@ -1,25 +1,42 @@
-import { C as diagnose, M as Signal, S as InputMap, f as Node, g as restoreBehaviors, h as captureBehaviors, v as createSaveStore, x as resolveOrderGroups, y as ORDER_GROUP_BASE } from "./loader-B-Gft32x.js";
+import { C as diagnose, M as Signal, S as InputMap, f as Node, g as restoreBehaviors, h as captureBehaviors, v as createSaveStore, x as resolveOrderGroups, y as ORDER_GROUP_BASE } from "./loader-BTkHYrQn.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { t as Rng } from "./rng-DP-SR7eg.js";
 import { l as registerNode } from "./registry-C7u42TID.js";
 //#region src/core/audio/buses.ts
-/**
-* Global volume state — `master` × `sfx`/`music` gain (0..1) plus a `muted`
-* flag. PURE state (no WebAudio): games and AI set it to control overall
-* loudness/mute; the renderer reads `effectiveVolume()` when it actually plays
-* a sound. Lives on the engine as `engine.audio` (instance-scoped, no
-* singletons). The WebAudio wiring is in the adapter; this just holds the
-* numbers so they're fully testable in `node`.
-*
-* ```ts
-* engine.audio.master = 0.8;   // dim everything
-* engine.audio.music = 0.4;    // quieter background music
-* engine.audio.muted = true;   // mute toggle
-* ```
-*/
+const AUDIO_LOG_LIMIT = 200;
 var AudioBuses = class {
 	/** Fires whenever any value changes (drives live re-gain of playing sounds). */
 	changed = new Signal();
+	/**
+	* What has sounded, most recent last.
+	*
+	* Audio is a no-op headless, which left "did the coin sound actually fire
+	* when the coin was collected?" unanswerable — the audio skill's own advice
+	* was to *"assert `play()` doesn't throw and check your gameplay logic
+	* instead"*, which checks something else. The CALL still happens with no
+	* backend, so recording it answers the wiring question everywhere: in the
+	* verify VM, in a playtest, in a test.
+	*
+	* Bounded (200) — a game running for an hour must not grow a log.
+	*/
+	events = [];
+	/** @internal Called by the players; games read `recent()`. */
+	record(event) {
+		this.events.push(event);
+		if (this.events.length > AUDIO_LOG_LIMIT) this.events.shift();
+	}
+	/** The last `limit` sounds, oldest first. */
+	recent(limit = AUDIO_LOG_LIMIT) {
+		return this.events.slice(Math.max(0, this.events.length - limit));
+	}
+	/** How many times a preset/clip/track sounded — the assertion you want. */
+	countOf(name) {
+		return this.events.reduce((n, e) => e.name === name ? n + 1 : n, 0);
+	}
+	/** Forget what has sounded so far (between scenes, or between assertions). */
+	clearLog() {
+		this.events.length = 0;
+	}
 	_master = 1;
 	_sfx = 1;
 	_music = 1;
@@ -191,6 +208,24 @@ var WebAudioMusicBackend = class {
 		const ctx = this.ensure();
 		if (ctx && ctx.state === "suspended") ctx.resume();
 	}
+	dispose() {
+		this.ctx?.close?.();
+		this.ctx = null;
+		this.resolved = false;
+	}
+};
+//#endregion
+//#region src/core/audio/music-manager.ts
+/** Mints silent tracks so the state machine runs with no audio backend. */
+const SILENT_BACKEND = {
+	createTrack: (src) => ({
+		src,
+		setGain() {},
+		setLoop() {},
+		play() {},
+		stop() {}
+	}),
+	unlock() {}
 };
 /**
 * Single-track background-music manager: plays ONE music track, crossfading to
@@ -232,13 +267,22 @@ var MusicManager = class {
 	get volume() {
 		return this._volume;
 	}
+	/**
+	* The backend, or an INERT one that mints silent tracks.
+	*
+	* Never null, on purpose: the manager used to return before touching its
+	* state when there was no backend, so `current` stayed null forever in every
+	* headless run — including the verify VM, which is the only place a game is
+	* checked automatically. "Did the boss music start?" had no answer anywhere.
+	* With an inert backend the state machine runs identically and nothing plays.
+	*/
 	ensure() {
 		if (!this.resolved) {
 			const b = new WebAudioMusicBackend();
 			this.backend = b && b.available === false ? null : b;
 			this.resolved = true;
 		}
-		return this.backend;
+		return this.backend ?? SILENT_BACKEND;
 	}
 	/** Resume a gesture-suspended context + (re)start any pending track. */
 	unlock() {
@@ -247,8 +291,14 @@ var MusicManager = class {
 	}
 	/** Play a single track (replacing any current one immediately, no fade). */
 	play(src, opts = {}) {
+		this.buses.record({
+			kind: "music",
+			name: src,
+			from: "engine.music",
+			bus: this._bus,
+			at: 0
+		});
 		const backend = this.ensure();
-		if (!backend) return;
 		this.killOutgoing();
 		this.active?.track.stop();
 		this._bus = opts.bus ?? "music";
@@ -270,8 +320,14 @@ var MusicManager = class {
 	* it's a fade-in. Crossfading to the already-current src is a no-op.
 	*/
 	crossfadeTo(src, seconds = 2) {
+		this.buses.record({
+			kind: "music",
+			name: src,
+			from: "engine.music",
+			bus: this._bus,
+			at: 0
+		});
 		const backend = this.ensure();
-		if (!backend) return;
 		if (this.active && this.active.track.src === src && this.active.phase !== "fadeOut") return;
 		const secs = Math.max(0, seconds);
 		if (!this.active) {
@@ -319,6 +375,18 @@ var MusicManager = class {
 		};
 		this.applyGains();
 	}
+	/**
+	* Stop instantly and release the backend — music must not outlive the game.
+	*
+	* `dispose()` is the one call that tears an SPA-mounted game down, and it used
+	* to leave the track playing with the engine that owned it gone.
+	*/
+	dispose() {
+		this.stop(0);
+		this.backend?.dispose?.();
+		this.backend = null;
+		this.resolved = false;
+	}
 	/** Set the per-manager volume (re-applied to live tracks on the next tick). */
 	setVolume(v) {
 		this._volume = clamp01$1(v);
@@ -853,6 +921,19 @@ var SfxEngine = class {
 	ctx = null;
 	resolved = false;
 	pcmCache = /* @__PURE__ */ new Map();
+	/**
+	* The engine's buses, when this SfxEngine belongs to one — so a continuous
+	* voice lands in the same audio record as everything else. A record that
+	* covered only SOME sounds would answer "did the engine hum start?" with a
+	* confident no.
+	*/
+	buses = null;
+	/** Live continuous voices, so teardown can silence the ones nobody stopped. */
+	voices = /* @__PURE__ */ new Set();
+	/** @internal Engine wiring. */
+	_setBuses(buses) {
+		this.buses = buses;
+	}
 	/** True once a backend is present (lazily created on first use). */
 	get available() {
 		return this.ensure() !== null;
@@ -870,10 +951,45 @@ var SfxEngine = class {
 	* done. Headless returns an inert handle (same call sites, no ifs).
 	*/
 	startVoice(preset, gain = 1) {
+		this.buses?.record({
+			kind: "voice",
+			name: preset,
+			from: "engine.sfx",
+			bus: "sfx",
+			at: 0
+		});
 		const ctx = this.ensure();
 		if (!ctx) return INERT_VOICE;
 		if (ctx.state === "suspended") ctx.resume();
-		return createVoice(ctx, preset, gain);
+		const voice = createVoice(ctx, preset, gain);
+		for (const v of this.voices) if (v.stopped) this.voices.delete(v);
+		this.voices.add(voice);
+		return voice;
+	}
+	/** How many continuous voices are still running (teardown/leak checks). */
+	get liveVoiceCount() {
+		let n = 0;
+		for (const v of this.voices) if (!v.stopped) n++;
+		return n;
+	}
+	/** Silence every continuous voice — the hum must not outlive the game. */
+	stopAll(seconds = 0) {
+		for (const v of [...this.voices]) v.stop(seconds);
+		this.voices.clear();
+	}
+	/**
+	* Silence everything and release the AudioContext.
+	*
+	* A browser allows only a handful of contexts per page, so an SPA that mounts
+	* the game a few times must hand this one back — `dispose()` is documented as
+	* the call that tears everything down.
+	*/
+	dispose() {
+		this.stopAll();
+		this.ctx?.close?.();
+		this.ctx = null;
+		this.resolved = false;
+		this.pcmCache.clear();
 	}
 	/** Resume a gesture-suspended context (wired to the first user gesture). */
 	unlock() {
@@ -1040,6 +1156,33 @@ function suggestLocale(available, languages) {
 	return "en";
 }
 //#endregion
+//#region src/core/effects-log.ts
+const EFFECT_LOG_LIMIT = 200;
+var EffectLog = class {
+	events = [];
+	/** @internal Called by the effects themselves; games read `recent()`. */
+	record(event) {
+		this.events.push(event);
+		if (this.events.length > EFFECT_LOG_LIMIT) this.events.shift();
+	}
+	/** The last `limit` effects, oldest first. */
+	recent(limit = EFFECT_LOG_LIMIT) {
+		return this.events.slice(Math.max(0, this.events.length - limit));
+	}
+	/** How many times an effect with this name fired (`explosion`, `#ff0000`). */
+	countOf(name) {
+		return this.events.reduce((n, e) => e.name === name ? n + 1 : n, 0);
+	}
+	/** How many effects this node fired — the question a wiring check has. */
+	countFrom(path) {
+		return this.events.reduce((n, e) => e.from === path ? n + 1 : n, 0);
+	}
+	/** Forget what has fired so far (between scenes, or between assertions). */
+	clearLog() {
+		this.events.length = 0;
+	}
+};
+//#endregion
 //#region src/core/frame-stats.ts
 /**
 * Rolling window of REAL frame timestamps — the math behind `engine.stats()`
@@ -1134,6 +1277,57 @@ var LogManager = class {
 	}
 };
 //#endregion
+//#region src/core/phase-timing.ts
+const EMPTY = {
+	fixedMs: 0,
+	updateMs: 0,
+	renderMs: 0,
+	otherMs: 0
+};
+var PhaseTimings = class {
+	capacity;
+	fixed = [];
+	update = [];
+	render = [];
+	head = 0;
+	constructor(capacity = 60) {
+		this.capacity = capacity;
+	}
+	/** Bank one frame's engine-side work. */
+	push(fixedMs, updateMs, renderMs) {
+		const i = this.head % this.capacity;
+		this.fixed[i] = fixedMs;
+		this.update[i] = updateMs;
+		this.render[i] = renderMs;
+		this.head += 1;
+	}
+	/** Means over the window; `frameMs` (0 headless) fills in `otherMs`. */
+	read(frameMs) {
+		const n = Math.min(this.head, this.capacity);
+		if (n === 0) return { ...EMPTY };
+		const fixedMs = mean(this.fixed, n);
+		const updateMs = mean(this.update, n);
+		const renderMs = mean(this.render, n);
+		return {
+			fixedMs,
+			updateMs,
+			renderMs,
+			otherMs: Math.max(0, frameMs - fixedMs - updateMs - renderMs)
+		};
+	}
+	clear() {
+		this.fixed.length = 0;
+		this.update.length = 0;
+		this.render.length = 0;
+		this.head = 0;
+	}
+};
+function mean(values, n) {
+	let total = 0;
+	for (let i = 0; i < n; i++) total += values[i] ?? 0;
+	return total / n;
+}
+//#endregion
 //#region src/core/settings.ts
 const DEFAULTS = {
 	master: 1,
@@ -1432,6 +1626,12 @@ var Engine = class {
 	*  routes its volume through this; games set it for global volume/mute. */
 	audio = new AudioBuses();
 	/**
+	* What SHOWED — the visual half of the audio record. Particle bursts, camera
+	* shake, screen flash and freeze frames land here, so "did the explosion
+	* fire?" is answerable in a run with no renderer.
+	*/
+	effects = new EffectLog();
+	/**
 	* Persisted player settings — volume, quality, sensitivity.
 	*
 	* `createSaveStore` was good and had zero callers, so every game's volume
@@ -1474,6 +1674,10 @@ var Engine = class {
 	accumulator = 0;
 	disposeScheduler = null;
 	frameStats = new FrameStatsRing();
+	/** Where each frame's time went — the breakdown `frameMs` alone cannot give. */
+	phaseTimings = new PhaseTimings();
+	/** This frame's render cost, as reported by whoever renders. */
+	renderMs = 0;
 	/**
 	* Game-time multiplier: 1 = realtime, 0.5 = slow motion, 0 = frozen
 	* (hit-stop / pause). Scales BOTH variable and fixed updates — physics,
@@ -1508,6 +1712,7 @@ var Engine = class {
 		this.scheduler = opts.scheduler ?? rafScheduler;
 		this.rng = new Rng(opts.seed ?? Math.random() * 4294967295 >>> 0);
 		this.maxFps = opts.maxFps ?? 0;
+		this.sfx._setBuses(this.audio);
 	}
 	get scene() {
 		return this._scene;
@@ -1664,12 +1869,24 @@ var Engine = class {
 		this.lastFrameError = null;
 		return nodes.length;
 	}
+	/**
+	* How long the last render took, in ms — called by whoever renders.
+	*
+	* The engine does not render, so this is the one slice it cannot measure for
+	* itself; without it the cost lands in `otherMs` beside the GC and the two
+	* are indistinguishable, which is the confusion this whole breakdown exists
+	* to end.
+	*/
+	noteRenderMs(ms) {
+		this.renderMs = ms;
+	}
 	stop() {
 		this.disposeScheduler?.();
 		this.disposeScheduler = null;
 		this.lastMs = null;
 		this.accumulator = 0;
 		this.frameStats.clear();
+		this.phaseTimings.clear();
 	}
 	/**
 	* Live performance counters, queryable at ANY time. fps/frameMs come from a
@@ -1683,7 +1900,8 @@ var Engine = class {
 			frameMs: this.frameStats.frameMs(),
 			nodes: this._scene?.tree.root ? countNodes(this._scene.tree.root) : 0,
 			running: this.disposeScheduler !== null,
-			errors: this.errorCount
+			errors: this.errorCount,
+			phases: this.phaseTimings.read(this.frameStats.frameMs())
 		};
 	}
 	/**
@@ -1704,6 +1922,8 @@ var Engine = class {
 	*/
 	dispose() {
 		this.stop();
+		this.music.dispose();
+		this.sfx.dispose();
 		if (this._scene) {
 			this._scene.tree._setEngine(null);
 			this._scene.root.free();
@@ -1715,21 +1935,31 @@ var Engine = class {
 	}
 	/**
 	* Advance exactly ONE fixed step and one variable update (both dt = the
-	* fixed step), bypassing the wall-clock accumulator entirely. Drift-free
-	* by construction — the unit of time for headless harnesses (incanto/test
-	* runScript): every input edge is visible to BOTH fixedUpdate and update
-	* exactly once.
+	* fixed step scaled by `timeScale`), bypassing the wall-clock accumulator
+	* entirely. Drift-free by construction — the unit of time for headless
+	* harnesses (incanto/test runScript): every input edge is visible to BOTH
+	* fixedUpdate and update exactly once.
+	*
+	* `ignorePause: true` steps a frame at full scale even while the game is
+	* paused — the debug overlay's single-step button, and nothing else.
 	*/
-	step() {
+	step(opts = {}) {
 		const scene = this._scene;
 		if (!scene) return;
-		this._time += this.fixedStep;
+		const dt = this.fixedStep * (opts.ignorePause ? 1 : this.timeScale);
+		this._time += dt;
 		this._unscaledTime += this.fixedStep;
-		scene.tree.fixedUpdate(this.fixedStep);
-		this.fixedUpdated.emit(this.fixedStep);
-		scene.tree.update(this.fixedStep);
-		this.music.tick(this.fixedStep);
-		this.updated.emit(this.fixedStep);
+		const startedFixed = performance.now();
+		scene.tree.fixedUpdate(dt);
+		this.fixedUpdated.emit(dt);
+		const startedUpdate = performance.now();
+		scene.tree.update(dt);
+		this.music.tick(dt);
+		this.updated.emit(dt);
+		const ended = performance.now();
+		const updateMs = Math.max(0, ended - startedUpdate - this.renderMs);
+		this.phaseTimings.push(startedUpdate - startedFixed, updateMs, this.renderMs);
+		this.renderMs = 0;
 		this.input.endFrame();
 	}
 	/** Advance the loop manually. First call after (re)start only primes the clock. */
@@ -1748,6 +1978,7 @@ var Engine = class {
 		if (!scene) return;
 		this.accumulator += dt;
 		let steps = 0;
+		const startedFixed = performance.now();
 		while (this.accumulator >= this.fixedStep && steps < this.maxFixedSteps) {
 			scene.tree.fixedUpdate(this.fixedStep);
 			this.fixedUpdated.emit(this.fixedStep);
@@ -1755,9 +1986,14 @@ var Engine = class {
 			steps += 1;
 		}
 		if (this.accumulator >= this.fixedStep) this.accumulator %= this.fixedStep;
+		const startedUpdate = performance.now();
 		scene.tree.update(dt);
 		this.music.tick(dt);
 		this.updated.emit(dt);
+		const ended = performance.now();
+		const updateMs = Math.max(0, ended - startedUpdate - this.renderMs);
+		this.phaseTimings.push(startedUpdate - startedFixed, updateMs, this.renderMs);
+		this.renderMs = 0;
 		this.input.endFrame();
 	}
 };
@@ -1859,6 +2095,11 @@ var AudioPlayer = class extends Node {
 	}
 	/** A play() was blocked by the browser's autoplay policy. */
 	pendingGesture = false;
+	/**
+	* Why this player is silent, when the reason is the FILE rather than the
+	* autoplay gate. Read by `game.assetErrors()`.
+	*/
+	loadError = null;
 	element = null;
 	_playing = false;
 	autoplayed = false;
@@ -1875,6 +2116,23 @@ var AudioPlayer = class extends Node {
 	_setSpatialPose(pose) {
 		this._spatialPose = pose;
 	}
+	/**
+	* Write this sound into the engine's audio record.
+	*
+	* The CALL happens even where the backend does not (headless, the verify VM),
+	* which is exactly why the record is worth keeping: it answers "did the coin
+	* sound fire when the coin was collected" in places no sound can be heard.
+	*/
+	note(kind, name) {
+		const engine = this.tree?.engine;
+		engine?.audio.record({
+			kind,
+			name,
+			from: this.getPath(),
+			bus: this.bus === "music" ? "music" : "sfx",
+			at: engine.time
+		});
+	}
 	/** Final gain = engine buses × this volume (1 when not in a tree). */
 	gain() {
 		const buses = this.tree?.engine?.audio;
@@ -1906,10 +2164,12 @@ var AudioPlayer = class extends Node {
 	}
 	play() {
 		if (this.preset !== "custom") {
+			this.note("preset", this.preset);
 			this.playPreset();
 			return;
 		}
 		if (!this.src) return;
+		this.note("src", this.src);
 		if (!this.element) {
 			this.element = createElement();
 			if (!this.element) return;
@@ -1918,6 +2178,12 @@ var AudioPlayer = class extends Node {
 				this._playing = false;
 				this.emit("finished");
 			});
+			this.element.addEventListener("error", () => {
+				this._playing = false;
+				if (this.loadError) return;
+				this.loadError = `could not load ${this.src}`;
+				diagnose(this.tree?.engine ?? null, "error", `[incanto] AudioPlayer '${this.name}' could not load '${this.src}' — it is silent.`);
+			});
 		}
 		const el = this.element;
 		el.src = this.src;
@@ -1925,9 +2191,15 @@ var AudioPlayer = class extends Node {
 		el.loop = this.loop;
 		this._playing = true;
 		this.pendingGesture = false;
-		el.play().catch(() => {
+		el.play().catch((error) => {
 			this._playing = false;
-			this.pendingGesture = true;
+			const name = error?.name ?? "";
+			if (name !== "NotSupportedError") {
+				this.pendingGesture = true;
+				return;
+			}
+			this.loadError = `${name}: ${this.src}`;
+			diagnose(this.tree?.engine ?? null, "error", `[incanto] AudioPlayer '${this.name}' cannot play '${this.src}' (${name}) — it is silent.`);
 		});
 	}
 	/**
@@ -1948,6 +2220,19 @@ var AudioPlayer = class extends Node {
 			spatial: this.spatialPlay()
 		});
 	}
+	/**
+	* A destroyed node goes SILENT.
+	*
+	* Nothing used to stop a sound on teardown, so a level's looping background
+	* clip kept playing over the level after it — the node was freed, so nobody
+	* had a handle to stop it with either. Being MOVED is deliberately not this:
+	* reparenting a node is not destroying it, and a sound that survives the move
+	* is what a scene graph should do.
+	*/
+	free() {
+		this.stop();
+		super.free();
+	}
 	stop() {
 		if (this.element) {
 			this.element.pause();
@@ -2805,6 +3090,17 @@ function px(n) {
 	return `${n}px`;
 }
 /**
+* The translated string, or the English one.
+*
+* `locale.t` returns the KEY when nothing declares it, and a menu reading
+* `settings.volume.music` is worse than one reading `Music`. English is the
+* base language and the fallback, always.
+*/
+function translated(engine, key, fallback) {
+	const locale = engine?.locale;
+	return locale?.has(key) ? locale.t(key) : fallback;
+}
+/**
 * A box that holds other widgets — the thing a menu actually is.
 *
 * Widgets normally mount into their HudLayer's anchor slot, which is why a
@@ -3227,8 +3523,7 @@ var UiSettingSelect = class extends UiSelect {
 	* base language and the fallback, always.
 	*/
 	_tOr(key, fallback) {
-		const locale = this._engine()?.locale;
-		return locale?.has(key) ? locale.t(key) : fallback;
+		return translated(this._engine(), key, fallback);
 	}
 	_sync() {
 		const engine = this._engine();
@@ -3356,6 +3651,106 @@ var UiRenderScaleSelect = class extends UiSettingSelect {
 		return Number.isFinite(pct) ? `${pct}%` : value;
 	}
 };
+/** The three buses a player is ever offered a slider for. */
+const VOLUME_BUSES = [
+	"master",
+	"sfx",
+	"music"
+];
+const VOLUME_LABELS = {
+	master: "Volume",
+	sfx: "Sound",
+	music: "Music"
+};
+/**
+* The volume slider — the settings row every game has.
+*
+* ```json
+* { "name": "Music", "type": "UiVolumeSlider", "props": { "bus": "music" } }
+* ```
+*
+* The graphics controls above became nodes because a game whose whole world is
+* JSON could not put a menu on screen without a behavior, a signal connection
+* and the knowledge that `Settings` persists. All of that was just as true of
+* volume, which is the control a player looks for FIRST and the only one some
+* games need at all — so an audio menu meant hand-rolled DOM, and hand-rolled
+* DOM is out of scene JSON, out of the editor, and out of every headless check.
+*
+* It writes the bus; the bus persists itself (`bindAudio`, which
+* `createGame2D/3D` wire), so there is nothing to save.
+*/
+var UiVolumeSlider = class extends UiSlider {
+	static typeName = "UiVolumeSlider";
+	static props = {
+		...UiSlider.props,
+		/** Which bus this row owns. `master` dims everything. */
+		bus: {
+			default: "master",
+			options: [...VOLUME_BUSES]
+		},
+		/** Empty takes the bus's own name — a row nobody labelled still reads. */
+		label: { default: "" }
+	};
+	bus = "master";
+	/** Last value we PUSHED in, to tell an engine-side change from a player drag. */
+	lastPushed = null;
+	_build() {
+		if (!this.label) {
+			const english = VOLUME_LABELS[this.bus] ?? VOLUME_LABELS.master;
+			this.label = translated(this.tree?.engine ?? null, `settings.volume.${this.bus}`, english);
+		}
+		return super._build();
+	}
+	_sync() {
+		const audio = this.tree?.engine?.audio;
+		if (audio) {
+			const stored = audio[this.bus];
+			if (stored !== this.lastPushed) {
+				this.lastPushed = stored;
+				this.value = stored;
+			} else if (this.value !== stored) {
+				audio[this.bus] = this.value;
+				this.lastPushed = audio[this.bus];
+			}
+		}
+		super._sync();
+	}
+};
+/**
+* The mute switch.
+*
+* ```json
+* { "name": "Mute", "type": "UiMuteToggle" }
+* ```
+*
+* Checked means silent. Like the slider it writes `engine.audio`, which
+* persists itself.
+*/
+var UiMuteToggle = class extends UiToggle {
+	static typeName = "UiMuteToggle";
+	static props = {
+		...UiToggle.props,
+		label: { default: "" }
+	};
+	lastPushed = null;
+	_build() {
+		if (!this.label) this.label = translated(this.tree?.engine ?? null, "settings.mute", "Mute");
+		return super._build();
+	}
+	_sync() {
+		const audio = this.tree?.engine?.audio;
+		if (audio) {
+			if (audio.muted !== this.lastPushed) {
+				this.lastPushed = audio.muted;
+				this.value = audio.muted;
+			} else if (this.value !== audio.muted) {
+				audio.muted = this.value;
+				this.lastPushed = audio.muted;
+			}
+		}
+		super._sync();
+	}
+};
 //#endregion
 //#region src/core/register.ts
 /**
@@ -3382,6 +3777,8 @@ function registerCoreNodes() {
 	registerNode(UiQualitySelect);
 	registerNode(UiFrameCapSelect);
 	registerNode(UiRenderScaleSelect);
+	registerNode(UiVolumeSlider);
+	registerNode(UiMuteToggle);
 }
 //#endregion
-export { ROLLOFF_MODELS as A, AudioBuses as B, BASE_LOCALE as C, translationKey as D, suggestLocale as E, synthSfx as F, MusicManager as I, WebAudioMusicBackend as L, spatialPan as M, SFX_PRESETS as N, SfxEngine as O, SFX_PRESET_NAMES as P, crossfadeGains as R, LogManager as S, T_PREFIX as T, qualityCaps as _, UiSlider as a, readDeviceHints as b, UiButton as c, UiBanner as d, UiBar as f, Settings as g, Engine as h, UiSelect as i, spatialGain as j, isAudioContextAvailable as k, UiDialogue as l, AudioPlayer as m, UiImage as n, UiToggle as o, UiText as p, UiPanel as r, Timer as s, registerCoreNodes as t, HudLayer as u, qualityEnvironment as v, Localization as w, suggestQuality as x, qualityRendering as y, fadeGain as z };
+export { BASE_LOCALE as A, SFX_PRESETS as B, qualityCaps as C, suggestQuality as D, readDeviceHints as E, SfxEngine as F, crossfadeGains as G, synthSfx as H, isAudioContextAvailable as I, fadeGain as K, ROLLOFF_MODELS as L, T_PREFIX as M, suggestLocale as N, LogManager as O, translationKey as P, spatialGain as R, Settings as S, qualityRendering as T, MusicManager as U, SFX_PRESET_NAMES as V, WebAudioMusicBackend as W, UiBanner as _, UiMuteToggle as a, AudioPlayer as b, UiRenderScaleSelect as c, UiToggle as d, UiVolumeSlider as f, HudLayer as g, UiDialogue as h, UiLanguageSelect as i, Localization as j, EffectLog as k, UiSelect as l, UiButton 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, UiBar as v, qualityEnvironment as w, Engine as x, UiText as y, spatialPan as z };

package/dist/{replay-BU1CCM15.d.ts → replay-ePMz26jw.d.ts}

@@ -1,4 +1,4 @@
-import { b as Engine } from "./behavior-uPEuZrUB.js";
+import { b as Engine } from "./behavior-CyQoSu4n.js";
 import { s as JsonObject } from "./schema-CFeioQRE.js";
 
 //#region src/core/audit.d.ts