@replayablejs/runtime 0.1.0-alpha.0

package/dist/audio/enabled.d.ts

@@ -0,0 +1,28 @@
+import { t as AudioController } from "../audio-CyLjSreN.js";
+import { s as AssetLoader } from "../loader-Czz-x3KH.js";
+//#region src/audio/enabled.d.ts
+/**
+ * Creates Howler-backed sound playback for an audio-enabled variant.
+ *
+ * This controller coordinates three lower-level components:
+ *
+ * - The asset loader turns generated sound URLs into loaded `Howl` instances.
+ * - The lifecycle applies host volume, visibility, and browser-unlock policy.
+ * - Managed playbacks own individual voices, fades, and final cleanup.
+ *
+ * There is only one playback implementation (`ManagedAudioPlayback`).
+ * The two internal collections below represent states of the same type:
+ * 1) `managedPlaybacks` keeps every live handle.
+ * 2) `unresolvedPlaybacks` indexes pending handles still missing a loaded sound.
+ *
+ * A managed `play()` request is retained until both gates open:
+ * - sound is loaded
+ * - runtime audio is allowed
+ *
+ * Either gate can open first. A transient `playOneShot()` is dropped while
+ * audio is blocked, preventing stale effects from playing later.
+ */
+declare function createAudio(loader: AssetLoader): AudioController;
+//#endregion
+export { createAudio };
+//# sourceMappingURL=enabled.d.ts.map

package/dist/audio/enabled.js

