incanto 0.52.0 → 0.54.0

package/dist/{behavior-uPEuZrUB.d.ts → behavior-CyQoSu4n.d.ts}

@@ -325,9 +325,42 @@ type BusName = "sfx" | "music";
 * engine.audio.muted = true;   // mute toggle
 * ```
 */
+/** One thing that sounded (or would have, headless). */
+interface AudioEvent {
+  /** `preset` (procedural one-shot), `src` (a clip), `music`, or `voice`. */
+  kind: "preset" | "src" | "music" | "voice";
+  /** The preset name, the clip url, or the voice preset. */
+  name: string;
+  /** Node path for a node-driven sound; `engine.music` / `engine.sfx` otherwise. */
+  from: string;
+  bus: BusName;
+  /** `engine.time` when it fired, in seconds. */
+  at: number;
+}
 declare class AudioBuses {
   /** Fires whenever any value changes (drives live re-gain of playing sounds). */
   readonly changed: 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.
+  */
+  private readonly events;
+  /** @internal Called by the players; games read `recent()`. */
+  record(event: AudioEvent): void;
+  /** The last `limit` sounds, oldest first. */
+  recent(limit?: number): AudioEvent[];
+  /** How many times a preset/clip/track sounded — the assertion you want. */
+  countOf(name: string): number;
+  /** Forget what has sounded so far (between scenes, or between assertions). */
+  clearLog(): void;
   private _master;
   private _sfx;
   private _music;
@@ -377,6 +410,8 @@ interface MusicBackend {
   createTrack(src: string): MusicTrack;
   /** Resume a gesture-suspended context (wired to the first user gesture). */
   unlock(): void;
+  /** Release the context it owns (optional — teardown). */
+  dispose?(): void;
 }
 interface PlayMusicOptions {
   /** Loop the track (default true — music usually loops). */
@@ -420,6 +455,15 @@ declare class MusicManager {
   get current(): string | null;
   /** Per-manager volume (0..1), on top of the bus gain. */
   get volume(): number;
+  /**
+  * 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.
+  */
   private ensure;
   /** Resume a gesture-suspended context + (re)start any pending track. */
   unlock(): void;
@@ -432,6 +476,13 @@ declare class MusicManager {
   crossfadeTo(src: string, seconds?: number): void;
   /** Stop the current track, optionally fading out over `fadeOut` seconds. */
   stop(fadeOut?: number): void;
+  /**
+  * 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(): void;
   /** Set the per-manager volume (re-applied to live tracks on the next tick). */
   setVolume(v: number): void;
   /** Advance fades by `dt` seconds and (re)apply bus×fade gains. Frame-driven. */
@@ -588,6 +639,14 @@ interface Voice {
 //#endregion
 //#region src/core/audio/webaudio-sfx.d.ts
 /** A spatial emitter: where the sound is + where the listener is. */
+/** The shape `AudioBuses.record` takes (structural — no import cycle). */
+interface AudioRecord {
+  kind: "preset" | "src" | "music" | "voice";
+  name: string;
+  from: string;
+  bus: "sfx" | "music";
+  at: number;
+}
 interface SpatialPlay {
   /** Emitter world position. */
   position: Vec3;
@@ -615,6 +674,19 @@ declare class SfxEngine {
   private ctx;
   private resolved;
   private readonly pcmCache;
+  /**
+  * 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.
+  */
+  private buses;
+  /** Live continuous voices, so teardown can silence the ones nobody stopped. */
+  private readonly voices;
+  /** @internal Engine wiring. */
+  _setBuses(buses: {
+    record(event: AudioRecord): void;
+  }): void;
   /** True once a backend is present (lazily created on first use). */
   get available(): boolean;
   private ensure;
@@ -624,6 +696,18 @@ declare class SfxEngine {
   * done. Headless returns an inert handle (same call sites, no ifs).
   */
   startVoice(preset: VoicePreset, gain?: number): Voice;
+  /** How many continuous voices are still running (teardown/leak checks). */
+  get liveVoiceCount(): number;
+  /** Silence every continuous voice — the hum must not outlive the game. */
+  stopAll(seconds?: number): void;
+  /**
+  * 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(): void;
   /** Resume a gesture-suspended context (wired to the first user gesture). */
   unlock(): void;
   /**
@@ -634,6 +718,57 @@ declare class SfxEngine {
   play(params: SfxParams, gain: number, opts?: SfxPlayOptions): void;
 }
 //#endregion
+//#region src/core/effects-log.d.ts
+/**
+* What SHOWED — the visual half of the audio record.
+*
+* A game's feedback is sound and vision, and only one of them could be checked.
+* `engine.audio.countOf('coin')` answers "did the coin sound fire?"; nothing
+* answered "did the explosion?". `framing()` says where an emitter IS, which is
+* a different question — a particle system that never fired and one that fired
+* a hundred times sit at the same coordinates.
+*
+* Nothing here renders, so nothing here is measured in pixels. It records that
+* the effect WAS ASKED FOR, which is the wiring question a game actually has:
+* the burst that never happened because the signal was never connected looks
+* exactly like the burst that happened off-screen, and this tells them apart.
+*
+* ```ts
+* session.engine.effects.clearLog();
+* smashTheCrystal();
+* session.step(200);
+* session.engine.effects.countOf('explosion');        // 1
+* session.engine.effects.countFrom('/Game/Crystal/Boom'); // 1
+* ```
+*/
+/** The kinds of thing a game does to say "that happened". */
+type EffectKind = "burst" | "emit" | "trail" | "shake" | "flash" | "hitstop";
+/** One effect that fired. */
+interface EffectEvent {
+  kind: EffectKind;
+  /** The preset name, the flash colour, or `''` when the effect has no name. */
+  name: string;
+  /** Node path, or `engine` for the screen-wide ones. */
+  from: string;
+  /** Particles in the burst, shake magnitude, seconds frozen — the amount. */
+  amount: number;
+  /** `engine.time` when it fired, in seconds. */
+  at: number;
+}
+declare class EffectLog {
+  private readonly events;
+  /** @internal Called by the effects themselves; games read `recent()`. */
+  record(event: EffectEvent): void;
+  /** The last `limit` effects, oldest first. */
+  recent(limit?: number): EffectEvent[];
+  /** How many times an effect with this name fired (`explosion`, `#ff0000`). */
+  countOf(name: string): number;
+  /** How many effects this node fired — the question a wiring check has. */
+  countFrom(path: string): number;
+  /** Forget what has fired so far (between scenes, or between assertions). */
+  clearLog(): void;
+}
+//#endregion
 //#region src/core/input.d.ts
 /**
 * Declarative input from scene JSON `input{}` — DOM-free logic (feed key state
@@ -760,6 +895,20 @@ declare class InputMap {
       connect(fn: () => void): () => void;
     };
   }): () => void;
+  /**
+  * Pointer input from a mouse, a FINGER or a pen — one code path.
+  *
+  * This used to bind `mousedown`/`mousemove`/`mouseup`, which on a phone only
+  * arrive as COMPATIBILITY events: delayed until the browser has decided the
+  * touch is not a scroll, never fired for drags or multi-touch, and suppressed
+  * outright once the surface claims its gestures with `touch-action: none`.
+  * So every genre the comment below lists — match-3, tower defense, card,
+  * point-and-click, RTS — was mouse-only on the device most of them are played
+  * on. Pointer events cover all three input kinds and fire immediately.
+  *
+  * Only the PRIMARY pointer drives it: a second finger (the one on the virtual
+  * stick) must not also swing the camera.
+  */
   attachPointer(target: HTMLElement, opts?: {
     lockOnClick?: boolean;
   }): () => void;
