incanto 0.36.2 → 0.38.0

package/dist/{register-BHAwM4bK.js → register-Dm7nrd-E.js}

@@ -1,4 +1,4 @@
-import { E as Signal, _ as InputMap, b as behaviorSchema, f as Node, g as resolveOrderGroups, m as ORDER_GROUP_BASE, v as diagnose } from "./loader-DAZlgqeC.js";
+import { E as Signal, _ as InputMap, b as behaviorSchema, f as Node, g as resolveOrderGroups, m as ORDER_GROUP_BASE, v as diagnose } from "./loader-r49nDwB4.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { t as Rng } from "./rng-DP-SR7eg.js";
 import { l as registerNode } from "./registry-IyWCGe4q.js";
@@ -1403,7 +1403,10 @@ const DEFAULTS = {
 	sensitivity: 1,
 	invertY: false,
 	reduceMotion: false,
-	language: "en"
+	language: "en",
+	qualityChosen: false,
+	maxFps: 0,
+	renderScale: 1
 };
 const TIERS = [
 	"low",
@@ -1469,6 +1472,64 @@ var Settings = class {
 		for (const key of Object.keys(DEFAULTS)) this.set(key, DEFAULTS[key]);
 	}
 	/**
+	* Choose a starting tier from the device, ONCE.
+	*
+	* Only on a first visit: after someone has picked a tier, re-detecting on
+	* every launch would silently undo their choice — which is the behaviour every
+	* player experiences as "the settings do not save".
+	*/
+	autoQuality(hints = readDeviceHints()) {
+		if (!this.values.qualityChosen) this.values.quality = suggestQuality(hints);
+		return this.values.quality;
+	}
+	/** Record that the tier came from a person, not from the device probe. */
+	chooseQuality(tier) {
+		this.set("quality", tier);
+		this.set("qualityChosen", true);
+	}
+	/**
+	* Apply the saved quality tier to a live scene, and keep applying it.
+	*
+	* The same shape as `bindAudio` and `bindLocale`. Until 0.38 this did not
+	* exist: `settings.quality` was written to disk and read by NOBODY, and
+	* `qualityEnvironment` — the function that turns a tier into something the
+	* renderer understands — emitted patches the environment parser rejects, for
+	* all three tiers. Both were public, documented and never once called.
+	*/
+	bindQuality(apply) {
+		apply(qualityEnvironment(this.values.quality));
+		return this.changed.connect((key) => {
+			if (key === "quality") apply(qualityEnvironment(this.values.quality));
+		});
+	}
+	/**
+	* Apply the saved frame cap, and again whenever it changes.
+	*
+	* Separate from `bindQuality` because it is not a tier: a player caps the
+	* frame rate to keep a phone cool or a battery alive, on the highest visual
+	* settings the device can hold, and those two choices do not belong on one
+	* slider. 0 means uncapped. Returns the unsubscribe.
+	*/
+	bindFrameCap(apply) {
+		apply(this.values.maxFps);
+		return this.changed.connect((key) => {
+			if (key === "maxFps") apply(this.values.maxFps);
+		});
+	}
+	/**
+	* Apply the saved resolution multiplier, and again whenever it changes.
+	*
+	* The lever that buys the most frames per unit of ugliness on a weak GPU —
+	* shading 44% of the pixels at 0.66 costs a soft image and nothing else,
+	* while dropping a quality tier costs shadows entirely.
+	*/
+	bindRenderScale(apply) {
+		apply(this.values.renderScale);
+		return this.changed.connect((key) => {
+			if (key === "renderScale") apply(this.values.renderScale);
+		});
+	}
+	/**
 	* Apply the saved language, and keep it in step both ways.
 	*
 	* The same shape as `bindAudio`: a game that writes
@@ -1502,45 +1563,67 @@ var Settings = class {
 	}
 };
 /**
-* What a quality tier MEANS, as an environment patch.
+* What a quality tier MEANS, as a LIVE environment patch.
+*
+* Only the levers that actually cost: shadows, post, bloom and clouds.
+* Deliberately an `environment` patch, because `setEnvironment3D(engine, patch)`
+* already applies one live and validated — this is not a second rendering
+* pipeline, it is three presets for the one that exists.
 *
-* Only the levers that actually cost: shadows, post, clouds, and the resolution
-* the renderer draws at. Deliberately an `environment` patch, because
-* `setEnvironment3D(engine, patch)` already applies one live and validated —
-* this is not a second rendering pipeline, it is three presets for the one that
-* exists.
+* The `off` spelling matters and got this wrong for three releases: every tier
+* emitted `{ enabled: false }`, which the environment parser rejects
+* (`environment.bloom has unknown key 'enabled'`). Nothing called this function,
+* so nothing found out. In a live patch `null` DELETES a key — that is how a
+* stage is turned off — and `shadows` alone takes a real `false`.
+*
+* Antialiasing and pixel ratio are NOT here: `antialias` is a WebGL context
+* attribute and cannot change without rebuilding the renderer. See
+* `qualityRendering`.
 */
 function qualityEnvironment(tier) {
 	if (tier === "low") return {
-		shadows: { enabled: false },
-		bloom: { enabled: false },
-		post: { enabled: false },
-		clouds: { enabled: false },
-		rendering: {
-			antialias: false,
-			pixelRatio: 1
-		}
+		shadows: false,
+		bloom: null,
+		post: null,
+		clouds: null
 	};
 	if (tier === "medium") return {
-		shadows: {
-			enabled: true,
-			static: true
-		},
-		bloom: { enabled: true },
-		post: { enabled: false },
-		rendering: {
-			antialias: true,
-			pixelRatio: 1
-		}
+		shadows: { static: true },
+		bloom: {},
+		post: null
 	};
 	return {
-		shadows: { enabled: true },
-		bloom: { enabled: true },
-		post: { enabled: true },
-		rendering: {
-			antialias: true,
-			pixelRatio: "device"
-		}
+		shadows: true,
+		bloom: {},
+		post: {}
+	};
+}
+/**
+* What a quality tier means for the levers that can only be set at BOOT.
+*
+* `antialias` is a context attribute: three fixes it when the WebGL context is
+* created, so a settings menu that changes it is choosing what the NEXT launch
+* gets. Every engine has this constraint and every game's options screen says
+* "requires restart" next to it — `createGame3D` reads the saved tier at boot,
+* so the restart is all it takes.
+*
+* `pixelRatio` CAN change live (adaptive resolution already does it), but it
+* belongs with antialias as "how many pixels do we draw" rather than "what is in
+* the scene".
+*/
+function qualityRendering(tier) {
+	const device = Math.min(globalThis.devicePixelRatio ?? 1, 2);
+	if (tier === "low") return {
+		antialias: false,
+		pixelRatio: 1
+	};
+	if (tier === "medium") return {
+		antialias: true,
+		pixelRatio: Math.min(device, 1.5)
+	};
+	return {
+		antialias: true,
+		pixelRatio: device
 	};
 }
 //#endregion
@@ -1671,6 +1754,7 @@ var Engine = class {
 		this.maxFixedSteps = opts.maxFixedStepsPerTick ?? 5;
 		this.scheduler = opts.scheduler ?? rafScheduler;
 		this.rng = new Rng(opts.seed ?? Math.random() * 4294967295 >>> 0);
+		this.maxFps = opts.maxFps ?? 0;
 	}
 	get scene() {
 		return this._scene;
@@ -1693,6 +1777,7 @@ var Engine = class {
 	start() {
 		if (this.disposeScheduler) return;
 		this.disposeScheduler = this.scheduler((now) => {
+			if (!this.frameIsDue(now)) return;
 			try {
 				this.tick(now);
 			} catch (error) {
@@ -1701,6 +1786,51 @@ var Engine = class {
 		});
 	}
 	/**
+	* The frame cap: fps, or 0 for "as fast as the display goes" (the default).
+	*
+	* Live — a settings menu writes it mid-game. It gates the whole frame, not
+	* just the render: an uncapped loop on a 144 Hz phone burns battery running
+	* game logic nobody sees.
+	*
+	* `tick()` is deliberately NOT gated. A headless harness driving its own
+	* clock asked for that frame; the cap is about the real-time loop.
+	*/
+	maxFps = 0;
+	nextFrameAt = 0;
+	lastOfferedAt = null;
+	displayPeriodMs = 0;
+	/**
+	* Should this display frame run?
+	*
+	* The obvious `if (now - last < interval) return` is wrong in a way that only
+	* shows up between the round numbers: a 45 fps cap on a 60 Hz display misses
+	* every other deadline by a fraction of a millisecond, waits a whole display
+	* frame more, and delivers 30 — asking for 45 makes the game slower than not
+	* capping at all. The fix is to allow a frame that is within half a display
+	* period of its deadline, and to advance the deadline by the interval rather
+	* than from `now`, so the error does not accumulate.
+	*/
+	frameIsDue(now) {
+		const prev = this.lastOfferedAt;
+		this.lastOfferedAt = now;
+		if (prev !== null) {
+			const delta = now - prev;
+			if (delta > 0 && delta < 500) this.displayPeriodMs = this.displayPeriodMs === 0 ? delta : this.displayPeriodMs * .9 + delta * .1;
+		}
+		if (!(this.maxFps > 0)) {
+			this.nextFrameAt = 0;
+			return true;
+		}
+		const interval = 1e3 / this.maxFps;
+		if (this.nextFrameAt === 0) {
+			this.nextFrameAt = now + interval;
+			return true;
+		}
+		if (now < this.nextFrameAt - this.displayPeriodMs * .5) return false;
+		this.nextFrameAt = Math.max(now, this.nextFrameAt + interval);
+		return true;
+	}
+	/**
 	* A frame threw somewhere outside a single node (a renderer, physics, a
 	* signal handler). Report the first one and count the rest: a broken frame
 	* repeats sixty times a second, and sixty identical traces a second is how
@@ -3241,6 +3371,161 @@ var UiLanguageSelect = class extends UiSelect {
 		return ENDONYMS[value] ?? value;
 	}
 };
+/**
+* A select bound to one persisted setting — the shape all three graphics
+* controls share.
+*
+* The engine owns quality tiers, the frame cap and the resolution scale, and
+* every one of them was reachable only from TypeScript. A vibe-coded game whose
+* whole world is JSON could not put a graphics menu on screen without a
+* behavior, a signal connection, and the knowledge that `Settings` persists —
+* which is how "supports low-end devices" quietly becomes "does not".
+*
+* Subclasses say which setting, what the options are, and what they read as.
+*/
+var UiSettingSelect = class extends UiSelect {
+	/** Last value we PUSHED into the select, to tell an engine change from a player one. */
+	lastPushed = null;
+	_engine() {
+		return this.tree?.engine ?? null;
+	}
+	/**
+	* The translated option label, or the English one.
+	*
+	* `locale.t` returns the KEY when nothing declares it, and a menu reading
+	* `settings.quality.high` is worse than one reading `High`. English is the
+	* base language and the fallback, always.
+	*/
+	_tOr(key, fallback) {
+		const locale = this._engine()?.locale;
+		return locale?.has(key) ? locale.t(key) : fallback;
+	}
+	_sync() {
+		const engine = this._engine();
+		if (engine) {
+			const stored = this._read(engine);
+			if (stored !== this.lastPushed) {
+				this.lastPushed = stored;
+				this.value = stored;
+			} else if (this.value !== stored) {
+				this._write(engine, this.value);
+				this.lastPushed = this._read(engine);
+			}
+		}
+		super._sync();
+	}
+};
+/**
+* The graphics quality picker.
+*
+* ```json
+* { "name": "Quality", "type": "UiQualitySelect" }
+* ```
+*
+* Writes through `chooseQuality`, NOT `set('quality')`: a tier a person picked
+* has to survive the next launch's device detection, and the two are
+* indistinguishable afterwards unless the choice is recorded as one.
+*
+* Shadows, bloom, post and clouds follow immediately. Antialiasing follows on
+* the next launch — it is a WebGL context attribute and cannot change while a
+* context exists.
+*/
+var UiQualitySelect = class extends UiSettingSelect {
+	static typeName = "UiQualitySelect";
+	static props = {
+		...UiSelect.props,
+		label: { default: "Quality" },
+		options: { default: "low,medium,high" }
+	};
+	label = "Quality";
+	options = "low,medium,high";
+	_key() {
+		return "quality";
+	}
+	_read(engine) {
+		return String(engine.settings.get("quality"));
+	}
+	_write(engine, value) {
+		if (value === "low" || value === "medium" || value === "high") engine.settings.chooseQuality(value);
+	}
+	_optionLabel(value) {
+		const english = value.charAt(0).toUpperCase() + value.slice(1);
+		return this._tOr(`settings.quality.${value}`, english);
+	}
+};
+/**
+* The frame-rate cap: fewer frames, a cooler phone, a longer battery.
+*
+* ```json
+* { "name": "FrameCap", "type": "UiFrameCapSelect" }
+* ```
+*
+* `0` is uncapped and is the default — a cap nobody asked for is a downgrade.
+* The cap gates the whole frame, so it saves the CPU as well as the GPU.
+*/
+var UiFrameCapSelect = class extends UiSettingSelect {
+	static typeName = "UiFrameCapSelect";
+	static props = {
+		...UiSelect.props,
+		label: { default: "Frame rate" },
+		/** `0` means uncapped and reads as a word, not as a number. */
+		options: { default: "30,60,120,0" }
+	};
+	label = "Frame rate";
+	options = "30,60,120,0";
+	_key() {
+		return "maxFps";
+	}
+	_read(engine) {
+		return String(engine.settings.get("maxFps"));
+	}
+	_write(engine, value) {
+		const fps = Number(value);
+		if (!Number.isFinite(fps) || fps < 0) return;
+		engine.settings.set("maxFps", fps);
+		engine.maxFps = fps;
+	}
+	_optionLabel(value) {
+		if (value === "0") return this._tOr("settings.frameCap.unlimited", "Unlimited");
+		return value;
+	}
+};
+/**
+* The resolution scale — the cheapest frames on a weak GPU.
+*
+* ```json
+* { "name": "Resolution", "type": "UiRenderScaleSelect" }
+* ```
+*
+* At 75% the fragment shaders run over 56% of the pixels for a slightly softer
+* image and nothing else, where dropping a quality tier costs the shadows
+* outright. Reads as a percentage, because `0.75` means nothing to a player.
+*/
+var UiRenderScaleSelect = class extends UiSettingSelect {
+	static typeName = "UiRenderScaleSelect";
+	static props = {
+		...UiSelect.props,
+		label: { default: "Resolution" },
+		options: { default: "0.5,0.75,1" }
+	};
+	label = "Resolution";
+	options = "0.5,0.75,1";
+	_key() {
+		return "renderScale";
+	}
+	_read(engine) {
+		return String(engine.settings.get("renderScale"));
+	}
+	_write(engine, value) {
+		const scale = Number(value);
+		if (!Number.isFinite(scale) || scale <= 0) return;
+		engine.settings.set("renderScale", scale);
+	}
+	_optionLabel(value) {
+		const pct = Math.round(Number(value) * 100);
+		return Number.isFinite(pct) ? `${pct}%` : value;
+	}
+};
 //#endregion
 //#region src/core/register.ts
 /**
@@ -3264,6 +3549,9 @@ function registerCoreNodes() {
 	registerNode(UiToggle);
 	registerNode(UiSelect);
 	registerNode(UiLanguageSelect);
+	registerNode(UiQualitySelect);
+	registerNode(UiFrameCapSelect);
+	registerNode(UiRenderScaleSelect);
 }
 //#endregion
-export { translationKey as A, WebAudioMusicBackend as B, restoreBehaviors as C, Localization as D, BASE_LOCALE as E, spatialPan as F, fadeGain as H, SFX_PRESETS as I, SFX_PRESET_NAMES as L, isAudioContextAvailable as M, ROLLOFF_MODELS as N, T_PREFIX as O, spatialGain as P, synthSfx as R, captureBehaviors as S, LogManager as T, AudioBuses as U, crossfadeGains as V, qualityEnvironment as _, UiSlider as a, SaveSlots as b, UiButton as c, UiBanner as d, UiBar as f, Settings as g, Engine as h, UiSelect as i, SfxEngine as j, suggestLocale 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, readDeviceHints as v, createSaveStore as w, behaviorsWithoutSave as x, suggestQuality as y, MusicManager as z };
+export { suggestLocale as A, MusicManager as B, captureBehaviors as C, BASE_LOCALE as D, LogManager as E, spatialGain as F, crossfadeGains as H, spatialPan as I, SFX_PRESETS as L, SfxEngine as M, isAudioContextAvailable as N, Localization as O, ROLLOFF_MODELS as P, SFX_PRESET_NAMES as R, behaviorsWithoutSave as S, createSaveStore as T, fadeGain as U, WebAudioMusicBackend as V, AudioBuses as W, qualityEnvironment as _, UiSlider as a, suggestQuality as b, UiButton as c, UiBanner as d, UiBar as f, Settings as g, Engine as h, UiSelect as i, translationKey as j, T_PREFIX 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, qualityRendering as v, restoreBehaviors as w, SaveSlots as x, readDeviceHints as y, synthSfx as z };

package/dist/{register-COGCNitr.js → register-DnB9m7Rl.js}

@@ -1,5 +1,5 @@
-import { f as Node, h as effectiveOrder } from "./loader-DAZlgqeC.js";
-import { t as registerCoreNodes } from "./register-BHAwM4bK.js";
+import { f as Node, h as effectiveOrder } from "./loader-r49nDwB4.js";
+import { t as registerCoreNodes } from "./register-Dm7nrd-E.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-IyWCGe4q.js";

package/dist/replay-Cxrr-ApH.d.ts

@@ -0,0 +1,86 @@
+import { b as Engine } from "./behavior-B5PJ32eu.js";
+import { s as JsonObject } from "./schema-CFeioQRE.js";
+
+//#region src/core/audit.d.ts
+/** Human-readable warnings (empty = clean). Pure JSON walk, no registry. */
+declare function auditScene(scene: JsonObject): string[];
+//#endregion
+//#region src/core/errors.d.ts
+/**
+* Stable error codes for every hard failure in the engine.
+*
+* Incanto fails loudly with machine-readable codes and messages that list valid
+* alternatives — AI agents self-correct on hard failures, not warnings.
+*/
+type IncantoErrorCode = "BAD_FORMAT" | "BAD_NODE_PATH" | "DANGLING_CONNECTION" | "DUPLICATE_BEHAVIOR" | "DUPLICATE_NODE_TYPE" | "DUPLICATE_UNIQUE_NAME" | "DUPLICATE_UID" | "NODE_NOT_FOUND" | "PROP_TYPE_MISMATCH" | "TREE_VIOLATION" | "UNKNOWN_ANIMATION" | "UNKNOWN_ASSET" | "UNKNOWN_CONSTANT" | "UNKNOWN_BEHAVIOR" | "UNKNOWN_HANDLER" | "UNKNOWN_NODE_TYPE" | "UNKNOWN_PROP" | "UNKNOWN_SIGNAL" | "UNRESOLVED_INSTANCE";
+/**
+* Structured context mirrored from the prose message — tools and agents parse
+* THESE instead of regexing the message (which is for humans and may reword).
+*/
+interface IncantoErrorDetails {
+  /** Absolute path of the offending node in the scene being loaded ('/Root/Child'). */
+  readonly path?: string;
+  /** The offending node's uid, when the scene JSON declared one. */
+  readonly uid?: string;
+  /** The offending node's type name. */
+  readonly nodeType?: string;
+  /** The offending prop key. */
+  readonly prop?: string;
+  /** The offending signal name. */
+  readonly signal?: string;
+  /** The valid alternatives the message also lists — for programmatic self-correction. */
+  readonly validOptions?: readonly string[];
+}
+declare class IncantoError extends Error {
+  readonly code: IncantoErrorCode;
+  readonly details: IncantoErrorDetails;
+  constructor(code: IncantoErrorCode, message: string, details?: IncantoErrorDetails);
+}
+//#endregion
+//#region src/core/replay.d.ts
+/**
+* Deterministic input replay — the engine already runs on a seeded RNG and
+* an injectable clock, so a recording of (tick timestamps + input events)
+* replays BIT-IDENTICALLY into a fresh engine with the same seed and scene.
+* That turns "does my game still work?" into an assertion an agent can run
+* headlessly: record once while playing, replay forever as a regression.
+*
+*   const rec = startRecording(engine);            // play the game...
+*   const replayJson = rec.stop();                 // ...save this JSON
+*
+*   const fresh = new Engine({ seed: SAME_SEED }); // same seed + scene JSON
+*   fresh.setScene(loadScene(sceneJson));
+*   replay(fresh, replayJson);                     // now assert game state
+*
+* Caveats (documented, by design): game code must use `engine.rng` (not
+* Math.random) and dt/engine.time (not Date.now) — the engine's own rules.
+* Gamepad polling is not recorded (bind pads to actions; actions replay).
+*/
+/** [tickIndex, methodName, ...primitive args] */
+type ReplayEvent = [number, string, ...(string | number | boolean)[]];
+interface ReplayJson {
+  /** File-format marker for forward compatibility. */
+  replay: 1;
+  /** Tick timestamps (ms) exactly as the loop delivered them. */
+  ticks: number[];
+  events: ReplayEvent[];
+}
+interface Recorder {
+  /** Detach the taps and return the recording. */
+  stop(): ReplayJson;
+}
+/**
+* Tap the engine's input entry points and tick clock. Recording starts at
+* the CURRENT moment — start it before the first tick for full-run replays.
+*/
+declare function startRecording(engine: Engine): Recorder;
+/**
+* Drive a fresh engine through a recording: for each recorded tick, feed
+* that tick's input events first, then tick with the recorded timestamp.
+* `onTick(index)` lets tests assert mid-run state.
+*/
+declare function replay(engine: Engine, recording: ReplayJson, opts?: {
+  onTick?: (index: number) => void;
+}): void;
+//#endregion
+export { startRecording as a, IncantoErrorDetails as c, replay as i, auditScene as l, ReplayEvent as n, IncantoError as o, ReplayJson as r, IncantoErrorCode as s, Recorder as t };

package/dist/{audit-D7F3n3Nt.js → replay-DH0UOuZ-.js}

@@ -1,4 +1,4 @@
-import { A as translationKey } from "./register-BHAwM4bK.js";
+import { j as translationKey } from "./register-Dm7nrd-E.js";
 //#region src/core/audit.ts
 const ANIMATED_TYPES = new Set([
 	"Particles2D",
@@ -108,4 +108,74 @@ function auditStrings(scene) {
 	return [`${listed.length} translation key${listed.length === 1 ? "" : "s"} nothing declares: ${listed.join(", ")}. The key itself renders on screen. Add them under "strings": { "en": { ... } } — other locales may omit any of them and fall back to English.`];
 }
 //#endregion
-export { auditScene as t };
+//#region src/core/replay.ts
+const RECORDED_METHODS = [
+	"handleKey",
+	"handleMouseButton",
+	"handlePointerMove",
+	"handleWheel",
+	"pressAction",
+	"releaseAction"
+];
+/**
+* Tap the engine's input entry points and tick clock. Recording starts at
+* the CURRENT moment — start it before the first tick for full-run replays.
+*/
+function startRecording(engine) {
+	const ticks = [];
+	const events = [];
+	const input = engine.input;
+	const originals = /* @__PURE__ */ new Map();
+	for (const name of RECORDED_METHODS) {
+		const original = input[name];
+		originals.set(name, original);
+		input[name] = (...args) => {
+			events.push([
+				ticks.length,
+				name,
+				...args
+			]);
+			return original.apply(engine.input, args);
+		};
+	}
+	const originalTick = engine.tick.bind(engine);
+	const engineAny = engine;
+	engineAny.tick = (nowMs) => {
+		ticks.push(nowMs);
+		originalTick(nowMs);
+	};
+	let stopped = false;
+	return { stop() {
+		if (!stopped) {
+			stopped = true;
+			for (const [name, fn] of originals) input[name] = fn;
+			engineAny.tick = originalTick;
+		}
+		return {
+			replay: 1,
+			ticks,
+			events
+		};
+	} };
+}
+/**
+* Drive a fresh engine through a recording: for each recorded tick, feed
+* that tick's input events first, then tick with the recorded timestamp.
+* `onTick(index)` lets tests assert mid-run state.
+*/
+function replay(engine, recording, opts) {
+	const input = engine.input;
+	let cursor = 0;
+	for (let i = 0; i < recording.ticks.length; i++) {
+		while (cursor < recording.events.length && recording.events[cursor][0] === i) {
+			const [, method, ...args] = recording.events[cursor];
+			const fn = input[method];
+			if (typeof fn === "function") fn.apply(engine.input, args);
+			cursor += 1;
+		}
+		engine.tick(recording.ticks[i]);
+		opts?.onTick?.(i);
+	}
+}
+//#endregion
+export { startRecording as n, auditScene as r, replay as t };