@@ -0,0 +1,426 @@
+import { Howl, Howler } from "howler/dist/howler.core.min.js";
+//#region src/audio/howler-lifecycle.ts
+const CONTEXT_RESUME_DELAY_MS = 200;
+/**
+* Coordinates Howler with Replayable's normalized host lifecycle.
+*
+* Howler's automatic suspension is disabled because iOS Safari can leave its
+* `AudioContext` suspended after an ad becomes visible again. The WebKit
+* workaround suspends immediately and schedules an independent resume 200 ms
+* later. The recovery deliberately does not sequence those operations through
+* promise settlement: affected WebKit versions can leave an audio-context
+* transition promise unsettled indefinitely.
+*
+* A subsequent hidden transition cancels the pending resume and suspends the
+* context again, preventing the delayed recovery from starting background
+* audio.
+*
+* @see https://bugs.webkit.org/show_bug.cgi?id=276016
+* @see https://bugs.webkit.org/show_bug.cgi?id=281566
+*/
+function createHowlerLifecycle() {
+	let recoveryTimeout;
+	let visible = false;
+	Howler.autoSuspend = false;
+	Howler.mute(true);
+	return {
+		setVisible(nextVisible) {
+			visible = nextVisible;
+			clearRecoveryTimeout();
+			if (!Howler.usingWebAudio) return;
+			Howler.ctx.suspend().catch(() => {});
+			if (!visible) return;
+			recoveryTimeout = window.setTimeout(() => {
+				recoveryTimeout = void 0;
+				if (!visible) return;
+				Howler.ctx.resume().catch(() => {});
+			}, CONTEXT_RESUME_DELAY_MS);
+		},
+		update({ allowed, volume }, muted) {
+			Howler.volume(volume);
+			Howler.mute(!allowed || muted);
+		},
+		unlock() {
+			if (!Howler.usingWebAudio || Howler.ctx.state === "running") return;
+			Howler.ctx.resume().catch(() => {});
+		}
+	};
+	function clearRecoveryTimeout() {
+		if (recoveryTimeout === void 0) return;
+		window.clearTimeout(recoveryTimeout);
+		recoveryTimeout = void 0;
+	}
+}
+//#endregion
+//#region src/audio/resolve-options.ts
+const DEFAULT_FADE_DURATION = 0;
+const DEFAULT_VOLUME = 1;
+/**
+* Produces the complete options used to create one managed playback.
+*
+* Defaults are applied once at the public API boundary so the playback state
+* machine never needs to distinguish omitted values from explicit values:
+*
+* ```ts
+* resolveAudioPlaybackOptions();
+* // { volume: 1, loop: false, fadeIn: 0 }
+*
+* resolveAudioPlaybackOptions({ loop: true, volume: 0.5 });
+* // { volume: 0.5, loop: true, fadeIn: 0 }
+* ```
+*
+* Invalid numeric values throw before a Howler voice is created.
+*/
+function resolveAudioPlaybackOptions(options = {}) {
+	return {
+		volume: resolveVolume(options.volume),
+		loop: options.loop ?? false,
+		fadeIn: resolveFadeDuration("fade-in", options.fadeIn)
+	};
+}
+/**
+* Produces the complete options used by one transient sound effect.
+*
+* ```ts
+* resolveAudioOneShotOptions();
+* // { volume: 1 }
+*
+* resolveAudioOneShotOptions({ volume: 0.8 });
+* // { volume: 0.8 }
+* ```
+*/
+function resolveAudioOneShotOptions(options = {}) {
+	return { volume: resolveVolume(options.volume) };
+}
+/**
+* Produces the complete options used to stop managed playback.
+*
+* ```ts
+* resolveAudioStopOptions();
+* // { fadeOut: 0 }
+*
+* resolveAudioStopOptions({ fadeOut: 0.4 });
+* // { fadeOut: 0.4 }
+* ```
+*
+* A zero duration stops immediately; a positive duration is converted to
+* milliseconds only when the managed playback calls Howler.
+*/
+function resolveAudioStopOptions(options = {}) {
+	return { fadeOut: resolveFadeDuration("fade-out", options.fadeOut) };
+}
+/**
+* Resolves public volume onto Howler's normalized linear gain range.
+*
+* `Number.isFinite` deliberately rejects `NaN` and both infinities in addition
+* to values outside the inclusive `0..1` range.
+*/
+function resolveVolume(volume = DEFAULT_VOLUME) {
+	if (!Number.isFinite(volume) || volume < 0 || volume > 1) throw new RangeError(`Audio volume must be a finite number from 0 through 1; received ${String(volume)}.`);
+	return volume;
+}
+/**
+* Resolves one public fade duration expressed in Replayable-standard seconds.
+*
+* Keeping seconds in the public API matches Replayable's update and fixed-update
+* timing contracts. Only the Howler integration converts this value to
+* milliseconds. `Number.isFinite` also prevents `NaN` and infinity from
+* reaching browser timers.
+*/
+function resolveFadeDuration(name, duration = DEFAULT_FADE_DURATION) {
+	if (!Number.isFinite(duration) || duration < 0) throw new RangeError(`Audio ${name} duration must be a finite, non-negative number of seconds; received ${String(duration)}.`);
+	return duration;
+}
+//#endregion
+//#region src/audio/managed-playback.ts
+const MILLISECONDS_PER_SECOND = 1e3;
+/**
+* Creates one managed Howler voice that may wait for both its sound and unlock.
+*
+* A playback exists as a single object and moves through this lifecycle:
+*
+* 1. It starts pending, without requiring a loaded sound or allocating a voice.
+* 2. `setSound()` stores the loaded `Howl`; playback is still pending.
+* 3. `start()` allocates one voice and records its ID.
+* 4. A non-looping voice finishes through Howler's `end` event, while a loop
+*    remains active until the application calls `stop()`.
+* 5. Stopping (immediate or faded) removes listeners, stops the exact voice,
+*    and calls `onFinished` so the orchestrator can forget the handle.
+*
+* ```ts
+* const playback = createManagedPlayback({
+*   fadeIn: 0.5,
+*   loop: true,
+*   volume: 0.6,
+* }, removePlayback);
+*
+* playback.setSound(sound);
+* playback.start();
+* playback.stop({ fadeOut: 0.4 });
+* ```
+*
+* Calling `stop()` before `start()` simply finishes the pending handle: no voice
+* is created and later load/unlock events will not restart it. Howler operations
+* are routed by this handle's playback ID so shared source `Howl`s do not mix
+* control.
+*
+* `start` is invoked by the audio controller when loading or permission opens a gate.
+* `stop` is the stable public handle returned to playable application code.
+*/
+function createManagedPlayback(options, onFinished) {
+	let activeVoice;
+	let endListener;
+	let sound;
+	let status = "pending";
+	const playback = {
+		setSound(loadedSound) {
+			if (status !== "pending" || sound !== void 0) return;
+			sound = loadedSound;
+		},
+		start() {
+			if (status !== "pending" || sound === void 0) return;
+			const playbackId = sound.play();
+			activeVoice = {
+				id: playbackId,
+				sound
+			};
+			status = "playing";
+			const fadeInMilliseconds = options.fadeIn * MILLISECONDS_PER_SECOND;
+			const shouldFadeIn = fadeInMilliseconds > 0 && options.volume > 0;
+			sound.volume(shouldFadeIn ? 0 : options.volume, playbackId);
+			sound.loop(options.loop, playbackId);
+			if (shouldFadeIn) sound.fade(0, options.volume, fadeInMilliseconds, playbackId);
+			if (!options.loop) listenForEnd();
+		},
+		stop(stopOptions) {
+			if (status === "stopping" || status === "finished") return;
+			const { fadeOut } = resolveAudioStopOptions(stopOptions);
+			if (activeVoice === void 0 || fadeOut === 0) {
+				finish();
+				return;
+			}
+			status = "stopping";
+			removeEndListener();
+			fadeOutPlayback(fadeOut);
+		}
+	};
+	return playback;
+	/** Stops this voice after fading from its current volume to silence. */
+	function fadeOutPlayback(duration) {
+		if (activeVoice === void 0) return;
+		const { id, sound: activeSound } = activeVoice;
+		const currentVolume = activeSound.volume(id);
+		if (typeof currentVolume !== "number") throw new Error(`Unable to read volume for Howler playback ${id}.`);
+		if (currentVolume === 0) {
+			finish();
+			return;
+		}
+		const handleFade = (fadedPlaybackId) => {
+			if (fadedPlaybackId !== activeVoice?.id) return;
+			finish();
+		};
+		activeSound.fade(currentVolume, 0, duration * MILLISECONDS_PER_SECOND, id);
+		activeSound.once("fade", handleFade, id);
+	}
+	/**
+	* Retires this handle and releases its pending or active Howler voice.
+	*
+	* `onFinished` removes the handle from the orchestrator's retained set. It is
+	* called for pending cancellation, natural completion, and explicit stopping.
+	*/
+	function finish() {
+		status = "finished";
+		stopActivePlayback();
+		onFinished(playback);
+	}
+	/** Lets a finite, non-looping sound release itself after natural completion. */
+	function listenForEnd() {
+		if (activeVoice === void 0) return;
+		const { id, sound: activeSound } = activeVoice;
+		const handleEnd = (endedPlaybackId) => {
+			if (endedPlaybackId !== activeVoice?.id) return;
+			endListener = void 0;
+			finish();
+		};
+		endListener = handleEnd;
+		activeSound.once("end", handleEnd, id);
+	}
+	/**
+	* Stops the active voice and releases Replayable's Howler listeners.
+	*
+	* Howler emits `stop`, not `end`, for this operation. The `end` listener is
+	* removed because its ID-scoped callback is no longer useful and would
+	* otherwise remain retained by the shared `Howl`.
+	*/
+	function stopActivePlayback() {
+		if (activeVoice === void 0) return;
+		const { id, sound: activeSound } = activeVoice;
+		removeEndListener();
+		activeVoice = void 0;
+		activeSound.stop(id);
+	}
+	function removeEndListener() {
+		if (endListener === void 0 || activeVoice === void 0) return;
+		activeVoice.sound.off("end", endListener, activeVoice.id);
+		endListener = void 0;
+	}
+}
+//#endregion
+//#region src/audio/sound-loader.ts
+/** Returns one loaded sound, or `undefined` while its bundle remains unloaded. */
+function getLoadedSound(loader, id) {
+	const sound = loader.cache.sounds?.[id];
+	return sound instanceof Howl ? sound : void 0;
+}
+/**
+* Converts one generated sound URL into a completely loaded Howler sound.
+*
+* Replayable's asset loader calls this handler once for every sound in the
+* requested bundle. Given this context:
+*
+* ```ts
+* {
+*   category: 'sounds',
+*   id: 'ui-click',
+*   source: '/assets/ui-click.m4a',
+* }
+* ```
+*
+* the promise resolves with a `Howl` only after its `load` event. The asset
+* loader then stores that value at `cache.sounds['ui-click']`. Consequently,
+* `loader.load('primary')` does not finish until every primary sound is ready
+* for synchronous `play()` calls.
+*
+* A load failure unloads the partial Howler resource before rejecting the
+* containing bundle load with the generated asset ID in the error message.
+*/
+function loadSound({ id, source }) {
+	return new Promise((resolve, reject) => {
+		const sound = new Howl({
+			preload: false,
+			src: source
+		});
+		const handleLoad = () => {
+			sound.off("loaderror", handleLoadError);
+			resolve(sound);
+		};
+		const handleLoadError = (_soundId, error) => {
+			sound.off("load", handleLoad);
+			sound.unload();
+			reject(/* @__PURE__ */ new Error(`Unable to load sound ${JSON.stringify(id)}: ${String(error)}.`));
+		};
+		sound.once("load", handleLoad);
+		sound.once("loaderror", handleLoadError);
+		sound.load();
+	});
+}
+//#endregion
+//#region src/audio/enabled.ts
+/**
+* Creates Howler-backed sound playback for an audio-enabled variant.
+*
+* This controller coordinates three lower-level components:
+*
+* - The asset loader turns generated sound URLs into loaded `Howl` instances.
+* - The lifecycle applies host volume, visibility, and browser-unlock policy.
+* - Managed playbacks own individual voices, fades, and final cleanup.
+*
+* There is only one playback implementation (`ManagedAudioPlayback`).
+* The two internal collections below represent states of the same type:
+* 1) `managedPlaybacks` keeps every live handle.
+* 2) `unresolvedPlaybacks` indexes pending handles still missing a loaded sound.
+*
+* A managed `play()` request is retained until both gates open:
+* - sound is loaded
+* - runtime audio is allowed
+*
+* Either gate can open first. A transient `playOneShot()` is dropped while
+* audio is blocked, preventing stale effects from playing later.
+*/
+function createAudio(loader) {
+	const lifecycle = createHowlerLifecycle();
+	const managedPlaybacks = /* @__PURE__ */ new Set();
+	const unresolvedPlaybacks = /* @__PURE__ */ new Map();
+	let allowed = false;
+	let muted = false;
+	let runtimeState;
+	loader.register("sounds", async (context) => {
+		const sound = await loadSound(context);
+		resolveSound(context.id, sound);
+		return sound;
+	});
+	return {
+		get muted() {
+			return muted;
+		},
+		setMuted(nextMuted) {
+			if (muted === nextMuted) return;
+			muted = nextMuted;
+			if (runtimeState !== void 0) lifecycle.update(runtimeState, muted);
+		},
+		play(id, options) {
+			const playback = createManagedPlayback(resolveAudioPlaybackOptions(options), (finishedPlayback) => {
+				removeManagedPlayback(id, finishedPlayback);
+			});
+			const sound = getLoadedSound(loader, id);
+			if (sound === void 0) retainUnresolvedPlayback(id, playback);
+			else playback.setSound(sound);
+			managedPlaybacks.add(playback);
+			startIfAllowed(playback);
+			return playback;
+		},
+		playOneShot(id, options) {
+			if (!allowed) return;
+			const sound = getLoadedSound(loader, id);
+			if (sound === void 0) return;
+			const { volume } = resolveAudioOneShotOptions(options);
+			const playbackId = sound.play();
+			sound.volume(volume, playbackId);
+		},
+		setVisible(visible) {
+			lifecycle.setVisible(visible);
+		},
+		update(state) {
+			const becameAllowed = !allowed && state.allowed;
+			allowed = state.allowed;
+			runtimeState = state;
+			lifecycle.update(state, muted);
+			if (becameAllowed) for (const playback of managedPlaybacks) playback.start();
+		},
+		unlock() {
+			lifecycle.unlock();
+		}
+	};
+	/** Tracks a pending request until the sound loader resolves this asset ID. */
+	function retainUnresolvedPlayback(id, playback) {
+		const playbacks = unresolvedPlaybacks.get(id) ?? /* @__PURE__ */ new Set();
+		playbacks.add(playback);
+		unresolvedPlaybacks.set(id, playbacks);
+	}
+	/** Binds every pending playback for this sound ID to its loaded `Howl`. */
+	function resolveSound(id, sound) {
+		const playbacks = unresolvedPlaybacks.get(id);
+		if (playbacks === void 0) return;
+		unresolvedPlaybacks.delete(id);
+		for (const playback of playbacks) {
+			playback.setSound(sound);
+			startIfAllowed(playback);
+		}
+	}
+	/** Starts a managed handle only when permission is already allowed. */
+	function startIfAllowed(playback) {
+		if (allowed) playback.start();
+	}
+	/** Removes the handle from both registries; pending index only if still unresolved. */
+	function removeManagedPlayback(id, playback) {
+		managedPlaybacks.delete(playback);
+		const playbacks = unresolvedPlaybacks.get(id);
+		if (playbacks === void 0) return;
+		playbacks.delete(playback);
+		if (playbacks.size === 0) unresolvedPlaybacks.delete(id);
+	}
+}
+//#endregion
+export { createAudio };
+
+//# sourceMappingURL=enabled.js.map