@@ -1306,12 +1455,36 @@ interface QualityCaps {
   minReflectionIntervalMs: number;
 }
 //#endregion
-//#region src/core/stats.d.ts
+//#region src/core/phase-timing.d.ts
 /**
-* Performance-stats shapes — pure data, importable everywhere (core stays
-* three-free; the renderer adapters fill RendererStats from three's
-* `renderer.info`).
+* Where the frame went — the breakdown `stats()` could not give.
+*
+* fps and frameMs are a TOTAL, and a total has no next question. This engine
+* has already lost a day to that: a frame drop everyone attributed to the GPU
+* turned out to be garbage collection, and nothing on screen could have said
+* so. Three of a frame's four parts are the engine's own work, and the fourth
+* is what is left — which is exactly where GC and browser work hide.
+*
+* Means over the same rolling window as `frameMs`, so the numbers are
+* comparable to each other and to the whole.
 */
+/** One frame's own accounting, in milliseconds. */
+interface FramePhases {
+  /** Fixed steps: physics, and anything on `fixedUpdate`. */
+  fixedMs: number;
+  /** The variable update: behaviors, node logic, tweens. */
+  updateMs: number;
+  /** Whatever renders, as reported by it. 0 when nothing does (headless). */
+  renderMs: number;
+  /**
+  * The frame minus the three above. GC, browser layout, input handling,
+  * anything outside the engine's own loop — and the one to look at when the
+  * others are small and the frame is not.
+  */
+  otherMs: number;
+}
+//#endregion
+//#region src/core/stats.d.ts
 /** Loop-side counters from `engine.stats()` — queryable at any time. */
 interface EngineStats {
   /** Frames per second over the last ~60 REAL ticks (headless runs: 0). */
@@ -1329,6 +1502,11 @@ interface EngineStats {
   * this counter exists for.
   */
   errors: number;
+  /**
+  * Where the frame went: fixed (physics), update (behaviors), render, and
+  * everything else. Means over the same window as `frameMs`.
+  */
+  phases: FramePhases;
 }
 /** GPU-side counters from `renderer.stats()` — the LAST rendered frame. */
 interface RendererStats {
@@ -1393,6 +1571,12 @@ declare class Engine {
   *  routes its volume through this; games set it for global volume/mute. */
   readonly audio: 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.
+  */
+  readonly effects: EffectLog;
+  /**
   * Persisted player settings — volume, quality, sensitivity.
   *
   * `createSaveStore` was good and had zero callers, so every game's volume
@@ -1435,6 +1619,10 @@ declare class Engine {
   private accumulator;
   private disposeScheduler;
   private readonly frameStats;
+  /** Where each frame's time went — the breakdown `frameMs` alone cannot give. */
+  private readonly phaseTimings;
+  /** This frame's render cost, as reported by whoever renders. */
+  private renderMs;
   /**
   * Game-time multiplier: 1 = realtime, 0.5 = slow motion, 0 = frozen
   * (hit-stop / pause). Scales BOTH variable and fixed updates — physics,
@@ -1528,6 +1716,15 @@ declare class Engine {
   erroredNodes(): Node[];
   /** Un-skip every quarantined node — the "try again" after you fix the code. */
   resumeErroredNodes(): number;
+  /**
+  * 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: number): void;
   stop(): void;
   /**
   * Live performance counters, queryable at ANY time. fps/frameMs come from a
@@ -1553,12 +1750,17 @@ declare class Engine {
   dispose(): void;
   /**
   * 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(): void;
+  step(opts?: {
+    ignorePause?: boolean;
+  }): void;
   /** Advance the loop manually. First call after (re)start only primes the clock. */
   tick(nowMs: number): void;
 }
@@ -1726,4 +1928,4 @@ declare function registeredBehaviors(): string[];
 /** Test isolation helper. */
 declare function clearBehaviors(): void;
 //#endregion
-export { T_PREFIX as $, SettingsValues as A, LogEntry as At, captureBehaviors as B, EngineStats as C, MusicTrack as Ct, QualityCaps as D, Node as Dt, DeviceHints as E, BusName as Et, BehaviorState as F, ORDER_GROUP_BASE as G, savesWithoutUid as H, RestoreReport as I, effectiveOrder as J, OrderGroup as K, SaveSlot as L, readDeviceHints as M, LogManager as Mt, suggestQuality as N, Signal as Nt, QualityTier as O, NodeLifecycle as Ot, Scene as P, SignalListener as Pt, Localization as Q, SaveSlots as R, Scheduler as S, MusicManager as St, RendererStats as T, AudioBuses as Tt, SaveStore as U, restoreBehaviors as V, createSaveStore as W, BASE_LOCALE as X, resolveOrderGroups as Y, LocaleTables as Z, mergeStaticSignals as _, SfxParams as _t, clearBehaviors as a, isAudioContextAvailable as at, Engine as b, synthSfx as bt, registeredBehaviors as c, Listener as ct, PropSchema as d, SpatialParams as dt, suggestLocale as et, clearRegistry as f, Vec3 as ft, getNodeType as g, SFX_PRESET_NAMES as gt, getNodeSignals as h, SFX_PRESETS as ht, behaviorSignals as i, SfxPlayOptions as it, qualityEnvironment as j, LogLevel as jt, Settings as k, SceneTree as kt, NodeCtor as l, ROLLOFF_MODELS as lt, getNodeSchema as m, spatialPan as mt, BehaviorCtor as n, InputMap as nt, getBehavior as o, Voice as ot, createNode as p, spatialGain as pt, OrderGroupTable as q, behaviorSchema as r, SfxEngine as rt, registerBehavior as s, VoicePreset as st, Behavior as t, translationKey as tt, PropDef as u, RolloffModel as ut, registerNode as v, SfxWave as vt, GameStats as w, PlayMusicOptions as wt, EngineOptions as x, MusicBackend as xt, registeredTypes as y, SynthOptions as yt, behaviorsWithoutSave as z };
+export { T_PREFIX as $, SettingsValues as A, Node as At, captureBehaviors as B, EngineStats as C, synthSfx as Ct, QualityCaps as D, PlayMusicOptions as Dt, DeviceHints as E, MusicTrack as Et, BehaviorState as F, LogManager as Ft, ORDER_GROUP_BASE as G, savesWithoutUid as H, RestoreReport as I, Signal as It, effectiveOrder as J, OrderGroup as K, SaveSlot as L, SignalListener as Lt, readDeviceHints as M, SceneTree as Mt, suggestQuality as N, LogEntry as Nt, QualityTier as O, AudioBuses as Ot, Scene as P, LogLevel as Pt, Localization as Q, SaveSlots as R, Scheduler as S, SynthOptions as St, RendererStats as T, MusicManager as Tt, SaveStore as U, restoreBehaviors as V, createSaveStore as W, BASE_LOCALE as X, resolveOrderGroups as Y, LocaleTables as Z, mergeStaticSignals as _, spatialPan as _t, clearBehaviors as a, EffectLog as at, Engine as b, SfxParams as bt, registeredBehaviors as c, isAudioContextAvailable as ct, PropSchema as d, Listener as dt, suggestLocale as et, clearRegistry as f, ROLLOFF_MODELS as ft, getNodeType as g, spatialGain as gt, getNodeSignals as h, Vec3 as ht, behaviorSignals as i, EffectKind as it, qualityEnvironment as j, NodeLifecycle as jt, Settings as k, BusName as kt, NodeCtor as l, Voice as lt, getNodeSchema as m, SpatialParams as mt, BehaviorCtor as n, InputMap as nt, getBehavior as o, SfxEngine as ot, createNode as p, RolloffModel as pt, OrderGroupTable as q, behaviorSchema as r, EffectEvent as rt, registerBehavior as s, SfxPlayOptions as st, Behavior as t, translationKey as tt, PropDef as u, VoicePreset as ut, registerNode as v, SFX_PRESETS as vt, GameStats as w, MusicBackend as wt, EngineOptions as x, SfxWave as xt, registeredTypes as y, SFX_PRESET_NAMES as yt, behaviorsWithoutSave as z };

package/dist/{create-game-B_e9hJf7.js → create-game-BRt6XKmP.js}

@@ -1,13 +1,13 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { A as registerBehavior, C as diagnose, n as loadScene, o as computeViewport, s as resolveViewport } from "./loader-B-Gft32x.js";
-import { h as Engine, m as AudioPlayer } from "./register-DVwlnZAZ.js";
+import { A as registerBehavior, C as diagnose, n as loadScene, o as computeViewport, s as resolveViewport } from "./loader-BTkHYrQn.js";
+import { b as AudioPlayer, x as Engine } from "./register-p48lHE2o.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
-import { i as resolveRendering, n as attachTouchControls } from "./touch-BoNg_MnF.js";
-import { a as openBundledEditor, i as devServerLibrary, n as pauseWhenHidden, r as crossFade, t as teardown } from "./teardown-ks3d5W9n.js";
-import { n as registerGameplayBehaviors } from "./gameplay-B6jqvYeM.js";
-import { g as PhysicsBody2D, n as UILayer, t as registerNodes2D, u as Camera2D, y as Node2D } from "./register-Trx7WHnD.js";
+import { i as resolveRendering, n as attachTouchControls } from "./touch-BnMyy9tr.js";
+import { a as openBundledEditor, c as audioErrors, i as devServerLibrary, n as pauseWhenHidden, r as crossFade, s as claimCanvasGestures, t as teardown } from "./teardown-C7uVSJvx.js";
+import { n as registerGameplayBehaviors } from "./gameplay-CZ2yq37J.js";
+import { g as PhysicsBody2D, n as UILayer, t as registerNodes2D, u as Camera2D, y as Node2D } from "./register-en63AEZO.js";
 import { t as debugSources } from "./debug-draw-BM3DsvtT.js";
-import { n as enablePhysics2D } from "./physics-2d-Dns-oZlE.js";
+import { n as enablePhysics2D } from "./physics-2d-CfWAggJ1.js";
 import { Box3, BufferAttribute, BufferGeometry, Color, LineBasicMaterial, LineSegments, LinearFilter, NearestFilter, OrthographicCamera, Raycaster, SRGBColorSpace, Scene, TextureLoader, Vector2, Vector3, WebGLRenderer } from "three";
 //#region src/2d/assets.ts
 /**
@@ -333,7 +333,11 @@ var Renderer2D = class {
 		this.selectionLines.renderOrder = 1e4;
 		this.selectionLines.visible = false;
 		this.worldScene.add(this.selectionLines);
-		this.disconnect = this.engine.updated.connect(() => this.render());
+		this.disconnect = this.engine.updated.connect(() => {
+			const started = performance.now();
+			this.render();
+			this.engine.noteRenderMs(performance.now() - started);
+		});
 	}
 	debugLines;
 	selectionLines;
@@ -625,10 +629,15 @@ async function createGame2D(opts) {
 	const cleanups = [];
 	const keyboard = opts.keyboard ?? (typeof window !== "undefined" ? window : false);
 	if (keyboard) engine.input.attachKeyboard(keyboard);
+	if (opts.pointer) {
+		const lockOnClick = typeof opts.pointer === "object" ? opts.pointer.lockOnClick ?? false : false;
+		engine.input.attachPointer(opts.canvas, { lockOnClick });
+	}
 	cleanups.push(wireAudioUnlock(engine, scene.root, opts.canvas));
 	cleanups.push(engine.settings.bindAudio(engine.audio));
 	cleanups.push(pauseWhenHidden(engine));
 	cleanups.push(engine.settings.bindLocale(engine.locale));
+	if (!opts.pageGestures) claimCanvasGestures(opts.canvas);
 	const touchMode = opts.touch ?? "auto";
 	if (touchMode !== false) {
 		const host = opts.touchContainer ?? opts.canvas.parentElement ?? null;
@@ -718,6 +727,9 @@ async function createGame2D(opts) {
 		pick(x, y) {
 			return engine.picker?.(x, y) ?? null;
 		},
+		assetErrors() {
+			return [...renderer.assets?.errors() ?? [], ...audioErrors(engine.scene?.tree.root)];
+		},
 		stats() {
 			return {
 				triangles: 0,
@@ -755,10 +767,17 @@ function wireAudioUnlock(engine, root, canvas) {
 		target: canvasTarget,
 		type: "pointerdown"
 	});
-	if (typeof window !== "undefined") sources.push({
-		target: window,
-		type: "keydown"
-	});
+	if (typeof window !== "undefined") {
+		const win = window;
+		sources.push({
+			target: win,
+			type: "keydown"
+		});
+		sources.push({
+			target: win,
+			type: "pointerdown"
+		});
+	}
 	if (sources.length === 0) return () => {};
 	function detachAll() {
 		for (const s of sources) s.target.removeEventListener?.(s.type, unlock);

package/dist/{create-game-CGnoypjL.js → create-game-Czzp6ZuE.js}

@@ -1,15 +1,15 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { A as registerBehavior, C as diagnose, n as loadScene } from "./loader-B-Gft32x.js";
-import { _ as qualityCaps, h as Engine, m as AudioPlayer, y as qualityRendering } from "./register-DVwlnZAZ.js";
+import { A as registerBehavior, C as diagnose, n as loadScene } from "./loader-BTkHYrQn.js";
+import { C as qualityCaps, T as qualityRendering, b as AudioPlayer, x as Engine } from "./register-p48lHE2o.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
-import { r as parseDrive, t as logReport } from "./log-report-lxrQY9cH.js";
-import { i as resolveRendering, n as attachTouchControls } from "./touch-BoNg_MnF.js";
-import { a as openBundledEditor, i as devServerLibrary, n as pauseWhenHidden, o as poseFromRenderer, r as crossFade, t as teardown } from "./teardown-ks3d5W9n.js";
-import { I as PhysicsBody3D, V as createCausticsQuad, n as registerGameplayBehaviors, z as Node3D } from "./gameplay-B6jqvYeM.js";
+import { r as parseDrive, t as logReport } from "./log-report-CPFm4OXf.js";
+import { i as resolveRendering, n as attachTouchControls } from "./touch-BnMyy9tr.js";
+import { a as openBundledEditor, c as audioErrors, i as devServerLibrary, n as pauseWhenHidden, o as poseFromRenderer, r as crossFade, s as claimCanvasGestures, t as teardown } from "./teardown-C7uVSJvx.js";
+import { I as PhysicsBody3D, V as createCausticsQuad, n as registerGameplayBehaviors, z as Node3D } from "./gameplay-CZ2yq37J.js";
 import { t as debugSources } from "./debug-draw-BM3DsvtT.js";
-import { E as Camera3D, U as TextureCache3D, g as ModelInstance3D, n as registerNodes3D, t as resolveEnvironmentHdri, v as DirectionalLight3D } from "./environment-presets-DSZwsKPs.js";
+import { E as Camera3D, U as TextureCache3D, g as ModelInstance3D, n as registerNodes3D, t as resolveEnvironmentHdri, v as DirectionalLight3D } from "./environment-presets-BQ_QsIBY.js";
 import { a as frameSignature, i as frameImage, o as frameStats } from "./frame-report-njybhZon.js";
-import { n as enablePhysics3D } from "./physics-3d-BhI0ehpe.js";
+import { n as enablePhysics3D } from "./physics-3d-Bes-GIuR.js";
 import { ACESFilmicToneMapping, AmbientLight, Box3, BufferAttribute, BufferGeometry, Color, DepthTexture, EquirectangularReflectionMapping, FloatType, Fog, HalfFloatType, LineBasicMaterial, LineSegments, Matrix4, Mesh, PCFShadowMap, PMREMGenerator, PerspectiveCamera, PlaneGeometry, Quaternion, Raycaster, Scene, ShaderMaterial, Vector2, Vector3, WebGLRenderTarget, WebGLRenderer } from "three";
 import { VRMLoaderPlugin, VRMUtils } from "@pixiv/three-vrm";
 import { GLTFLoader } from "three/addons/loaders/GLTFLoader.js";
@@ -1670,7 +1670,11 @@ var Renderer3D = class {
 		this.selectionLines.renderOrder = 1e4;
 		this.selectionLines.visible = false;
 		this.threeScene.add(this.selectionLines);
-		this.disconnect = this.engine.updated.connect(() => this.render());
+		this.disconnect = this.engine.updated.connect(() => {
+			const started = performance.now();
+			this.render();
+			this.engine.noteRenderMs(performance.now() - started);
+		});
 	}
 	/** The pixel ratio the scene ASKED for — the governor scales this, never replaces it. */
 	basePixelRatio;
@@ -2349,6 +2353,7 @@ async function createGame3D(opts) {
 		engine.input.attachPointer(opts.canvas, { lockOnClick });
 	}
 	cleanups.push(wireAudioUnlock(engine, scene.root, opts.canvas));
+	if (!opts.pageGestures) claimCanvasGestures(opts.canvas);
 	const touchMode = opts.touch ?? "auto";
 	if (touchMode !== false) {
 		const host = opts.touchContainer ?? opts.canvas.parentElement ?? null;
@@ -2575,7 +2580,7 @@ async function createGame3D(opts) {
 		renderer,
 		physics,
 		assetErrors() {
-			return renderer.assets?.errors() ?? [];
+			return [...renderer.assets?.errors() ?? [], ...audioErrors(engine.scene?.tree.root)];
 		},
 		async frame(frameOpts) {
 			const capture = renderer.captureFrame;
@@ -2623,10 +2628,17 @@ function wireAudioUnlock(engine, root, canvas) {
 		target: canvasTarget,
 		type: "pointerdown"
 	});
-	if (typeof window !== "undefined") sources.push({
-		target: window,
-		type: "keydown"
-	});
+	if (typeof window !== "undefined") {
+		const win = window;
+		sources.push({
+			target: win,
+			type: "keydown"
+		});
+		sources.push({
+			target: win,
+			type: "pointerdown"
+		});
+	}
 	if (sources.length === 0) return () => {};
 	function detachAll() {
 		for (const s of sources) s.target.removeEventListener?.(s.type, unlock);

package/dist/debug.d.ts

@@ -1,4 +1,4 @@
-import { T as RendererStats, b as Engine, jt as LogLevel } from "./behavior-uPEuZrUB.js";
+import { Pt as LogLevel, T as RendererStats, b as Engine } from "./behavior-CyQoSu4n.js";
 
 //#region src/debug/panel.d.ts
 /** Minimal document surface the overlay needs (injectable for tests). */

package/dist/debug.js

@@ -1600,7 +1600,7 @@ var DebugOverlay = class {
 	*/
 	nextFrame() {
 		if (!this.paused) this.setPaused(true);
-		this.engine.step();
+		this.engine.step({ ignorePause: true });
 		this.syncTime();
 	}
 	/** Push the engine's current time state into the panel, without rebuilding it. */

package/dist/{duplicate-B-OtSRFL.js → duplicate-MNLMAcbz.js}

@@ -1,4 +1,4 @@
-import { i as serializeNode, t as buildNodeJson } from "./loader-B-Gft32x.js";
+import { i as serializeNode, t as buildNodeJson } from "./loader-BTkHYrQn.js";
 //#region src/core/scene/duplicate.ts
 function stripUids(json) {
 	const { uid: _uid, ...rest } = json;

package/dist/editor.js

@@ -1181,6 +1181,20 @@ var kt = {
 				en: "Options are the locales the scene declares in \"strings\", each labeled with its own endonym. Picking one switches the game live and persists it. English is the base: any key a locale omits falls back to it, on purpose.",
 				ko: "옵션은 씬의 \"strings\"가 선언한 로케일이며, 각 언어의 자기 이름으로 표시됩니다. 선택하면 즉시 바뀌고 저장됩니다. 영어가 기준이라 로케일이 빠뜨린 키는 의도적으로 영어로 표시됩니다."
 			}),
+			L("UiVolumeSlider", {
+				en: "A volume slider, already wired to a bus.",
+				ko: "볼륨 슬라이더 — 버스에 이미 연결되어 있습니다."
+			}, {
+				en: "bus picks which one it owns: master (everything), sfx or music. It writes engine.audio, which persists itself, so nothing needs saving. Left unlabelled it names its own bus. Two of them (music + sfx) is the audio menu most games ship.",
+				ko: "bus로 어느 볼륨을 맡을지 고릅니다 — master(전체), sfx, music. engine.audio에 쓰면 자동 저장되므로 따로 저장할 게 없습니다. label을 비워두면 버스 이름이 표시됩니다. 대부분의 게임은 music + sfx 두 개면 충분합니다."
+			}),
+			L("UiMuteToggle", {
+				en: "The mute switch — checked means silent.",
+				ko: "음소거 스위치 — 체크하면 소리가 꺼집니다."
+			}, {
+				en: "Writes engine.audio.muted and persists with the volumes. Follows a mute made anywhere else, so two menus can never disagree.",
+				ko: "engine.audio.muted에 쓰고 볼륨과 함께 저장됩니다. 다른 곳에서 음소거해도 따라가므로 두 메뉴가 어긋나지 않습니다."
+			}),
 			L("UiQualitySelect", {
 				en: "Graphics quality — Low, Medium, High. Already wired.",
 				ko: "그래픽 품질 — Low, Medium, High. 이미 연결되어 있습니다."