package/dist/audio/enabled.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enabled.js","names":[],"sources":["../../src/audio/howler-lifecycle.ts","../../src/audio/resolve-options.ts","../../src/audio/managed-playback.ts","../../src/audio/sound-loader.ts","../../src/audio/enabled.ts"],"sourcesContent":["import { Howler } from '#audio/howler.js';\nimport type { RuntimeAudioState } from '#types/audio.js';\n\nconst CONTEXT_RESUME_DELAY_MS = 200;\n\n/**\n * Coordinates Howler with Replayable's normalized host lifecycle.\n *\n * Howler's automatic suspension is disabled because iOS Safari can leave its\n * `AudioContext` suspended after an ad becomes visible again. The WebKit\n * workaround suspends immediately and schedules an independent resume 200 ms\n * later. The recovery deliberately does not sequence those operations through\n * promise settlement: affected WebKit versions can leave an audio-context\n * transition promise unsettled indefinitely.\n *\n * A subsequent hidden transition cancels the pending resume and suspends the\n * context again, preventing the delayed recovery from starting background\n * audio.\n *\n * @see https://bugs.webkit.org/show_bug.cgi?id=276016\n * @see https://bugs.webkit.org/show_bug.cgi?id=281566\n */\nexport function createHowlerLifecycle() {\n  let recoveryTimeout: number | undefined;\n  let visible = false;\n\n  Howler.autoSuspend = false;\n  Howler.mute(true);\n\n  return {\n    setVisible(nextVisible: boolean): void {\n      visible = nextVisible;\n      clearRecoveryTimeout();\n\n      if (!Howler.usingWebAudio) {\n        return;\n      }\n\n      // Do not await this promise. The following resume must remain\n      // independently scheduled rather than depending on WebKit settling the\n      // preceding audio-context transition.\n      void Howler.ctx.suspend().catch(() => {\n        // The context may already be closed or unavailable.\n      });\n\n      if (!visible) {\n        return;\n      }\n\n      // WebKit's published reproduction uses 200 ms to let the visibility\n      // transition settle before attempting to resume the context.\n      recoveryTimeout = window.setTimeout(() => {\n        recoveryTimeout = undefined;\n\n        if (!visible) {\n          return;\n        }\n\n        void Howler.ctx.resume().catch(() => {\n          // A later trusted interaction or visibility transition can retry.\n        });\n      }, CONTEXT_RESUME_DELAY_MS);\n    },\n\n    update({ allowed, volume }: RuntimeAudioState, muted: boolean): void {\n      Howler.volume(volume);\n      Howler.mute(!allowed || muted);\n    },\n\n    unlock(): void {\n      if (!Howler.usingWebAudio || Howler.ctx.state === 'running') {\n        return;\n      }\n\n      // Invocation—not promise settlement—must occur in the trusted event task.\n      // Howler also installs an unlock listener; this explicit attempt makes the\n      // runtime contract independent of that internal implementation detail.\n      void Howler.ctx.resume().catch(() => {\n        // A later trusted interaction or visibility recovery can retry.\n      });\n    },\n  };\n\n  function clearRecoveryTimeout(): void {\n    if (recoveryTimeout === undefined) {\n      return;\n    }\n\n    window.clearTimeout(recoveryTimeout);\n    recoveryTimeout = undefined;\n  }\n}\n","import type { AudioOneShotOptions, AudioPlaybackOptions, AudioStopOptions } from '#types/audio.js';\n\nconst DEFAULT_FADE_DURATION = 0;\nconst DEFAULT_VOLUME = 1;\n\n/**\n * Produces the complete options used to create one managed playback.\n *\n * Defaults are applied once at the public API boundary so the playback state\n * machine never needs to distinguish omitted values from explicit values:\n *\n * ```ts\n * resolveAudioPlaybackOptions();\n * // { volume: 1, loop: false, fadeIn: 0 }\n *\n * resolveAudioPlaybackOptions({ loop: true, volume: 0.5 });\n * // { volume: 0.5, loop: true, fadeIn: 0 }\n * ```\n *\n * Invalid numeric values throw before a Howler voice is created.\n */\nexport function resolveAudioPlaybackOptions(\n  options: AudioPlaybackOptions = {},\n): Required<AudioPlaybackOptions> {\n  return {\n    volume: resolveVolume(options.volume),\n    loop: options.loop ?? false,\n    fadeIn: resolveFadeDuration('fade-in', options.fadeIn),\n  };\n}\n\n/**\n * Produces the complete options used by one transient sound effect.\n *\n * ```ts\n * resolveAudioOneShotOptions();\n * // { volume: 1 }\n *\n * resolveAudioOneShotOptions({ volume: 0.8 });\n * // { volume: 0.8 }\n * ```\n */\nexport function resolveAudioOneShotOptions(\n  options: AudioOneShotOptions = {},\n): Required<AudioOneShotOptions> {\n  return {\n    volume: resolveVolume(options.volume),\n  };\n}\n\n/**\n * Produces the complete options used to stop managed playback.\n *\n * ```ts\n * resolveAudioStopOptions();\n * // { fadeOut: 0 }\n *\n * resolveAudioStopOptions({ fadeOut: 0.4 });\n * // { fadeOut: 0.4 }\n * ```\n *\n * A zero duration stops immediately; a positive duration is converted to\n * milliseconds only when the managed playback calls Howler.\n */\nexport function resolveAudioStopOptions(\n  options: AudioStopOptions = {},\n): Required<AudioStopOptions> {\n  return {\n    fadeOut: resolveFadeDuration('fade-out', options.fadeOut),\n  };\n}\n\n/**\n * Resolves public volume onto Howler's normalized linear gain range.\n *\n * `Number.isFinite` deliberately rejects `NaN` and both infinities in addition\n * to values outside the inclusive `0..1` range.\n */\nfunction resolveVolume(volume = DEFAULT_VOLUME): number {\n  if (!Number.isFinite(volume) || volume < 0 || volume > 1) {\n    throw new RangeError(\n      `Audio volume must be a finite number from 0 through 1; received ${String(volume)}.`,\n    );\n  }\n\n  return volume;\n}\n\n/**\n * Resolves one public fade duration expressed in Replayable-standard seconds.\n *\n * Keeping seconds in the public API matches Replayable's update and fixed-update\n * timing contracts. Only the Howler integration converts this value to\n * milliseconds. `Number.isFinite` also prevents `NaN` and infinity from\n * reaching browser timers.\n */\nfunction resolveFadeDuration(\n  name: 'fade-in' | 'fade-out',\n  duration = DEFAULT_FADE_DURATION,\n): number {\n  if (!Number.isFinite(duration) || duration < 0) {\n    throw new RangeError(\n      `Audio ${name} duration must be a finite, non-negative number of seconds; received ${String(duration)}.`,\n    );\n  }\n\n  return duration;\n}\n","import type { Howl, HowlCallback } from '#audio/howler.js';\nimport { resolveAudioStopOptions } from '#audio/resolve-options.js';\nimport type {\n  PlaybackStatus,\n  ActiveVoice,\n  AudioPlaybackOptions,\n  AudioStopOptions,\n  ManagedAudioPlayback,\n} from '#types/audio.js';\n\nconst MILLISECONDS_PER_SECOND = 1000;\n\n/**\n * Creates one managed Howler voice that may wait for both its sound and unlock.\n *\n * A playback exists as a single object and moves through this lifecycle:\n *\n * 1. It starts pending, without requiring a loaded sound or allocating a voice.\n * 2. `setSound()` stores the loaded `Howl`; playback is still pending.\n * 3. `start()` allocates one voice and records its ID.\n * 4. A non-looping voice finishes through Howler's `end` event, while a loop\n *    remains active until the application calls `stop()`.\n * 5. Stopping (immediate or faded) removes listeners, stops the exact voice,\n *    and calls `onFinished` so the orchestrator can forget the handle.\n *\n * ```ts\n * const playback = createManagedPlayback({\n *   fadeIn: 0.5,\n *   loop: true,\n *   volume: 0.6,\n * }, removePlayback);\n *\n * playback.setSound(sound);\n * playback.start();\n * playback.stop({ fadeOut: 0.4 });\n * ```\n *\n * Calling `stop()` before `start()` simply finishes the pending handle: no voice\n * is created and later load/unlock events will not restart it. Howler operations\n * are routed by this handle's playback ID so shared source `Howl`s do not mix\n * control.\n *\n * `start` is invoked by the audio controller when loading or permission opens a gate.\n * `stop` is the stable public handle returned to playable application code.\n */\nexport function createManagedPlayback(\n  options: Required<AudioPlaybackOptions>,\n  onFinished: (playback: ManagedAudioPlayback) => void,\n): ManagedAudioPlayback {\n  let activeVoice: ActiveVoice | undefined;\n  let endListener: HowlCallback | undefined;\n  let sound: Howl | undefined;\n  let status: PlaybackStatus = 'pending';\n\n  const playback: ManagedAudioPlayback = {\n    setSound(loadedSound): void {\n      if (status !== 'pending' || sound !== undefined) {\n        return;\n      }\n\n      sound = loadedSound;\n    },\n\n    start(): void {\n      if (status !== 'pending' || sound === undefined) {\n        return;\n      }\n\n      // Howler returns a new ID for this voice even when another handle is\n      // already playing the same source sound.\n      const playbackId = sound.play();\n\n      activeVoice = { id: playbackId, sound };\n      status = 'playing';\n\n      const fadeInMilliseconds = options.fadeIn * MILLISECONDS_PER_SECOND;\n      const shouldFadeIn = fadeInMilliseconds > 0 && options.volume > 0;\n\n      // Volume and looping are scoped to this ID rather than the shared Howl.\n      sound.volume(shouldFadeIn ? 0 : options.volume, playbackId);\n      sound.loop(options.loop, playbackId);\n\n      if (shouldFadeIn) {\n        sound.fade(0, options.volume, fadeInMilliseconds, playbackId);\n      }\n\n      if (!options.loop) {\n        listenForEnd();\n      }\n    },\n\n    stop(stopOptions?: AudioStopOptions): void {\n      if (status === 'stopping' || status === 'finished') {\n        return;\n      }\n\n      const { fadeOut } = resolveAudioStopOptions(stopOptions);\n\n      if (activeVoice === undefined || fadeOut === 0) {\n        finish();\n\n        return;\n      }\n\n      // The handle rejects repeated commands while the underlying voice remains\n      // audible until its fade completes.\n      status = 'stopping';\n      removeEndListener();\n      fadeOutPlayback(fadeOut);\n    },\n  };\n\n  return playback;\n\n  /** Stops this voice after fading from its current volume to silence. */\n  function fadeOutPlayback(duration: number): void {\n    if (activeVoice === undefined) {\n      return;\n    }\n\n    const { id, sound: activeSound } = activeVoice;\n    const currentVolume = activeSound.volume(id);\n\n    if (typeof currentVolume !== 'number') {\n      throw new Error(`Unable to read volume for Howler playback ${id}.`);\n    }\n\n    if (currentVolume === 0) {\n      finish();\n\n      return;\n    }\n\n    const handleFade = (fadedPlaybackId: number): void => {\n      if (fadedPlaybackId !== activeVoice?.id) {\n        return;\n      }\n\n      finish();\n    };\n\n    // Starting the new fade first replaces an in-progress fade-in. Howler emits\n    // `fade` when cancelling that old transition, so Replayable subscribes only\n    // after the replacement begins and waits for the fade-out itself.\n    activeSound.fade(currentVolume, 0, duration * MILLISECONDS_PER_SECOND, id);\n    activeSound.once('fade', handleFade, id);\n  }\n\n  /**\n   * Retires this handle and releases its pending or active Howler voice.\n   *\n   * `onFinished` removes the handle from the orchestrator's retained set. It is\n   * called for pending cancellation, natural completion, and explicit stopping.\n   */\n  function finish(): void {\n    status = 'finished';\n    stopActivePlayback();\n    onFinished(playback);\n  }\n\n  /** Lets a finite, non-looping sound release itself after natural completion. */\n  function listenForEnd(): void {\n    if (activeVoice === undefined) {\n      return;\n    }\n\n    const { id, sound: activeSound } = activeVoice;\n    const handleEnd = (endedPlaybackId: number): void => {\n      if (endedPlaybackId !== activeVoice?.id) {\n        return;\n      }\n\n      endListener = undefined;\n      finish();\n    };\n\n    endListener = handleEnd;\n    activeSound.once('end', handleEnd, id);\n  }\n\n  /**\n   * Stops the active voice and releases Replayable's Howler listeners.\n   *\n   * Howler emits `stop`, not `end`, for this operation. The `end` listener is\n   * removed because its ID-scoped callback is no longer useful and would\n   * otherwise remain retained by the shared `Howl`.\n   */\n  function stopActivePlayback(): void {\n    if (activeVoice === undefined) {\n      return;\n    }\n\n    const { id, sound: activeSound } = activeVoice;\n\n    removeEndListener();\n    activeVoice = undefined;\n    activeSound.stop(id);\n  }\n\n  function removeEndListener(): void {\n    if (endListener === undefined || activeVoice === undefined) {\n      return;\n    }\n\n    activeVoice.sound.off('end', endListener, activeVoice.id);\n    endListener = undefined;\n  }\n}\n","import { Howl, type HowlErrorCallback } from '#audio/howler.js';\nimport type { AssetLoadContext, AssetLoader } from '#types/loader.js';\n\n/** Returns one loaded sound, or `undefined` while its bundle remains unloaded. */\nexport function getLoadedSound(loader: AssetLoader, id: string): Howl | undefined {\n  const sound = loader.cache.sounds?.[id];\n\n  return sound instanceof Howl ? sound : undefined;\n}\n\n/**\n * Converts one generated sound URL into a completely loaded Howler sound.\n *\n * Replayable's asset loader calls this handler once for every sound in the\n * requested bundle. Given this context:\n *\n * ```ts\n * {\n *   category: 'sounds',\n *   id: 'ui-click',\n *   source: '/assets/ui-click.m4a',\n * }\n * ```\n *\n * the promise resolves with a `Howl` only after its `load` event. The asset\n * loader then stores that value at `cache.sounds['ui-click']`. Consequently,\n * `loader.load('primary')` does not finish until every primary sound is ready\n * for synchronous `play()` calls.\n *\n * A load failure unloads the partial Howler resource before rejecting the\n * containing bundle load with the generated asset ID in the error message.\n */\nexport function loadSound({ id, source }: AssetLoadContext<'sounds'>): Promise<Howl> {\n  return new Promise((resolve, reject) => {\n    // Manual loading lets Replayable attach both terminal listeners before any\n    // network or data-URL decoding work can complete.\n    const sound = new Howl({ preload: false, src: source });\n\n    const handleLoad = (): void => {\n      // The opposite terminal event can no longer occur for this load. Removing\n      // it releases the settled promise closure retained by the cached Howl.\n      sound.off('loaderror', handleLoadError);\n      resolve(sound);\n    };\n\n    const handleLoadError: HowlErrorCallback = (_soundId, error): void => {\n      sound.off('load', handleLoad);\n\n      // Release any partially allocated HTMLAudio or Web Audio resources.\n      sound.unload();\n      reject(new Error(`Unable to load sound ${JSON.stringify(id)}: ${String(error)}.`));\n    };\n\n    sound.once('load', handleLoad);\n    sound.once('loaderror', handleLoadError);\n    sound.load();\n  });\n}\n","import { createHowlerLifecycle } from '#audio/howler-lifecycle.js';\nimport type { Howl } from '#audio/howler.js';\nimport { createManagedPlayback } from '#audio/managed-playback.js';\nimport { resolveAudioOneShotOptions, resolveAudioPlaybackOptions } from '#audio/resolve-options.js';\nimport { getLoadedSound, loadSound } from '#audio/sound-loader.js';\nimport type {\n  AudioController,\n  AudioPlayback,\n  ManagedAudioPlayback,\n  RuntimeAudioState,\n} from '#types/audio.js';\nimport type { AssetLoader } from '#types/loader.js';\n\n/**\n * Creates Howler-backed sound playback for an audio-enabled variant.\n *\n * This controller coordinates three lower-level components:\n *\n * - The asset loader turns generated sound URLs into loaded `Howl` instances.\n * - The lifecycle applies host volume, visibility, and browser-unlock policy.\n * - Managed playbacks own individual voices, fades, and final cleanup.\n *\n * There is only one playback implementation (`ManagedAudioPlayback`).\n * The two internal collections below represent states of the same type:\n * 1) `managedPlaybacks` keeps every live handle.\n * 2) `unresolvedPlaybacks` indexes pending handles still missing a loaded sound.\n *\n * A managed `play()` request is retained until both gates open:\n * - sound is loaded\n * - runtime audio is allowed\n *\n * Either gate can open first. A transient `playOneShot()` is dropped while\n * audio is blocked, preventing stale effects from playing later.\n */\nexport function createAudio(loader: AssetLoader): AudioController {\n  const lifecycle = createHowlerLifecycle();\n  // All live handles from `play()`: pending or active.\n  const managedPlaybacks = new Set<ManagedAudioPlayback>();\n  // Pending-by-sound-id index for quick binding when a sound finishes loading.\n  const unresolvedPlaybacks = new Map<string, Set<ManagedAudioPlayback>>();\n  let allowed = false;\n  let muted = false;\n  let runtimeState: RuntimeAudioState | undefined;\n\n  // Registering this loader callback keeps primary/secondary asset timing safe.\n  loader.register('sounds', async (context) => {\n    const sound = await loadSound(context);\n\n    resolveSound(context.id, sound);\n\n    return sound;\n  });\n\n  return {\n    get muted(): boolean {\n      return muted;\n    },\n\n    setMuted(nextMuted): void {\n      if (muted === nextMuted) {\n        return;\n      }\n\n      muted = nextMuted;\n\n      if (runtimeState !== undefined) {\n        lifecycle.update(runtimeState, muted);\n      }\n    },\n\n    play(id, options): AudioPlayback {\n      const resolvedOptions = resolveAudioPlaybackOptions(options);\n      const playback = createManagedPlayback(resolvedOptions, (finishedPlayback) => {\n        removeManagedPlayback(id, finishedPlayback);\n      });\n      const sound = getLoadedSound(loader, id);\n\n      if (sound === undefined) {\n        retainUnresolvedPlayback(id, playback);\n      } else {\n        playback.setSound(sound);\n      }\n\n      managedPlaybacks.add(playback);\n\n      // `start()` re-checks gates for both already-ready and newly-ready cases.\n      startIfAllowed(playback);\n\n      return playback;\n    },\n\n    playOneShot(id, options): void {\n      // A one-shot has no retained handle: blocked effects are intentionally\n      // discarded rather than queued and replayed out of context later.\n      if (!allowed) {\n        return;\n      }\n\n      const sound = getLoadedSound(loader, id);\n\n      // Unloaded one-shots are dropped intentionally and are never deferred.\n      if (sound === undefined) {\n        return;\n      }\n\n      const { volume } = resolveAudioOneShotOptions(options);\n      const playbackId = sound.play();\n\n      sound.volume(volume, playbackId);\n    },\n\n    setVisible(visible): void {\n      lifecycle.setVisible(visible);\n    },\n\n    update(state): void {\n      const becameAllowed = !allowed && state.allowed;\n      allowed = state.allowed;\n      runtimeState = state;\n\n      // Howler volume and global muting are updated before any deferred voice\n      // starts. Existing managed voices keep the same playback ID while blocked;\n      // visibility policy may suspend their shared audio context, but Replayable\n      // never stops and recreates them during an allowed-state transition.\n      lifecycle.update(state, muted);\n\n      if (becameAllowed) {\n        // Start any pending voices; active voices ignore repeated start attempts.\n        for (const playback of managedPlaybacks) {\n          playback.start();\n        }\n      }\n    },\n\n    unlock(): void {\n      lifecycle.unlock();\n    },\n  };\n\n  /** Tracks a pending request until the sound loader resolves this asset ID. */\n  function retainUnresolvedPlayback(id: string, playback: ManagedAudioPlayback): void {\n    const playbacks = unresolvedPlaybacks.get(id) ?? new Set();\n\n    playbacks.add(playback);\n    unresolvedPlaybacks.set(id, playbacks);\n  }\n\n  /** Binds every pending playback for this sound ID to its loaded `Howl`. */\n  function resolveSound(id: string, sound: Howl): void {\n    const playbacks = unresolvedPlaybacks.get(id);\n\n    if (playbacks === undefined) {\n      return;\n    }\n\n    // Remove the index entry before notifying playbacks; a callback can clean up\n    // the same playback while handling its own completion.\n    unresolvedPlaybacks.delete(id);\n\n    for (const playback of playbacks) {\n      playback.setSound(sound);\n      startIfAllowed(playback);\n    }\n  }\n\n  /** Starts a managed handle only when permission is already allowed. */\n  function startIfAllowed(playback: ManagedAudioPlayback): void {\n    if (allowed) {\n      playback.start();\n    }\n  }\n\n  /** Removes the handle from both registries; pending index only if still unresolved. */\n  function removeManagedPlayback(id: string, playback: ManagedAudioPlayback): void {\n    managedPlaybacks.delete(playback);\n\n    const playbacks = unresolvedPlaybacks.get(id);\n\n    if (playbacks === undefined) {\n      return;\n    }\n\n    playbacks.delete(playback);\n\n    if (playbacks.size === 0) {\n      unresolvedPlaybacks.delete(id);\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/audio-CyLjSreN.d.ts

@@ -0,0 +1,66 @@
+import "howler/dist/howler.core.min.js";
+//#region src/types/audio.d.ts
+/** Options for one transient sound effect. */
+interface AudioOneShotOptions {
+  /** Playback volume from silent (`0`) to full source volume (`1`). */
+  readonly volume?: number;
+}
+/** Options for one managed sound playback. */
+interface AudioPlaybackOptions {
+  /** Playback volume from silent (`0`) to full source volume (`1`). */
+  readonly volume?: number;
+  /** Repeats the sound until its playback handle is stopped. */
+  readonly loop?: boolean;
+  /** Seconds spent fading from silence to the configured volume. */
+  readonly fadeIn?: number;
+}
+/** Options for stopping managed sound playback. */
+interface AudioStopOptions {
+  /** Seconds spent fading from the current volume to silence before stopping. */
+  readonly fadeOut?: number;
+}
+/** Controls one managed playback while pending or active. */
+interface AudioPlayback {
+  /** Cancels deferred start or stops the active sound. */
+  stop(options?: AudioStopOptions): void;
+}
+/** Capability-aware sound playback exposed to playable application code. */
+interface PlayableAudio {
+  /** Whether application audio is currently muted by the playable itself. */
+  readonly muted: boolean;
+  /** Changes application mute state without stopping active managed playback. */
+  setMuted(muted: boolean): void;
+  /**
+   * Creates managed playback that starts after loading and audio permission.
+   *
+   * The returned handle remains valid while deferred, so `stop()` before both
+   * conditions are met cancels the pending sound.
+   */
+  play(id: string, options?: AudioPlaybackOptions): AudioPlayback;
+  /**
+   * Plays one transient effect immediately, or drops it when unavailable.
+   *
+   * Dropping blocked or unloaded one-shots prevents stale sounds from replaying
+   * after later load/unlock.
+   */
+  playOneShot(id: string, options?: AudioOneShotOptions): void;
+}
+/** Effective audio conditions derived from capability and host lifecycle state. */
+interface RuntimeAudioState {
+  /** Whether sounds may currently be audible. */
+  readonly allowed: boolean;
+  /** Host-provided volume normalized from silent (`0`) to full volume (`1`). */
+  readonly volume: number;
+}
+/** Internal audio facade controls retained by the runtime lifecycle. */
+interface AudioController extends PlayableAudio {
+  /** Applies a host visibility transition to the underlying audio context. */
+  setVisible(visible: boolean): void;
+  /** Applies the latest effective host and interaction conditions. */
+  update(state: RuntimeAudioState): void;
+  /** Unlocks browser audio synchronously inside the first trusted interaction. */
+  unlock(): void;
+}
+//#endregion
+export { AudioStopOptions as a, AudioPlaybackOptions as i, AudioOneShotOptions as n, PlayableAudio as o, AudioPlayback as r, RuntimeAudioState as s, AudioController as t };
+//# sourceMappingURL=audio-CyLjSreN.d.ts.map

package/dist/categories-BbQSRMmw.js

@@ -0,0 +1,21 @@
+//#region src/assets/categories.ts
+/** Categories produced from one selected source file per logical asset. */
+const simpleAssetCategories = [
+	"sprites",
+	"textures",
+	"sounds",
+	"fonts",
+	"locales"
+];
+/** Categories assembled from several related source files. */
+const groupedAssetCategories = [
+	"atlases",
+	"spines",
+	"shaders"
+];
+/** Every generated asset category understood by the playable runtime. */
+const assetCategories = [...simpleAssetCategories, ...groupedAssetCategories];
+//#endregion
+export { groupedAssetCategories as n, simpleAssetCategories as r, assetCategories as t };
+
+//# sourceMappingURL=categories-BbQSRMmw.js.map

package/dist/categories-BbQSRMmw.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"categories-BbQSRMmw.js","names":[],"sources":["../src/assets/categories.ts"],"sourcesContent":["/** Categories produced from one selected source file per logical asset. */\nexport const simpleAssetCategories = ['sprites', 'textures', 'sounds', 'fonts', 'locales'] as const;\n\n/** Categories assembled from several related source files. */\nexport const groupedAssetCategories = ['atlases', 'spines', 'shaders'] as const;\n\n/** Every generated asset category understood by the playable runtime. */\nexport const assetCategories = [...simpleAssetCategories, ...groupedAssetCategories] as const;\n"],"mappings":";;AACA,MAAa,wBAAwB;CAAC;CAAW;CAAY;CAAU;CAAS;AAAS;;AAGzF,MAAa,yBAAyB;CAAC;CAAW;CAAU;AAAS;;AAGrE,MAAa,kBAAkB,CAAC,GAAG,uBAAuB,GAAG,sBAAsB"}

package/dist/create-adapter-4oub3UeP.js

@@ -0,0 +1,22 @@
+import { a as waitForDocumentReady, n as createBrowserSnapshot, t as subscribeToBrowserUpdates } from "./events-C85TpS5f.js";
+//#region src/adapters/browser/create-adapter.ts
+/**
+* Creates a browser-backed host adapter with caller-provided store behavior.
+*
+* Preview and browser-based network adapters share document readiness,
+* visibility, and viewport handling. Only their click-through APIs differ.
+*/
+function createBrowserAdapter(openStore) {
+	return {
+		async initialize(listener) {
+			await waitForDocumentReady();
+			subscribeToBrowserUpdates(listener);
+			return createBrowserSnapshot();
+		},
+		openStore
+	};
+}
+//#endregion
+export { createBrowserAdapter as t };
+
+//# sourceMappingURL=create-adapter-4oub3UeP.js.map

package/dist/create-adapter-4oub3UeP.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-adapter-4oub3UeP.js","names":[],"sources":["../src/adapters/browser/create-adapter.ts"],"sourcesContent":["import type { HostAdapter, HostSnapshot } from '#types/host-adapter.js';\n\nimport { createBrowserSnapshot, waitForDocumentReady } from './api.js';\nimport { subscribeToBrowserUpdates } from './events.js';\n\n/**\n * Creates a browser-backed host adapter with caller-provided store behavior.\n *\n * Preview and browser-based network adapters share document readiness,\n * visibility, and viewport handling. Only their click-through APIs differ.\n */\nexport function createBrowserAdapter(openStore: HostAdapter['openStore']): HostAdapter {\n  return {\n    async initialize(listener): Promise<HostSnapshot> {\n      await waitForDocumentReady();\n\n      subscribeToBrowserUpdates(listener);\n\n      return createBrowserSnapshot();\n    },\n\n    openStore,\n  };\n}\n"],"mappings":";;;;;;;;AAWA,SAAgB,qBAAqB,WAAkD;CACrF,OAAO;EACL,MAAM,WAAW,UAAiC;GAChD,MAAM,qBAAqB;GAE3B,0BAA0B,QAAQ;GAElC,OAAO,sBAAsB;EAC/B;EAEA;CACF;AACF"}

package/dist/create-adapter-ByJx4UTX.js

@@ -0,0 +1,43 @@
+import { i as waitForMraidReady, n as readMraidViewport, r as requireMraid, t as subscribeToMraidUpdates } from "./events-CYG_LvaH.js";
+//#region src/mraid/create-adapter.ts
+/**
+* Creates the standard MRAID host behavior shared by networks whose CTA opens
+* the authored store URL directly through `mraid.open(url)`.
+*/
+function createMraidHostAdapter() {
+	return {
+		async initialize(listener) {
+			requireMraid();
+			await waitForMraidReady();
+			subscribeToMraidUpdates(listener);
+			subscribeToBrowserViewportChanges(listener);
+			return {
+				visible: mraid.isViewable(),
+				viewport: readMraidViewport(),
+				volume: 1
+			};
+		},
+		openStore(url) {
+			requireMraid();
+			mraid.open(url);
+		}
+	};
+}
+/**
+* Supplements MRAID sizeChange with browser signals emitted by host WebViews
+* during device rotation. Runtime state deduplicates equivalent dimensions.
+*/
+function subscribeToBrowserViewportChanges(listener) {
+	const handleViewportChange = () => {
+		listener({
+			type: "resize",
+			viewport: readMraidViewport()
+		});
+	};
+	window.addEventListener("resize", handleViewportChange);
+	window.addEventListener("orientationchange", handleViewportChange);
+}
+//#endregion
+export { createMraidHostAdapter as t };
+
+//# sourceMappingURL=create-adapter-ByJx4UTX.js.map